gdb

[deliverable/binutils-gdb.git] / gdb / i387-tdep.c

diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index 703ca2f1aa0550769aa4e9a7262736f5964c3a48..3fb5b56f4cf805d7522faf65307f5feade1f57c2 100644 (file)
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -1,13 +1,14 @@
 /* Intel 387 floating point stuff.
 
 /* Intel 387 floating point stuff.
 

-   Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000,
-   2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000, 2001,
+   2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
+   Free Software Foundation, Inc.

 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "doublest.h"
 
 #include "defs.h"
 #include "doublest.h"


@@ -39,7 +38,8 @@
 /* Print the floating point number specified by RAW.  */
 
 static void
 /* Print the floating point number specified by RAW.  */
 
 static void

-print_i387_value (const gdb_byte *raw, struct ui_file *file)
+print_i387_value (struct gdbarch *gdbarch,
+                 const gdb_byte *raw, struct ui_file *file)

 {
   DOUBLEST value;
 
 {
   DOUBLEST value;
 


@@ -47,7 +47,7 @@ print_i387_value (const gdb_byte *raw, struct ui_file *file)
      of certain numbers such as NaNs, even if GDB is running natively.
      This is fine since our caller already detects such special
      numbers and we print the hexadecimal representation anyway.  */
      of certain numbers such as NaNs, even if GDB is running natively.
      This is fine since our caller already detects such special
      numbers and we print the hexadecimal representation anyway.  */

-  value = extract_typed_floating (raw, builtin_type_i387_ext);
+  value = extract_typed_floating (raw, i387_ext_type (gdbarch));

 
   /* We try to print 19 digits.  The last digit may or may not contain
      garbage, but we'd better print one too many.  We need enough room
 
   /* We try to print 19 digits.  The last digit may or may not contain
      garbage, but we'd better print one too many.  We need enough room


@@ -63,7 +63,8 @@ print_i387_value (const gdb_byte *raw, struct ui_file *file)
 /* Print the classification for the register contents RAW.  */
 
 static void
 /* Print the classification for the register contents RAW.  */
 
 static void

-print_i387_ext (const gdb_byte *raw, struct ui_file *file)
+print_i387_ext (struct gdbarch *gdbarch,
+               const gdb_byte *raw, struct ui_file *file)

 {
   int sign;
   int integer;
 {
   int sign;
   int integer;


@@ -94,11 +95,11 @@ print_i387_ext (const gdb_byte *raw, struct ui_file *file)
     }
   else if (exponent < 0x7fff && exponent > 0x0000 && integer)
     /* Normal.  */
     }
   else if (exponent < 0x7fff && exponent > 0x0000 && integer)
     /* Normal.  */

-    print_i387_value (raw, file);
+    print_i387_value (gdbarch, raw, file);

   else if (exponent == 0x0000)
     {
       /* Denormal or zero.  */
   else if (exponent == 0x0000)
     {
       /* Denormal or zero.  */

-      print_i387_value (raw, file);
+      print_i387_value (gdbarch, raw, file);

       
       if (integer)
        /* Pseudo-denormal.  */
       
       if (integer)
        /* Pseudo-denormal.  */


@@ -217,18 +218,14 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
 
   gdb_assert (gdbarch == get_frame_arch (frame));
 
 
   gdb_assert (gdbarch == get_frame_arch (frame));
 

-  /* Define I387_ST0_REGNUM such that we use the proper definitions
-     for FRAME's architecture.  */
-#define I387_ST0_REGNUM tdep->st0_regnum
-
-  fctrl = get_frame_register_unsigned (frame, I387_FCTRL_REGNUM);
-  fstat = get_frame_register_unsigned (frame, I387_FSTAT_REGNUM);
-  ftag = get_frame_register_unsigned (frame, I387_FTAG_REGNUM);
-  fiseg = get_frame_register_unsigned (frame, I387_FISEG_REGNUM);
-  fioff = get_frame_register_unsigned (frame, I387_FIOFF_REGNUM);
-  foseg = get_frame_register_unsigned (frame, I387_FOSEG_REGNUM);
-  fooff = get_frame_register_unsigned (frame, I387_FOOFF_REGNUM);
-  fop = get_frame_register_unsigned (frame, I387_FOP_REGNUM);
+  fctrl = get_frame_register_unsigned (frame, I387_FCTRL_REGNUM (tdep));
+  fstat = get_frame_register_unsigned (frame, I387_FSTAT_REGNUM (tdep));
+  ftag = get_frame_register_unsigned (frame, I387_FTAG_REGNUM (tdep));
+  fiseg = get_frame_register_unsigned (frame, I387_FISEG_REGNUM (tdep));
+  fioff = get_frame_register_unsigned (frame, I387_FIOFF_REGNUM (tdep));
+  foseg = get_frame_register_unsigned (frame, I387_FOSEG_REGNUM (tdep));
+  fooff = get_frame_register_unsigned (frame, I387_FOOFF_REGNUM (tdep));
+  fop = get_frame_register_unsigned (frame, I387_FOP_REGNUM (tdep));

 
   top = ((fstat >> 11) & 7);
 
 
   top = ((fstat >> 11) & 7);
 


@@ -256,14 +253,15 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
          break;
        }
 
          break;
        }
 

-      get_frame_register (frame, (fpreg + 8 - top) % 8 + I387_ST0_REGNUM, raw);
+      get_frame_register (frame, (fpreg + 8 - top) % 8 + I387_ST0_REGNUM (tdep),
+                         raw);

 
       fputs_filtered ("0x", file);
       for (i = 9; i >= 0; i--)
        fprintf_filtered (file, "%02x", raw[i]);
 
       if (tag != 3)
 
       fputs_filtered ("0x", file);
       for (i = 9; i >= 0; i--)
        fprintf_filtered (file, "%02x", raw[i]);
 
       if (tag != 3)

-       print_i387_ext (raw, file);
+       print_i387_ext (gdbarch, raw, file);

 
       fputs_filtered ("\n", file);
     }
 
       fputs_filtered ("\n", file);
     }


