2000-05-08 Michael Snyder <msnyder@seadog.cygnus.com>

        * gdbarch.sh: Add FP0_REGNUM to list of multi-arched register numbers.
        * gdbarch.c, gdbarch.h: Regenerate.
        * core-regset.c: Change FP0_REGNUM to a runtime test.
        * procfs.c: Ditto.
        * sun3-nat.c: Ditto.
        * sparc-tdep.c: Ditto.

        * i386mach-nat.c: Remove unnecessary ifdef for FP0_REGNUM.
        * ptx4-nat.c: Ditto.

        * sol-thread.c (sol_thread_create_inferior): only add the thread
        to the thread list if it is not already in there.
        (prototypes for thread_db func ptrs): pretty up formatting.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index df55d95a32e223b00104844cbaae1e6df37e97a3..faf01da412aef5abd59c8e899752a9743908eae2 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,15 @@
 2000-05-08  Michael Snyder  <msnyder@seadog.cygnus.com>
 
+       * gdbarch.sh: Add FP0_REGNUM to list of multi-arched register numbers.
+       * gdbarch.c, gdbarch.h: Regenerate.
+       * core-regset.c: Change FP0_REGNUM to a runtime test.
+       * procfs.c: Ditto.
+       * sun3-nat.c: Ditto.
+       * sparc-tdep.c: Ditto.
+       
+       * i386mach-nat.c: Remove unnecessary ifdef for FP0_REGNUM.
+       * ptx4-nat.c: Ditto.
+
        * sol-thread.c (sol_thread_create_inferior): only add the thread
        to the thread list if it is not already in there.
        (prototypes for thread_db func ptrs): pretty up formatting.

diff --git a/gdb/core-regset.c b/gdb/core-regset.c
index 8f96c0f1842a73932dacd154273d883421e6090c..36880276b8a48208b2789e5af4af88f158deadc2 100644 (file)
--- a/gdb/core-regset.c
+++ b/gdb/core-regset.c
@@ -109,9 +109,8 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
       else
        {
          memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset));
-#if defined (FP0_REGNUM)
-         supply_fpregset (&fpregset);
-#endif
+         if (FP0_REGNUM >= 0)
+           supply_fpregset (&fpregset);
        }
     }
 #endif /* defined(HAVE_GREGSET_T) && defined (HAVE_FPREGSET_T) */

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 17bed5cab32da5296cd9e3cdce017fa04470c576..4cfb8bc05580fd36dc4584e29a4964f4c3a7c8e5 100644 (file)
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -146,6 +146,7 @@ struct gdbarch
   int sp_regnum;
   int fp_regnum;
   int pc_regnum;
+  int fp0_regnum;
   int npc_regnum;
   int nnpc_regnum;
   gdbarch_register_name_ftype *register_name;
@@ -283,6 +284,7 @@ struct gdbarch startup_gdbarch = {
   0,
   0,
   0,
+  0,
   generic_get_saved_register,
   0,
   0,
@@ -353,6 +355,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
   gdbarch->sp_regnum = -1;
   gdbarch->fp_regnum = -1;
   gdbarch->pc_regnum = -1;
+  gdbarch->fp0_regnum = -1;
   gdbarch->npc_regnum = -1;
   gdbarch->nnpc_regnum = -1;
   gdbarch->register_name = legacy_register_name;
@@ -472,6 +475,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
   if ((GDB_MULTI_ARCH >= 2)
       && (gdbarch->pc_regnum == -1))
     internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
+  /* Skip verify of fp0_regnum, invalid_p == 0 */
   /* Skip verify of npc_regnum, invalid_p == 0 */
   /* Skip verify of nnpc_regnum, invalid_p == 0 */
   /* Skip verify of register_name, invalid_p == 0 */
@@ -711,6 +715,9 @@ gdbarch_dump (void)
   fprintf_unfiltered (gdb_stdlog,
                       "gdbarch_update: PC_REGNUM = %ld\n",
                       (long) PC_REGNUM);
+  fprintf_unfiltered (gdb_stdlog,
+                      "gdbarch_update: FP0_REGNUM = %ld\n",
+                      (long) FP0_REGNUM);
   fprintf_unfiltered (gdb_stdlog,
                       "gdbarch_update: NPC_REGNUM = %ld\n",
                       (long) NPC_REGNUM);
@@ -1348,6 +1355,22 @@ set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
   gdbarch->pc_regnum = pc_regnum;
 }
 