@@ -282,11 +280,28 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
   fprintf_filtered (file, "%s\n", hex_string_custom (fooff, 8));
   fprintf_filtered (file, "Opcode:              %s\n",
                    hex_string_custom (fop ? (fop | 0xd800) : 0, 4));
   fprintf_filtered (file, "%s\n", hex_string_custom (fooff, 8));
   fprintf_filtered (file, "Opcode:              %s\n",
                    hex_string_custom (fop ? (fop | 0xd800) : 0, 4));

-
-#undef I387_ST0_REGNUM

 }
 \f
 
 }
 \f
 

+/* Return nonzero if a value of type TYPE stored in register REGNUM
+   needs any special handling.  */
+
+int
+i387_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
+{
+  if (i386_fp_regnum_p (gdbarch, regnum))
+    {
+      /* Floating point registers must be converted unless we are
+        accessing them in their hardware type.  */
+      if (type == i387_ext_type (gdbarch))
+       return 0;
+      else
+       return 1;
+    }
+
+  return 0;
+}
+

 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
    return its contents in TO.  */
 
 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
    return its contents in TO.  */
 


@@ -294,9 +309,10 @@ void
 i387_register_to_value (struct frame_info *frame, int regnum,
                        struct type *type, gdb_byte *to)
 {
 i387_register_to_value (struct frame_info *frame, int regnum,
                        struct type *type, gdb_byte *to)
 {

+  struct gdbarch *gdbarch = get_frame_arch (frame);

   gdb_byte from[I386_MAX_REGISTER_SIZE];
 
   gdb_byte from[I386_MAX_REGISTER_SIZE];
 

-  gdb_assert (i386_fp_regnum_p (regnum));
+  gdb_assert (i386_fp_regnum_p (gdbarch, regnum));

 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)


@@ -306,10 +322,9 @@ i387_register_to_value (struct frame_info *frame, int regnum,
       return;
     }
 
       return;
     }
 

-  /* Convert to TYPE.  This should be a no-op if TYPE is equivalent to
-     the extended floating-point format used by the FPU.  */
+  /* Convert to TYPE.  */

   get_frame_register (frame, regnum, from);
   get_frame_register (frame, regnum, from);

-  convert_typed_floating (from, builtin_type_i387_ext, to, type);
+  convert_typed_floating (from, i387_ext_type (gdbarch), to, type);

 }
 
 /* Write the contents FROM of a value of type TYPE into register
 }
 
 /* Write the contents FROM of a value of type TYPE into register


@@ -319,9 +334,10 @@ void
 i387_value_to_register (struct frame_info *frame, int regnum,
                        struct type *type, const gdb_byte *from)
 {
 i387_value_to_register (struct frame_info *frame, int regnum,
                        struct type *type, const gdb_byte *from)
 {

+  struct gdbarch *gdbarch = get_frame_arch (frame);

   gdb_byte to[I386_MAX_REGISTER_SIZE];
 
   gdb_byte to[I386_MAX_REGISTER_SIZE];
 

-  gdb_assert (i386_fp_regnum_p (regnum));
+  gdb_assert (i386_fp_regnum_p (gdbarch, regnum));

 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)


@@ -331,9 +347,8 @@ i387_value_to_register (struct frame_info *frame, int regnum,
       return;
     }
 
       return;
     }
 

-  /* Convert from TYPE.  This should be a no-op if TYPE is equivalent
-     to the extended floating-point format used by the FPU.  */
-  convert_typed_floating (from, type, to, builtin_type_i387_ext);
+  /* Convert from TYPE.  */
+  convert_typed_floating (from, type, to, i387_ext_type (gdbarch));

   put_frame_register (frame, regnum, to);
 }
 \f
   put_frame_register (frame, regnum, to);
 }
 \f


@@ -364,8 +379,8 @@ static int fsave_offset[] =
   18                           /* `fop' (bottom 11 bits).  */
 };
 
   18                           /* `fop' (bottom 11 bits).  */
 };
 

-#define FSAVE_ADDR(fsave, regnum) \
-  (fsave + fsave_offset[regnum - I387_ST0_REGNUM])
+#define FSAVE_ADDR(tdep, fsave, regnum) \
+  (fsave + fsave_offset[regnum - I387_ST0_REGNUM (tdep)])

 \f
 
 /* Fill register REGNUM in REGCACHE with the appropriate value from
 \f
 
 /* Fill register REGNUM in REGCACHE with the appropriate value from


@@ -375,19 +390,15 @@ static int fsave_offset[] =
 void
 i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
 {
 void
 i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   const gdb_byte *regs = fsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
 
   const gdb_byte *regs = fsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
 

-  /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
-     proper definitions for REGCACHE's architecture.  */
-
-#define I387_ST0_REGNUM tdep->st0_regnum
-#define I387_NUM_XMM_REGS tdep->num_xmm_regs
-
-  for (i = I387_ST0_REGNUM; i < I387_XMM0_REGNUM; i++)
+  for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)

     if (regnum == -1 || regnum == i)
       {
        if (fsave == NULL)
     if (regnum == -1 || regnum == i)
       {
        if (fsave == NULL)


@@ -398,35 +409,32 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
 
        /* Most of the FPU control registers occupy only 16 bits in the
           fsave area.  Give those a special treatment.  */
 
        /* Most of the FPU control registers occupy only 16 bits in the
           fsave area.  Give those a special treatment.  */

-       if (i >= I387_FCTRL_REGNUM
-           && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM)
+       if (i >= I387_FCTRL_REGNUM (tdep)
+           && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))

          {
            gdb_byte val[4];
 
          {
            gdb_byte val[4];
 

-           memcpy (val, FSAVE_ADDR (regs, i), 2);
+           memcpy (val, FSAVE_ADDR (tdep, regs, i), 2);

            val[2] = val[3] = 0;
            val[2] = val[3] = 0;

-           if (i == I387_FOP_REGNUM)
+           if (i == I387_FOP_REGNUM (tdep))

              val[1] &= ((1 << 3) - 1);
            regcache_raw_supply (regcache, i, val);
          }
        else
              val[1] &= ((1 << 3) - 1);
            regcache_raw_supply (regcache, i, val);
          }
        else

-         regcache_raw_supply (regcache, i, FSAVE_ADDR (regs, i));
+         regcache_raw_supply (regcache, i, FSAVE_ADDR (tdep, regs, i));

       }
 
   /* Provide dummy values for the SSE registers.  */
       }
 
   /* Provide dummy values for the SSE registers.  */

-  for (i = I387_XMM0_REGNUM; i < I387_MXCSR_REGNUM; i++)
+  for (i = I387_XMM0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)

     if (regnum == -1 || regnum == i)
       regcache_raw_supply (regcache, i, NULL);
     if (regnum == -1 || regnum == i)
       regcache_raw_supply (regcache, i, NULL);