+int
+gdbarch_fp0_regnum (struct gdbarch *gdbarch)
+{
+  /* Skip verify of fp0_regnum, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
+  return gdbarch->fp0_regnum;
+}
+
+void
+set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
+                        int fp0_regnum)
+{
+  gdbarch->fp0_regnum = fp0_regnum;
+}
+
 int
 gdbarch_npc_regnum (struct gdbarch *gdbarch)
 {

diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 7ccad0a1184231ba3242a1e93e4561add8b38edb..dde7c515ed8b05b8ecee7d5b9ea9e70cb2fd2c1e 100644 (file)
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -263,6 +263,19 @@ extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
 #endif
 #endif
 
+/* Default (value) for non- multi-arch platforms. */
+#if (GDB_MULTI_ARCH == 0) && !defined (FP0_REGNUM)
+#define FP0_REGNUM (-1)
+#endif
+
+extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
+extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
+#if GDB_MULTI_ARCH
+#if (GDB_MULTI_ARCH > 1) || !defined (FP0_REGNUM)
+#define FP0_REGNUM (gdbarch_fp0_regnum (current_gdbarch))
+#endif
+#endif
+
 /* Default (value) for non- multi-arch platforms. */
 #if (GDB_MULTI_ARCH == 0) && !defined (NPC_REGNUM)
 #define NPC_REGNUM (-1)

diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 892d61f86ac0cf1aa17ac77e1129f8fc4af33fd0..6026ca167845e922db66c7da8a40459f2d422866 100755 (executable)
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -241,6 +241,7 @@ v:2:NUM_REGS:int:num_regs::::0:-1
 v:2:SP_REGNUM:int:sp_regnum::::0:-1
 v:2:FP_REGNUM:int:fp_regnum::::0:-1
 v:2:PC_REGNUM:int:pc_regnum::::0:-1
+v:2:FP0_REGNUM:int:fp0_regnum::::0:-1:0
 v:2:NPC_REGNUM:int:npc_regnum::::0:-1:0
 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1:0
 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name:0

diff --git a/gdb/i386mach-nat.c b/gdb/i386mach-nat.c
index 5ecb103022a2c54ac07bff912d2746c0c6fc7fad..cd1e1fe17a75e7c9c59eabeadecad90a6c9c06e3 100644 (file)
--- a/gdb/i386mach-nat.c
+++ b/gdb/i386mach-nat.c
@@ -129,11 +129,9 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
       break;
 
     case 2:
-#ifdef FP0_REGNUM
       memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)],
              core_reg_sect,
              core_reg_size);   /* FIXME, probably bogus */
-#endif
 #ifdef FPC_REGNUM
       memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
              &corestr.c_fpu.f_fpstatus.f_ctrl,

diff --git a/gdb/procfs.c b/gdb/procfs.c
index 1a6c9472fd517b13f2726e10eb9d35f7d191ee7e..2fa825b41bc3a6b8a567d3f8b85fbb821e437b53 100644 (file)
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -3502,19 +3502,20 @@ procfs_fetch_registers (regno)
 
   supply_gregset (gregs);
 