-  if (regnum == -1 || regnum == I387_MXCSR_REGNUM)
+  if (regnum == -1 || regnum == I387_MXCSR_REGNUM (tdep))

     {
       gdb_byte buf[4];
 
     {
       gdb_byte buf[4];
 

-      store_unsigned_integer (buf, 4, 0x1f80);
-      regcache_raw_supply (regcache, I387_MXCSR_REGNUM, buf);
+      store_unsigned_integer (buf, 4, byte_order, 0x1f80);
+      regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf);

     }
     }

-
-#undef I387_ST0_REGNUM
-#undef I387_NUM_XMM_REGS

 }
 
 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
 }
 
 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE


@@ -437,52 +445,36 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
 void
 i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
 {
 void
 i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

   gdb_byte *regs = fsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
 
   gdb_byte *regs = fsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
 

-  /* Define I387_ST0_REGNUM such that we use the proper definitions
-     for REGCACHE's architecture.  */
-#define I387_ST0_REGNUM tdep->st0_regnum
-
-  for (i = I387_ST0_REGNUM; i < I387_XMM0_REGNUM; i++)
+  for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)

     if (regnum == -1 || regnum == i)
       {
        /* Most of the FPU control registers occupy only 16 bits in
            the fsave area.  Give those a special treatment.  */
     if (regnum == -1 || regnum == i)
       {
        /* Most of the FPU control registers occupy only 16 bits in
            the fsave area.  Give those a special treatment.  */

-       if (i >= I387_FCTRL_REGNUM
-           && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM)
+       if (i >= I387_FCTRL_REGNUM (tdep)
+           && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))

          {
            gdb_byte buf[4];
 
            regcache_raw_collect (regcache, i, buf);
 
          {
            gdb_byte buf[4];
 
            regcache_raw_collect (regcache, i, buf);
 

-           if (i == I387_FOP_REGNUM)
+           if (i == I387_FOP_REGNUM (tdep))

              {
                /* The opcode occupies only 11 bits.  Make sure we
                    don't touch the other bits.  */
                buf[1] &= ((1 << 3) - 1);
              {
                /* The opcode occupies only 11 bits.  Make sure we
                    don't touch the other bits.  */
                buf[1] &= ((1 << 3) - 1);

-               buf[1] |= ((FSAVE_ADDR (regs, i))[1] & ~((1 << 3) - 1));
+               buf[1] |= ((FSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));

              }
              }

-           memcpy (FSAVE_ADDR (regs, i), buf, 2);
+           memcpy (FSAVE_ADDR (tdep, regs, i), buf, 2);

          }
        else
          }
        else

-         regcache_raw_collect (regcache, i, FSAVE_ADDR (regs, i));
+         regcache_raw_collect (regcache, i, FSAVE_ADDR (tdep, regs, i));

       }
       }

-#undef I387_ST0_REGNUM
-}
-
-/* Fill register REGNUM (if it is a floating-point register) in *FSAVE
-   with the value in GDB's register cache.  If REGNUM is -1, do this
-   for all registers.  This function doesn't touch any of the reserved
-   bits in *FSAVE.  */
-
-void
-i387_fill_fsave (void *fsave, int regnum)
-{
-  i387_collect_fsave (current_regcache, regnum, fsave);

 }
 \f
 
 }
 \f
 


@@ -526,8 +518,8 @@ static int fxsave_offset[] =
   160 + 15 * 16,               /* ... %xmm15 (128 bits each).  */
 };
 
   160 + 15 * 16,               /* ... %xmm15 (128 bits each).  */
 };
 

-#define FXSAVE_ADDR(fxsave, regnum) \
-  (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM])
+#define FXSAVE_ADDR(tdep, fxsave, regnum) \
+  (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM (tdep)])

 
 /* We made an unfortunate choice in putting %mxcsr after the SSE
    registers %xmm0-%xmm7 instead of before, since it makes supporting
 
 /* We made an unfortunate choice in putting %mxcsr after the SSE
    registers %xmm0-%xmm7 instead of before, since it makes supporting


@@ -553,13 +545,7 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
   gdb_assert (tdep->num_xmm_regs > 0);
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
   gdb_assert (tdep->num_xmm_regs > 0);
 

-  /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
-     proper definitions for REGCACHE's architecture.  */
-
-#define I387_ST0_REGNUM        tdep->st0_regnum
-#define I387_NUM_XMM_REGS tdep->num_xmm_regs
-
-  for (i = I387_ST0_REGNUM; i < I387_MXCSR_REGNUM; i++)
+  for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)

     if (regnum == -1 || regnum == i)
       {
        if (regs == NULL)
     if (regnum == -1 || regnum == i)
       {
        if (regs == NULL)


@@ -570,16 +556,16 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
 
        /* Most of the FPU control registers occupy only 16 bits in
           the fxsave area.  Give those a special treatment.  */
 
        /* Most of the FPU control registers occupy only 16 bits in
           the fxsave area.  Give those a special treatment.  */

-       if (i >= I387_FCTRL_REGNUM && i < I387_XMM0_REGNUM
-           && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM)
+       if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep)
+           && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))

          {
            gdb_byte val[4];
 
          {
            gdb_byte val[4];
 

-           memcpy (val, FXSAVE_ADDR (regs, i), 2);
+           memcpy (val, FXSAVE_ADDR (tdep, regs, i), 2);

            val[2] = val[3] = 0;
            val[2] = val[3] = 0;

-           if (i == I387_FOP_REGNUM)
+           if (i == I387_FOP_REGNUM (tdep))

              val[1] &= ((1 << 3) - 1);
              val[1] &= ((1 << 3) - 1);

-           else if (i== I387_FTAG_REGNUM)
+           else if (i== I387_FTAG_REGNUM (tdep))

              {
                /* The fxsave area contains a simplified version of
                   the tag word.  We have to look at the actual 80-bit
              {
                /* The fxsave area contains a simplified version of
                   the tag word.  We have to look at the actual 80-bit


@@ -589,7 +575,8 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
                int fpreg;
                int top;
 
                int fpreg;
                int top;
 

-               top = ((FXSAVE_ADDR (regs, I387_FSTAT_REGNUM))[1] >> 3);
+               top = ((FXSAVE_ADDR (tdep, regs,
+                                    I387_FSTAT_REGNUM (tdep)))[1] >> 3);

                top &= 0x7;
 
                for (fpreg = 7; fpreg >= 0; fpreg--)
                top &= 0x7;
 
                for (fpreg = 7; fpreg >= 0; fpreg--)


@@ -598,8 +585,9 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
 
                    if (val[0] & (1 << fpreg))
                      {
 
                    if (val[0] & (1 << fpreg))
                      {

-                       int regnum = (fpreg + 8 - top) % 8 + I387_ST0_REGNUM;
-                       tag = i387_tag (FXSAVE_ADDR (regs, regnum));
+                       int regnum = (fpreg + 8 - top) % 8 
+                                      + I387_ST0_REGNUM (tdep);
+                       tag = i387_tag (FXSAVE_ADDR (tdep, regs, regnum));

                      }
                    else
                      tag = 3;          /* Empty */
                      }
                    else
                      tag = 3;          /* Empty */


@@ -612,20 +600,17 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
            regcache_raw_supply (regcache, i, val);
          }
        else
            regcache_raw_supply (regcache, i, val);
          }
        else

-         regcache_raw_supply (regcache, i, FXSAVE_ADDR (regs, i));
+         regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));

       }
 
       }
 

-  if (regnum == I387_MXCSR_REGNUM || regnum == -1)
+  if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)

     {
       if (regs == NULL)
     {
       if (regs == NULL)

-       regcache_raw_supply (regcache, I387_MXCSR_REGNUM, NULL);
+       regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), NULL);

       else
       else

-       regcache_raw_supply (regcache, I387_MXCSR_REGNUM,
+       regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),

                             FXSAVE_MXCSR_ADDR (regs));
     }
                             FXSAVE_MXCSR_ADDR (regs));
     }