-#if defined (FP0_REGNUM)       /* need floating point? */
-  if ((regno >= 0 && regno < FP0_REGNUM) ||
-      regno == PC_REGNUM  ||
-      (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
-      regno == FP_REGNUM  ||
-      regno == SP_REGNUM)
-    return;                    /* not a floating point register */
+  if (FP0_REGNUM >= 0) /* need floating point? */
+    {
+      if ((regno >= 0 && regno < FP0_REGNUM) ||
+         regno == PC_REGNUM  ||
+         (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
+         regno == FP_REGNUM  ||
+         regno == SP_REGNUM)
+       return;                 /* not a floating point register */
 
-  if ((fpregs = proc_get_fpregs (pi)) == NULL)
-    proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
+      if ((fpregs = proc_get_fpregs (pi)) == NULL)
+       proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
 
-  supply_fpregset (fpregs);
-#endif
+      supply_fpregset (fpregs);
+    }
 }
 
 /* Get ready to modify the registers array.  On machines which store
@@ -3576,21 +3577,22 @@ procfs_store_registers (regno)
   if (!proc_set_gregs (pi))
     proc_error (pi, "store_registers, set_gregs", __LINE__);
 
-#if defined (FP0_REGNUM)       /* need floating point? */
-  if ((regno >= 0 && regno < FP0_REGNUM) ||
-      regno == PC_REGNUM  ||
-      (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
-      regno == FP_REGNUM  ||
-      regno == SP_REGNUM)
-    return;                    /* not a floating point register */
-
-  if ((fpregs = proc_get_fpregs (pi)) == NULL)
-    proc_error (pi, "store_registers, get_fpregs", __LINE__);
-
-  fill_fpregset (fpregs, regno);
-  if (!proc_set_fpregs (pi))
-    proc_error (pi, "store_registers, set_fpregs", __LINE__);
-#endif
+  if (FP0_REGNUM >= 0)         /* need floating point? */
+    {
+      if ((regno >= 0 && regno < FP0_REGNUM) ||
+         regno == PC_REGNUM  ||
+         (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
+         regno == FP_REGNUM  ||
+         regno == SP_REGNUM)
+       return;                 /* not a floating point register */
+
+      if ((fpregs = proc_get_fpregs (pi)) == NULL)
+       proc_error (pi, "store_registers, get_fpregs", __LINE__);
+
+      fill_fpregset (fpregs, regno);
+      if (!proc_set_fpregs (pi))
+       proc_error (pi, "store_registers, set_fpregs", __LINE__);
+    }
 }
 
 /*
@@ -4111,14 +4113,13 @@ invalidate_cache (parent, pi, ptr)
       if (!proc_set_gregs (pi))        /* flush gregs cache */
        proc_warn (pi, "target_resume, set_gregs",
                   __LINE__);
-#ifdef FP0_REGNUM
-  if (pi->fpregs_dirty)
-    if (parent == NULL ||
-       proc_get_current_thread (parent) != pi->tid)
-      if (!proc_set_fpregs (pi))       /* flush fpregs cache */
-       proc_warn (pi, "target_resume, set_fpregs", 
-                  __LINE__);
-#endif
+  if (FP0_REGNUM >= 0)
+    if (pi->fpregs_dirty)
+      if (parent == NULL ||
+         proc_get_current_thread (parent) != pi->tid)
+       if (!proc_set_fpregs (pi))      /* flush fpregs cache */
+         proc_warn (pi, "target_resume, set_fpregs", 
+                    __LINE__);
 #endif
 
   if (parent != NULL)

diff --git a/gdb/ptx4-nat.c b/gdb/ptx4-nat.c
index 9640d283eba5cd7e2145fdd318d537e463566b62..a7acee271498beb2a8dc9ac4c0a2dc1b618bac94 100644 (file)
--- a/gdb/ptx4-nat.c
+++ b/gdb/ptx4-nat.c
@@ -62,8 +62,6 @@ fill_gregset (gregsetp, regno)
     }
 }
 
-#if defined (FP0_REGNUM)
-
 /*  Given a pointer to a floating point register set in /proc format
    (fpregset_t *), unpack the register contents and supply them as gdb's
    idea of the current floating point register values. */
@@ -93,8 +91,6 @@ fill_fpregset (fpregsetp, regno)
   /* FIXME: see m68k-tdep.c for an example, for the m68k. */
 }
 