-
-#undef I387_ST0_REGNUM
-#undef I387_NUM_XMM_REGS

 }
 
 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 }
 
 /* Fill register REGNUM (if it is a floating-point or SSE register) in


@@ -636,39 +621,33 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
 void
 i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
 {
 void
 i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

   gdb_byte *regs = fxsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
   gdb_assert (tdep->num_xmm_regs > 0);
 
   gdb_byte *regs = fxsave;
   int i;
 
   gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
   gdb_assert (tdep->num_xmm_regs > 0);
 

-  /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
-     proper definitions for REGCACHE's architecture.  */
-
-#define I387_ST0_REGNUM        tdep->st0_regnum
-#define I387_NUM_XMM_REGS tdep->num_xmm_regs
-
-  for (i = I387_ST0_REGNUM; i < I387_MXCSR_REGNUM; i++)
+  for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)

     if (regnum == -1 || regnum == i)
       {
        /* Most of the FPU control registers occupy only 16 bits in
            the fxsave area.  Give those a special treatment.  */
     if (regnum == -1 || regnum == i)
       {
        /* Most of the FPU control registers occupy only 16 bits in
            the fxsave area.  Give those a special treatment.  */

-       if (i >= I387_FCTRL_REGNUM && i < I387_XMM0_REGNUM
-           && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM)
+       if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep)
+           && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))

          {
            gdb_byte buf[4];
 
            regcache_raw_collect (regcache, i, buf);
 
          {
            gdb_byte buf[4];
 
            regcache_raw_collect (regcache, i, buf);
 

-           if (i == I387_FOP_REGNUM)
+           if (i == I387_FOP_REGNUM (tdep))

              {
                /* The opcode occupies only 11 bits.  Make sure we
                    don't touch the other bits.  */
                buf[1] &= ((1 << 3) - 1);
              {
                /* The opcode occupies only 11 bits.  Make sure we
                    don't touch the other bits.  */
                buf[1] &= ((1 << 3) - 1);

-               buf[1] |= ((FXSAVE_ADDR (regs, i))[1] & ~((1 << 3) - 1));
+               buf[1] |= ((FXSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));

              }
              }

-           else if (i == I387_FTAG_REGNUM)
+           else if (i == I387_FTAG_REGNUM (tdep))

              {
                /* Converting back is much easier.  */
 
              {
                /* Converting back is much easier.  */
 


@@ -687,29 +666,15 @@ i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
                      buf[0] |= (1 << fpreg);
                  }
              }
                      buf[0] |= (1 << fpreg);
                  }
              }

-           memcpy (FXSAVE_ADDR (regs, i), buf, 2);
+           memcpy (FXSAVE_ADDR (tdep, regs, i), buf, 2);

          }
        else
          }
        else

-         regcache_raw_collect (regcache, i, FXSAVE_ADDR (regs, i));
+         regcache_raw_collect (regcache, i, FXSAVE_ADDR (tdep, regs, i));

       }
 
       }
 

-  if (regnum == I387_MXCSR_REGNUM || regnum == -1)
-    regcache_raw_collect (regcache, I387_MXCSR_REGNUM,
+  if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
+    regcache_raw_collect (regcache, I387_MXCSR_REGNUM (tdep),

                          FXSAVE_MXCSR_ADDR (regs));
                          FXSAVE_MXCSR_ADDR (regs));

-
-#undef I387_ST0_REGNUM
-#undef I387_NUM_XMM_REGS
-}
-
-/* Fill register REGNUM (if it is a floating-point or SSE register) in
-   *FXSAVE with the value in GDB's register cache.  If REGNUM is -1, do
-   this for all registers.  This function doesn't touch any of the
-   reserved bits in *FXSAVE.  */
-
-void
-i387_fill_fxsave (void *fxsave, int regnum)
-{
-  i387_collect_fxsave (current_regcache, regnum, fxsave);

 }
 
 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
 }
 
 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in


@@ -769,22 +734,17 @@ i387_return_value (struct gdbarch *gdbarch, struct regcache *regcache)
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   ULONGEST fstat;
 
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   ULONGEST fstat;
 

-  /* Define I387_ST0_REGNUM such that we use the proper
-     definitions for the architecture.  */
-#define I387_ST0_REGNUM tdep->st0_regnum
-

   /* Set the top of the floating-point register stack to 7.  The
      actual value doesn't really matter, but 7 is what a normal
      function return would end up with if the program started out with
      a freshly initialized FPU.  */
   /* Set the top of the floating-point register stack to 7.  The
      actual value doesn't really matter, but 7 is what a normal
      function return would end up with if the program started out with
      a freshly initialized FPU.  */

-  regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM, &fstat);
+  regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);

   fstat |= (7 << 11);
   fstat |= (7 << 11);

-  regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM, fstat);
+  regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);

 
   /* Mark %st(1) through %st(7) as empty.  Since we set the top of the
      floating-point register stack to 7, the appropriate value for the
      tag word is 0x3fff.  */
 
   /* Mark %st(1) through %st(7) as empty.  Since we set the top of the
      floating-point register stack to 7, the appropriate value for the
      tag word is 0x3fff.  */

-  regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM, 0x3fff);
+  regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);

 
 

-#undef I387_ST0_REGNUM

 }
 }