-#endif /* defined (FP0_REGNUM) */
-
 /*
  * This doesn't quite do the same thing as the procfs.c version, but give
  * it the same name so we don't have to put an ifdef in solib.c.

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index ed6245c0e59453ebb3b11f7793573efd5acfafe9..ceac8027badc7696ba3a9d38569e50e31f297674 100644 (file)
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -44,8 +44,12 @@
 
 #ifdef GDB_TARGET_IS_SPARC64
 #define FP_REGISTER_BYTES (64 * 4)
-#else
+#else 
+#if (SPARC_HAS_FPU)
 #define FP_REGISTER_BYTES (32 * 4)
+#else
+#define FP_REGISTER_BYTES 0
+#endif
 #endif
 
 /* If not defined, assume 32 bit sparc.  */
@@ -749,16 +753,16 @@ sparc_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
          else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
            addr = frame1->frame + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
              - (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
-#ifdef FP0_REGNUM
-         else if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
+         else if (FP0_REGNUM >= 0 &&
+                  regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
            addr = frame1->frame + (regnum - FP0_REGNUM) * 4
              - (FP_REGISTER_BYTES);
 #ifdef GDB_TARGET_IS_SPARC64
-         else if (regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
+         else if (FP0_REGNUM >= 0 &&
+                  regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
            addr = frame1->frame + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
              - (FP_REGISTER_BYTES);
 #endif
-#endif /* FP0_REGNUM */
          else if (regnum >= Y_REGNUM && regnum < NUM_REGS)
            addr = frame1->frame + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
              - (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
@@ -849,13 +853,8 @@ sparc_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 #endif
 
 /* See tm-sparc.h for how this is calculated.  */
-#ifdef FP0_REGNUM
 #define DUMMY_STACK_REG_BUF_SIZE \
-(((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
-#else
-#define DUMMY_STACK_REG_BUF_SIZE \
-(((8+8+8) * SPARC_INTREG_SIZE) )
-#endif /* FP0_REGNUM */
+     (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
 #define DUMMY_STACK_SIZE (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
 
 void
@@ -887,11 +886,10 @@ sparc_push_dummy_frame ()
                       &register_temp[16 * SPARC_INTREG_SIZE],
                       SPARC_INTREG_SIZE * 8);
 
-#ifdef FP0_REGNUM
-  read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
-                      &register_temp[24 * SPARC_INTREG_SIZE],
-                      FP_REGISTER_BYTES);
-#endif /* FP0_REGNUM */
+  if (FP0_REGNUM >= 0)
+    read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+                        &register_temp[24 * SPARC_INTREG_SIZE],
+                        FP_REGISTER_BYTES);
 
   sp -= DUMMY_STACK_SIZE;
 
@@ -991,18 +989,20 @@ sparc_frame_find_saved_regs (fi, saved_regs_addr)
        saved_regs_addr->regs[regnum] =
          frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
          - DUMMY_STACK_REG_BUF_SIZE + 8 * SPARC_INTREG_SIZE;
-#ifdef FP0_REGNUM
-      for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 32; regnum++)
-       saved_regs_addr->regs[regnum] =
-         frame_addr + (regnum - FP0_REGNUM) * 4
-         - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
+      if (FP0_REGNUM >= 0)
+       {
+         for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 32; regnum++)
+           saved_regs_addr->regs[regnum] =
+             frame_addr + (regnum - FP0_REGNUM) * 4
+             - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
 #ifdef GDB_TARGET_IS_SPARC64
-      for (regnum = FP0_REGNUM + 32; regnum < FP_MAX_REGNUM; regnum++)
-       saved_regs_addr->regs[regnum] =
-         frame_addr + 32 * 4 + (regnum - FP0_REGNUM - 32) * 4
-         - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
+         for (regnum = FP0_REGNUM + 32; regnum < FP_MAX_REGNUM; regnum++)
+           saved_regs_addr->regs[regnum] =
+             frame_addr + 32 * 4 + (regnum - FP0_REGNUM - 32) * 4
+             - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
 #endif
-#endif /* FP0_REGNUM */
+       }
+
 #ifdef GDB_TARGET_IS_SPARC64
       for (regnum = PC_REGNUM; regnum < PC_REGNUM + 7; regnum++)
        {
@@ -1094,26 +1094,27 @@ sparc_pop_frame ()
   int regnum;
 
   sparc_frame_find_saved_regs (frame, &fsr);
-#ifdef FP0_REGNUM
-  if (fsr.regs[FP0_REGNUM])
+  if (FP0_REGNUM >= 0)
     {
-      read_memory (fsr.regs[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
-      write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
-                           raw_buffer, FP_REGISTER_BYTES);
-    }
+      if (fsr.regs[FP0_REGNUM])
+       {
+         read_memory (fsr.regs[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
+         write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+                               raw_buffer, FP_REGISTER_BYTES);
+       }
 #ifndef GDB_TARGET_IS_SPARC64
-  if (fsr.regs[FPS_REGNUM])
-    {
-      read_memory (fsr.regs[FPS_REGNUM], raw_buffer, 4);
-      write_register_bytes (REGISTER_BYTE (FPS_REGNUM), raw_buffer, 4);
-    }
-  if (fsr.regs[CPS_REGNUM])
-    {
-      read_memory (fsr.regs[CPS_REGNUM], raw_buffer, 4);
-      write_register_bytes (REGISTER_BYTE (CPS_REGNUM), raw_buffer, 4);
-    }
+      if (fsr.regs[FPS_REGNUM])
+       {
+         read_memory (fsr.regs[FPS_REGNUM], raw_buffer, 4);
+         write_register_bytes (REGISTER_BYTE (FPS_REGNUM), raw_buffer, 4);
+       }
+      if (fsr.regs[CPS_REGNUM])
+       {
+         read_memory (fsr.regs[CPS_REGNUM], raw_buffer, 4);
+         write_register_bytes (REGISTER_BYTE (CPS_REGNUM), raw_buffer, 4);
+       }
 #endif
-#endif /* FP0_REGNUM */
+    }
   if (fsr.regs[G1_REGNUM])
     {
       read_memory (fsr.regs[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
@@ -1388,8 +1389,6 @@ fill_gregset (gregsetp, regno)
     }
 }
 
-#if defined (FP0_REGNUM)
-
 /*  Given a pointer to a floating point register set in /proc format
    (fpregset_t *), unpack the register contents and supply them as gdb's
    idea of the current floating point register values. */
@@ -1401,6 +1400,9 @@ supply_fpregset (fpregsetp)
   register int regi;
   char *from;
 
+  if (FP0_REGNUM < 0)
+    return;
+
   for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
     {
       from = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
@@ -1424,6 +1426,9 @@ fill_fpregset (fpregsetp, regno)
   char *to;
   char *from;
 
+  if (FP0_REGNUM < 0)
+    return;
+
   for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
     {
       if ((regno == -1) || (regno == regi))
@@ -1439,8 +1444,6 @@ fill_fpregset (fpregsetp, regno)
     }
 }
 
-#endif /* defined (FP0_REGNUM) */
-
 #endif /* USE_PROC_FS */
 
 

diff --git a/gdb/sun3-nat.c b/gdb/sun3-nat.c
index 1e878caefd8c1226d5debe63b4c136d5ca6a7a43..8e5e16fd18272123e8c1b0b3c4e2f295fbc31ea1 100644 (file)
--- a/gdb/sun3-nat.c
+++ b/gdb/sun3-nat.c
@@ -33,31 +33,29 @@ fetch_inferior_registers (regno)
      int regno;
 {
   struct regs inferior_registers;
-#ifdef FP0_REGNUM
   struct fp_status inferior_fp_registers;
-#endif
 
   registers_fetched ();
 
   ptrace (PTRACE_GETREGS, inferior_pid,
          (PTRACE_ARG3_TYPE) & inferior_registers);
-#ifdef FP0_REGNUM
-  ptrace (PTRACE_GETFPREGS, inferior_pid,
-         (PTRACE_ARG3_TYPE) & inferior_fp_registers);
-#endif
+
+  if (FP0_REGNUM >= 0)
+    ptrace (PTRACE_GETFPREGS, inferior_pid,
+           (PTRACE_ARG3_TYPE) & inferior_fp_registers);
 
   memcpy (registers, &inferior_registers, 16 * 4);
-#ifdef FP0_REGNUM
-  memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
-         sizeof inferior_fp_registers.fps_regs);
-#endif
+  if (FP0_REGNUM >= 0)
+    memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+           sizeof inferior_fp_registers.fps_regs);
+
   *(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
   *(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
-#ifdef FP0_REGNUM
-  memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
-         &inferior_fp_registers.fps_control,
-      sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
-#endif
+  if (FP0_REGNUM >= 0)
+    memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
+           &inferior_fp_registers.fps_control,
+           sizeof inferior_fp_registers - 
+           sizeof inferior_fp_registers.fps_regs);
 }
 
 /* Store our register values back into the inferior.
@@ -69,30 +67,27 @@ store_inferior_registers (regno)
      int regno;
 {
   struct regs inferior_registers;
-#ifdef FP0_REGNUM
   struct fp_status inferior_fp_registers;
-#endif
 
   memcpy (&inferior_registers, registers, 16 * 4);
-#ifdef FP0_REGNUM
-  memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
-         sizeof inferior_fp_registers.fps_regs);
-#endif
+  if (FP0_REGNUM >= 0)
+    memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
+           sizeof inferior_fp_registers.fps_regs);
+
   inferior_registers.r_ps = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)];
   inferior_registers.r_pc = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
 
-#ifdef FP0_REGNUM
-  memcpy (&inferior_fp_registers.fps_control,
-         &registers[REGISTER_BYTE (FPC_REGNUM)],
-      sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
-#endif
+  if (FP0_REGNUM >= 0)
+    memcpy (&inferior_fp_registers.fps_control,
+           &registers[REGISTER_BYTE (FPC_REGNUM)],
+           sizeof inferior_fp_registers - 
+           sizeof inferior_fp_registers.fps_regs);
 
   ptrace (PTRACE_SETREGS, inferior_pid,
          (PTRACE_ARG3_TYPE) & inferior_registers);
-#if FP0_REGNUM
-  ptrace (PTRACE_SETFPREGS, inferior_pid,
-         (PTRACE_ARG3_TYPE) & inferior_fp_registers);
-#endif
+  if (FP0_REGNUM >= 0)
+    ptrace (PTRACE_SETFPREGS, inferior_pid,
+           (PTRACE_ARG3_TYPE) & inferior_fp_registers);
 }
 
 
@@ -125,18 +120,20 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 
       if (core_reg_size >= sizeof (struct fpu))
        {
-#ifdef FP0_REGNUM
-         memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)],
-                 fpustruct->f_fpstatus.fps_regs,
-                 sizeof fpustruct->f_fpstatus.fps_regs);
-         memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
-                 &fpustruct->f_fpstatus.fps_control,
-                 sizeof fpustruct->f_fpstatus -
-                 sizeof fpustruct->f_fpstatus.fps_regs);
-#endif
+         if (FP0_REGNUM >= 0)
+           {
+             memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)],
+                     fpustruct->f_fpstatus.fps_regs,
+                     sizeof fpustruct->f_fpstatus.fps_regs);
+             memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
+                     &fpustruct->f_fpstatus.fps_control,
+                     sizeof fpustruct->f_fpstatus -
+                     sizeof fpustruct->f_fpstatus.fps_regs);
+           }
        }
       else
-       fprintf_unfiltered (gdb_stderr, "Couldn't read float regs from core file\n");
+       fprintf_unfiltered (gdb_stderr, 
+                           "Couldn't read float regs from core file\n");
     }
 }
 \f