*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / mips-tdep.c
index da46b35208a81a3b2ef68f9246cf8add9ce3d8e5..976bcf7f0e651eaef821bc1eed94bdb9be06f48f 100644 (file)
@@ -1,7 +1,7 @@
 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
 
    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
 
    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
    Free Software Foundation, Inc.
 
    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
    Free Software Foundation, Inc.
 
    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
@@ -11,7 +11,7 @@
 
    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 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,
@@ -20,9 +20,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., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "gdb_string.h"
 
 #include "defs.h"
 #include "gdb_string.h"
@@ -167,6 +165,9 @@ static int mips_debug = 0;
 #define PROPERTY_GP32 "internal: transfers-32bit-registers"
 #define PROPERTY_GP64 "internal: transfers-64bit-registers"
 
 #define PROPERTY_GP32 "internal: transfers-32bit-registers"
 #define PROPERTY_GP64 "internal: transfers-64bit-registers"
 
+struct target_desc *mips_tdesc_gp32;
+struct target_desc *mips_tdesc_gp64;
+
 /* MIPS specific per-architecture information */
 struct gdbarch_tdep
 {
 /* MIPS specific per-architecture information */
 struct gdbarch_tdep
 {
@@ -198,38 +199,6 @@ struct gdbarch_tdep
   int register_size;
 };
 
   int register_size;
 };
 
-static int
-n32n64_floatformat_always_valid (const struct floatformat *fmt,
-                                 const void *from)
-{
-  return 1;
-}
-
-/* FIXME: brobecker/2004-08-08: Long Double values are 128 bit long.
-   They are implemented as a pair of 64bit doubles where the high
-   part holds the result of the operation rounded to double, and
-   the low double holds the difference between the exact result and
-   the rounded result.  So "high" + "low" contains the result with
-   added precision.  Unfortunately, the floatformat structure used
-   by GDB is not powerful enough to describe this format.  As a temporary
-   measure, we define a 128bit floatformat that only uses the high part.
-   We lose a bit of precision but that's probably the best we can do
-   for now with the current infrastructure.  */
-
-static const struct floatformat floatformat_n32n64_long_double_big =
-{
-  floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52,
-  floatformat_intbit_no,
-  "floatformat_n32n64_long_double_big",
-  n32n64_floatformat_always_valid
-};
-
-static const struct floatformat *floatformats_n32n64_long[BFD_ENDIAN_UNKNOWN] =
-{
-  &floatformat_n32n64_long_double_big,
-  &floatformat_n32n64_long_double_big
-};
-
 const struct mips_regnum *
 mips_regnum (struct gdbarch *gdbarch)
 {
 const struct mips_regnum *
 mips_regnum (struct gdbarch *gdbarch)
 {
@@ -266,36 +235,6 @@ unmake_mips16_addr (CORE_ADDR addr)
   return ((addr) & ~(CORE_ADDR) 1);
 }
 
   return ((addr) & ~(CORE_ADDR) 1);
 }
 
-/* Return the contents of register REGNUM as a signed integer.  */
-
-static LONGEST
-read_signed_register (int regnum)
-{
-  LONGEST val;
-  regcache_cooked_read_signed (current_regcache, regnum, &val);
-  return val;
-}
-
-static LONGEST
-read_signed_register_pid (int regnum, ptid_t ptid)
-{
-  ptid_t save_ptid;
-  LONGEST retval;
-
-  if (ptid_equal (ptid, inferior_ptid))
-    return read_signed_register (regnum);
-
-  save_ptid = inferior_ptid;
-
-  inferior_ptid = ptid;
-
-  retval = read_signed_register (regnum);
-
-  inferior_ptid = save_ptid;
-
-  return retval;
-}
-
 /* Return the MIPS ABI associated with GDBARCH.  */
 enum mips_abi
 mips_abi (struct gdbarch *gdbarch)
 /* Return the MIPS ABI associated with GDBARCH.  */
 enum mips_abi
 mips_abi (struct gdbarch *gdbarch)
@@ -372,18 +311,20 @@ msymbol_is_special (struct minimal_symbol *msym)
    things accordingly.  */
 
 static void
    things accordingly.  */
 
 static void
-mips_xfer_register (struct regcache *regcache, int reg_num, int length,
+mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
+                   int reg_num, int length,
                    enum bfd_endian endian, gdb_byte *in,
                    const gdb_byte *out, int buf_offset)
 {
   int reg_offset = 0;
                    enum bfd_endian endian, gdb_byte *in,
                    const gdb_byte *out, int buf_offset)
 {
   int reg_offset = 0;
-  gdb_assert (reg_num >= gdbarch_num_regs (current_gdbarch));
+
+  gdb_assert (reg_num >= gdbarch_num_regs (gdbarch));
   /* Need to transfer the left or right part of the register, based on
      the targets byte order.  */
   switch (endian)
     {
     case BFD_ENDIAN_BIG:
   /* Need to transfer the left or right part of the register, based on
      the targets byte order.  */
   switch (endian)
     {
     case BFD_ENDIAN_BIG:
-      reg_offset = register_size (current_gdbarch, reg_num) - length;
+      reg_offset = register_size (gdbarch, reg_num) - length;
       break;
     case BFD_ENDIAN_LITTLE:
       reg_offset = 0;
       break;
     case BFD_ENDIAN_LITTLE:
       reg_offset = 0;
@@ -429,10 +370,10 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length,
 static int
 mips2_fp_compat (struct frame_info *frame)
 {
 static int
 mips2_fp_compat (struct frame_info *frame)
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
      meaningful.  */
   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
      meaningful.  */
-  if (register_size (current_gdbarch, mips_regnum (current_gdbarch)->fp0) ==
-      4)
+  if (register_size (gdbarch, mips_regnum (gdbarch)->fp0) == 4)
     return 0;
 
 #if 0
     return 0;
 
 #if 0
@@ -520,9 +461,9 @@ static const char *mips_irix_reg_names[NUM_MIPS_PROCESSOR_REGS] = {
 
 /* Return the name of the register corresponding to REGNO.  */
 static const char *
 
 /* Return the name of the register corresponding to REGNO.  */
 static const char *
-mips_register_name (int regno)
+mips_register_name (struct gdbarch *gdbarch, int regno)
 {
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   /* GPR names for all ABIs other than n32/n64.  */
   static char *mips_gpr_names[] = {
     "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
   /* GPR names for all ABIs other than n32/n64.  */
   static char *mips_gpr_names[] = {
     "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
@@ -539,12 +480,12 @@ mips_register_name (int regno)
     "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
   };
 
     "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
   };
 
-  enum mips_abi abi = mips_abi (current_gdbarch);
+  enum mips_abi abi = mips_abi (gdbarch);
 
   /* Map [gdbarch_num_regs .. 2*gdbarch_num_regs) onto the raw registers, 
      but then don't make the raw register names visible.  */
 
   /* Map [gdbarch_num_regs .. 2*gdbarch_num_regs) onto the raw registers, 
      but then don't make the raw register names visible.  */
-  int rawnum = regno % gdbarch_num_regs (current_gdbarch);
-  if (regno < gdbarch_num_regs (current_gdbarch))
+  int rawnum = regno % gdbarch_num_regs (gdbarch);
+  if (regno < gdbarch_num_regs (gdbarch))
     return "";
 
   /* The MIPS integer registers are always mapped from 0 to 31.  The
     return "";
 
   /* The MIPS integer registers are always mapped from 0 to 31.  The
@@ -557,9 +498,9 @@ mips_register_name (int regno)
       else
        return mips_gpr_names[rawnum];
     }
       else
        return mips_gpr_names[rawnum];
     }
-  else if (tdesc_has_registers (gdbarch_target_desc (current_gdbarch)))
-    return tdesc_register_name (rawnum);
-  else if (32 <= rawnum && rawnum < gdbarch_num_regs (current_gdbarch))
+  else if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
+    return tdesc_register_name (gdbarch, rawnum);
+  else if (32 <= rawnum && rawnum < gdbarch_num_regs (gdbarch))
     {
       gdb_assert (rawnum - 32 < NUM_MIPS_PROCESSOR_REGS);
       return tdep->mips_processor_reg_names[rawnum - 32];
     {
       gdb_assert (rawnum - 32 < NUM_MIPS_PROCESSOR_REGS);
       return tdep->mips_processor_reg_names[rawnum - 32];
@@ -578,17 +519,17 @@ mips_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
   int vector_p;
   int float_p;
   int raw_p;
   int vector_p;
   int float_p;
   int raw_p;
-  int rawnum = regnum % gdbarch_num_regs (current_gdbarch);
-  int pseudo = regnum / gdbarch_num_regs (current_gdbarch);
+  int rawnum = regnum % gdbarch_num_regs (gdbarch);
+  int pseudo = regnum / gdbarch_num_regs (gdbarch);
   if (reggroup == all_reggroup)
     return pseudo;
   vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
   float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
   /* FIXME: cagney/2003-04-13: Can't yet use gdbarch_num_regs
      (gdbarch), as not all architectures are multi-arch.  */
   if (reggroup == all_reggroup)
     return pseudo;
   vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
   float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
   /* FIXME: cagney/2003-04-13: Can't yet use gdbarch_num_regs
      (gdbarch), as not all architectures are multi-arch.  */
-  raw_p = rawnum < gdbarch_num_regs (current_gdbarch);
-  if (gdbarch_register_name (current_gdbarch, regnum) == NULL
-      || gdbarch_register_name (current_gdbarch, regnum)[0] == '\0')
+  raw_p = rawnum < gdbarch_num_regs (gdbarch);
+  if (gdbarch_register_name (gdbarch, regnum) == NULL
+      || gdbarch_register_name (gdbarch, regnum)[0] == '\0')
     return 0;
   if (reggroup == float_reggroup)
     return float_p && pseudo;
     return 0;
   if (reggroup == float_reggroup)
     return float_p && pseudo;
@@ -644,16 +585,16 @@ static void
 mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                           int cookednum, gdb_byte *buf)
 {
 mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                           int cookednum, gdb_byte *buf)
 {
-  int rawnum = cookednum % gdbarch_num_regs (current_gdbarch);
-  gdb_assert (cookednum >= gdbarch_num_regs (current_gdbarch)
-             && cookednum < 2 * gdbarch_num_regs (current_gdbarch));
+  int rawnum = cookednum % gdbarch_num_regs (gdbarch);
+  gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
+             && cookednum < 2 * gdbarch_num_regs (gdbarch));
   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
     regcache_raw_read (regcache, rawnum, buf);
   else if (register_size (gdbarch, rawnum) >
           register_size (gdbarch, cookednum))
     {
       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
     regcache_raw_read (regcache, rawnum, buf);
   else if (register_size (gdbarch, rawnum) >
           register_size (gdbarch, cookednum))
     {
       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
-         || gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
+         || gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
        regcache_raw_read_part (regcache, rawnum, 0, 4, buf);
       else
        regcache_raw_read_part (regcache, rawnum, 4, 4, buf);
        regcache_raw_read_part (regcache, rawnum, 0, 4, buf);
       else
        regcache_raw_read_part (regcache, rawnum, 4, 4, buf);
@@ -667,16 +608,16 @@ mips_pseudo_register_write (struct gdbarch *gdbarch,
                            struct regcache *regcache, int cookednum,
                            const gdb_byte *buf)
 {
                            struct regcache *regcache, int cookednum,
                            const gdb_byte *buf)
 {
-  int rawnum = cookednum % gdbarch_num_regs (current_gdbarch);
-  gdb_assert (cookednum >= gdbarch_num_regs (current_gdbarch)
-             && cookednum < 2 * gdbarch_num_regs (current_gdbarch));
+  int rawnum = cookednum % gdbarch_num_regs (gdbarch);
+  gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
+             && cookednum < 2 * gdbarch_num_regs (gdbarch));
   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
     regcache_raw_write (regcache, rawnum, buf);
   else if (register_size (gdbarch, rawnum) >
           register_size (gdbarch, cookednum))
     {
       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
     regcache_raw_write (regcache, rawnum, buf);
   else if (register_size (gdbarch, rawnum) >
           register_size (gdbarch, cookednum))
     {
       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
-         || gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
+         || gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
        regcache_raw_write_part (regcache, rawnum, 0, 4, buf);
       else
        regcache_raw_write_part (regcache, rawnum, 4, 4, buf);
        regcache_raw_write_part (regcache, rawnum, 0, 4, buf);
       else
        regcache_raw_write_part (regcache, rawnum, 4, 4, buf);
@@ -719,14 +660,14 @@ set_mips64_transfers_32bit_regs (char *args, int from_tty,
 /* Convert to/from a register and the corresponding memory value.  */
 
 static int
 /* Convert to/from a register and the corresponding memory value.  */
 
 static int
-mips_convert_register_p (int regnum, struct type *type)
-{
-  return (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
-         && register_size (current_gdbarch, regnum) == 4
-         && (regnum % gdbarch_num_regs (current_gdbarch))
-               >= mips_regnum (current_gdbarch)->fp0
-         && (regnum % gdbarch_num_regs (current_gdbarch))
-               < mips_regnum (current_gdbarch)->fp0 + 32
+mips_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
+{
+  return (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
+         && register_size (gdbarch, regnum) == 4
+         && (regnum % gdbarch_num_regs (gdbarch))
+               >= mips_regnum (gdbarch)->fp0
+         && (regnum % gdbarch_num_regs (gdbarch))
+               < mips_regnum (gdbarch)->fp0 + 32
          && TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8);
 }
 
          && TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8);
 }
 
@@ -752,11 +693,10 @@ mips_value_to_register (struct frame_info *frame, int regnum,
 static struct type *
 mips_register_type (struct gdbarch *gdbarch, int regnum)
 {
 static struct type *
 mips_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  gdb_assert (regnum >= 0 && regnum < 2 * gdbarch_num_regs (current_gdbarch));
-  if ((regnum % gdbarch_num_regs (current_gdbarch))
-       >= mips_regnum (current_gdbarch)->fp0
-      && (regnum % gdbarch_num_regs (current_gdbarch))
-       < mips_regnum (current_gdbarch)->fp0 + 32)
+  gdb_assert (regnum >= 0 && regnum < 2 * gdbarch_num_regs (gdbarch));
+  if ((regnum % gdbarch_num_regs (gdbarch)) >= mips_regnum (gdbarch)->fp0
+      && (regnum % gdbarch_num_regs (gdbarch))
+        < mips_regnum (gdbarch)->fp0 + 32)
     {
       /* The floating-point registers raw, or cooked, always match
          mips_isa_regsize(), and also map 1:1, byte for byte.  */
     {
       /* The floating-point registers raw, or cooked, always match
          mips_isa_regsize(), and also map 1:1, byte for byte.  */
@@ -765,7 +705,7 @@ mips_register_type (struct gdbarch *gdbarch, int regnum)
       else
        return builtin_type_ieee_double;
     }
       else
        return builtin_type_ieee_double;
     }
-  else if (regnum < gdbarch_num_regs (current_gdbarch))
+  else if (regnum < gdbarch_num_regs (gdbarch))
     {
       /* The raw or ISA registers.  These are all sized according to
         the ISA regsize.  */
     {
       /* The raw or ISA registers.  These are all sized according to
         the ISA regsize.  */
@@ -778,10 +718,9 @@ mips_register_type (struct gdbarch *gdbarch, int regnum)
     {
       /* The cooked or ABI registers.  These are sized according to
         the ABI (with a few complications).  */
     {
       /* The cooked or ABI registers.  These are sized according to
         the ABI (with a few complications).  */
-      if (regnum >= (gdbarch_num_regs (current_gdbarch)
-                    + mips_regnum (current_gdbarch)->fp_control_status)
-         && regnum <= gdbarch_num_regs (current_gdbarch)
-                      + MIPS_LAST_EMBED_REGNUM)
+      if (regnum >= (gdbarch_num_regs (gdbarch)
+                    + mips_regnum (gdbarch)->fp_control_status)
+         && regnum <= gdbarch_num_regs (gdbarch) + MIPS_LAST_EMBED_REGNUM)
        /* The pseudo/cooked view of the embedded registers is always
           32-bit.  The raw view is handled below.  */
        return builtin_type_int32;
        /* The pseudo/cooked view of the embedded registers is always
           32-bit.  The raw view is handled below.  */
        return builtin_type_int32;
@@ -926,46 +865,48 @@ mips_pc_is_mips16 (CORE_ADDR memaddr)
    all registers should be sign extended for simplicity? */
 
 static CORE_ADDR
    all registers should be sign extended for simplicity? */
 
 static CORE_ADDR
-mips_read_pc (ptid_t ptid)
+mips_read_pc (struct regcache *regcache)
 {
 {
-  return read_signed_register_pid (mips_regnum (current_gdbarch)->pc, ptid);
+  ULONGEST pc;
+  int regnum = mips_regnum (get_regcache_arch (regcache))->pc;
+  regcache_cooked_read_signed (regcache, regnum, &pc);
+  return pc;
 }
 
 static CORE_ADDR
 mips_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
 }
 
 static CORE_ADDR
 mips_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
-  return frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + mips_regnum (gdbarch)->pc);
+  return frame_unwind_register_signed
+          (next_frame, gdbarch_num_regs (gdbarch) + mips_regnum (gdbarch)->pc);
 }
 
 static CORE_ADDR
 mips_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
 }
 
 static CORE_ADDR
 mips_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
-  return frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + MIPS_SP_REGNUM);
+  return frame_unwind_register_signed
+          (next_frame, gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM);
 }
 
 }
 
-/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
+/* Assuming THIS_FRAME is a dummy, return the frame ID of that
    dummy frame.  The frame ID's base needs to match the TOS value
    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
    breakpoint.  */
 
 static struct frame_id
    dummy frame.  The frame ID's base needs to match the TOS value
    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
    breakpoint.  */
 
 static struct frame_id
-mips_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+mips_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
   return frame_id_build
 {
   return frame_id_build
-          (frame_unwind_register_signed (next_frame,
-                                         gdbarch_num_regs (current_gdbarch)
-                                         + MIPS_SP_REGNUM),
-                                         frame_pc_unwind (next_frame));
+          (get_frame_register_signed (this_frame,
+                                      gdbarch_num_regs (gdbarch)
+                                      + MIPS_SP_REGNUM),
+           get_frame_pc (this_frame));
 }
 
 static void
 }
 
 static void
-mips_write_pc (CORE_ADDR pc, ptid_t ptid)
+mips_write_pc (struct regcache *regcache, CORE_ADDR pc)
 {
 {
-  write_register_pid (mips_regnum (current_gdbarch)->pc, pc, ptid);
+  int regnum = mips_regnum (get_regcache_arch (regcache))->pc;
+  regcache_cooked_write_unsigned (regcache, regnum, pc);
 }
 
 /* Fetch and return instruction from the specified location.  If the PC
 }
 
 /* Fetch and return instruction from the specified location.  If the PC
@@ -985,7 +926,7 @@ mips_fetch_instruction (CORE_ADDR addr)
     }
   else
     instlen = MIPS_INSN32_SIZE;
     }
   else
     instlen = MIPS_INSN32_SIZE;
-  status = read_memory_nobpt (addr, buf, instlen);
+  status = target_read_memory (addr, buf, instlen);
   if (status)
     memory_error (status, addr);
   return extract_unsigned_integer (buf, instlen);
   if (status)
     memory_error (status, addr);
   return extract_unsigned_integer (buf, instlen);
@@ -1036,7 +977,7 @@ mips32_next_pc (struct frame_info *frame, CORE_ADDR pc)
              goto neq_branch;
            case 2:             /* BLEZL */
              goto less_branch;
              goto neq_branch;
            case 2:             /* BLEZL */
              goto less_branch;
-           case 3:             /* BGTZ */
+           case 3:             /* BGTZL */
              goto greater_branch;
            default:
              pc += 4;
              goto greater_branch;
            default:
              pc += 4;
@@ -1048,7 +989,8 @@ mips32_next_pc (struct frame_info *frame, CORE_ADDR pc)
          int tf = itype_rt (inst) & 0x01;
          int cnum = itype_rt (inst) >> 2;
          int fcrcs =
          int tf = itype_rt (inst) & 0x01;
          int cnum = itype_rt (inst) >> 2;
          int fcrcs =
-           get_frame_register_signed (frame, mips_regnum (current_gdbarch)->
+           get_frame_register_signed (frame,
+                                      mips_regnum (get_frame_arch (frame))->
                                                fp_control_status);
          int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
 
                                                fp_control_status);
          int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
 
@@ -1209,7 +1151,7 @@ struct upk_mips16
 
 
 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same format
 
 
 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same format
-   for the bits which make up the immediatate extension.  */
+   for the bits which make up the immediate extension.  */
 
 static CORE_ADDR
 extended_offset (unsigned int extension)
 
 static CORE_ADDR
 extended_offset (unsigned int extension)
@@ -1224,13 +1166,11 @@ extended_offset (unsigned int extension)
 }
 
 /* Only call this function if you know that this is an extendable
 }
 
 /* Only call this function if you know that this is an extendable
-   instruction, It wont malfunction, but why make excess remote memory references?
-   If the immediate operands get sign extended or somthing, do it after
-   the extension is performed.
- */
+   instruction.  It won't malfunction, but why make excess remote memory
+   references?  If the immediate operands get sign extended or something,
+   do it after the extension is performed.  */
 /* FIXME: Every one of these cases needs to worry about sign extension
 /* FIXME: Every one of these cases needs to worry about sign extension
-   when the offset is to be used in relative addressing */
-
+   when the offset is to be used in relative addressing.  */
 
 static unsigned int
 fetch_mips_16 (CORE_ADDR pc)
 
 static unsigned int
 fetch_mips_16 (CORE_ADDR pc)
@@ -1463,11 +1403,11 @@ mips16_next_pc (struct frame_info *frame, CORE_ADDR pc)
    target monitor or stub is not developed enough to do a single_step.
    It works by decoding the current instruction and predicting where a
    branch will go. This isnt hard because all the data is available.
    target monitor or stub is not developed enough to do a single_step.
    It works by decoding the current instruction and predicting where a
    branch will go. This isnt hard because all the data is available.
-   The MIPS32 and MIPS16 variants are quite different */
+   The MIPS32 and MIPS16 variants are quite different */
 static CORE_ADDR
 mips_next_pc (struct frame_info *frame, CORE_ADDR pc)
 {
 static CORE_ADDR
 mips_next_pc (struct frame_info *frame, CORE_ADDR pc)
 {
-  if (pc & 0x01)
+  if (is_mips16_addr (pc))
     return mips16_next_pc (frame, pc);
   else
     return mips32_next_pc (frame, pc);
     return mips16_next_pc (frame, pc);
   else
     return mips32_next_pc (frame, pc);
@@ -1548,7 +1488,7 @@ mips16_get_imm (unsigned short prev_inst, /* previous instruction */
 
 static CORE_ADDR
 mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
 
 static CORE_ADDR
 mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
-                      struct frame_info *next_frame,
+                      struct frame_info *this_frame,
                       struct mips_frame_cache *this_cache)
 {
   CORE_ADDR cur_pc;
                       struct mips_frame_cache *this_cache)
 {
   CORE_ADDR cur_pc;
@@ -1560,18 +1500,20 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
   unsigned short prev_inst = 0;        /* saved copy of previous instruction */
   unsigned inst = 0;           /* current instruction */
   unsigned entry_inst = 0;     /* the entry instruction */
   unsigned short prev_inst = 0;        /* saved copy of previous instruction */
   unsigned inst = 0;           /* current instruction */
   unsigned entry_inst = 0;     /* the entry instruction */
+  unsigned save_inst = 0;      /* the save instruction */
   int reg, offset;
 
   int extend_bytes = 0;
   int prev_extend_bytes;
   CORE_ADDR end_prologue_addr = 0;
   int reg, offset;
 
   int extend_bytes = 0;
   int prev_extend_bytes;
   CORE_ADDR end_prologue_addr = 0;
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
 
   /* Can be called when there's no process, and hence when there's no
 
   /* Can be called when there's no process, and hence when there's no
-     NEXT_FRAME.  */
-  if (next_frame != NULL)
-    sp = frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + MIPS_SP_REGNUM);
+     THIS_FRAME.  */
+  if (this_frame != NULL)
+    sp = get_frame_register_signed (this_frame,
+                                   gdbarch_num_regs (gdbarch)
+                                   + MIPS_SP_REGNUM);
   else
     sp = 0;
 
   else
     sp = 0;
 
@@ -1662,6 +1604,12 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
       else if ((inst & 0xf81f) == 0xe809
                && (inst & 0x700) != 0x700)     /* entry */
        entry_inst = inst;      /* save for later processing */
       else if ((inst & 0xf81f) == 0xe809
                && (inst & 0x700) != 0x700)     /* entry */
        entry_inst = inst;      /* save for later processing */
+      else if ((inst & 0xff80) == 0x6480)      /* save */
+       {
+         save_inst = inst;     /* save for later processing */
+         if (prev_extend_bytes)                /* extend */
+           save_inst |= prev_inst << 16;
+       }
       else if ((inst & 0xf800) == 0x1800)      /* jal(x) */
        cur_pc += MIPS_INSN16_SIZE;     /* 32-bit instruction */
       else if ((inst & 0xff1c) == 0x6704)      /* move reg,$a0-$a3 */
       else if ((inst & 0xf800) == 0x1800)      /* jal(x) */
        cur_pc += MIPS_INSN16_SIZE;     /* 32-bit instruction */
       else if ((inst & 0xff1c) == 0x6704)      /* move reg,$a0-$a3 */
@@ -1701,7 +1649,7 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
        {
          set_reg_offset (this_cache, reg, sp + offset);
       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
        {
          set_reg_offset (this_cache, reg, sp + offset);
-         offset += mips_abi_regsize (current_gdbarch);
+         offset += mips_abi_regsize (gdbarch);
        }
 
       /* Check if the ra register was pushed on the stack.  */
        }
 
       /* Check if the ra register was pushed on the stack.  */
@@ -1709,31 +1657,124 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
       if (entry_inst & 0x20)
        {
          set_reg_offset (this_cache, MIPS_RA_REGNUM, sp + offset);
       if (entry_inst & 0x20)
        {
          set_reg_offset (this_cache, MIPS_RA_REGNUM, sp + offset);
-         offset -= mips_abi_regsize (current_gdbarch);
+         offset -= mips_abi_regsize (gdbarch);
        }
 
       /* Check if the s0 and s1 registers were pushed on the stack.  */
       for (reg = 16; reg < sreg_count + 16; reg++)
        {
          set_reg_offset (this_cache, reg, sp + offset);
        }
 
       /* Check if the s0 and s1 registers were pushed on the stack.  */
       for (reg = 16; reg < sreg_count + 16; reg++)
        {
          set_reg_offset (this_cache, reg, sp + offset);
-         offset -= mips_abi_regsize (current_gdbarch);
+         offset -= mips_abi_regsize (gdbarch);
+       }
+    }
+
+  /* The SAVE instruction is similar to ENTRY, except that defined by the
+     MIPS16e ASE of the MIPS Architecture.  Unlike with ENTRY though, the
+     size of the frame is specified as an immediate field of instruction
+     and an extended variation exists which lets additional registers and
+     frame space to be specified.  The instruction always treats registers
+     as 32-bit so its usefulness for 64-bit ABIs is questionable.  */
+  if (save_inst != 0 && mips_abi_regsize (gdbarch) == 4)
+    {
+      static int args_table[16] = {
+       0, 0, 0, 0, 1, 1, 1, 1,
+       2, 2, 2, 0, 3, 3, 4, -1,
+      };
+      static int astatic_table[16] = {
+       0, 1, 2, 3, 0, 1, 2, 3,
+       0, 1, 2, 4, 0, 1, 0, -1,
+      };
+      int aregs = (save_inst >> 16) & 0xf;
+      int xsregs = (save_inst >> 24) & 0x7;
+      int args = args_table[aregs];
+      int astatic = astatic_table[aregs];
+      long frame_size;
+
+      if (args < 0)
+       {
+         warning (_("Invalid number of argument registers encoded in SAVE."));
+         args = 0;
+       }
+      if (astatic < 0)
+       {
+         warning (_("Invalid number of static registers encoded in SAVE."));
+         astatic = 0;
+       }
+
+      /* For standard SAVE the frame size of 0 means 128.  */
+      frame_size = ((save_inst >> 16) & 0xf0) | (save_inst & 0xf);
+      if (frame_size == 0 && (save_inst >> 16) == 0)
+       frame_size = 16;
+      frame_size *= 8;
+      frame_offset += frame_size;
+
+      /* Now we can calculate what the SP must have been at the
+         start of the function prologue.  */
+      sp += frame_offset;
+
+      /* Check if A0-A3 were saved in the caller's argument save area.  */
+      for (reg = MIPS_A0_REGNUM, offset = 0; reg < args + 4; reg++)
+       {
+         set_reg_offset (this_cache, reg, sp + offset);
+         offset += mips_abi_regsize (gdbarch);
+       }
+
+      offset = -4;
+
+      /* Check if the RA register was pushed on the stack.  */
+      if (save_inst & 0x40)
+       {
+         set_reg_offset (this_cache, MIPS_RA_REGNUM, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
+       }
+
+      /* Check if the S8 register was pushed on the stack.  */
+      if (xsregs > 6)
+       {
+         set_reg_offset (this_cache, 30, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
+         xsregs--;
+       }
+      /* Check if S2-S7 were pushed on the stack.  */
+      for (reg = 18 + xsregs - 1; reg > 18 - 1; reg--)
+       {
+         set_reg_offset (this_cache, reg, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
+       }
+
+      /* Check if the S1 register was pushed on the stack.  */
+      if (save_inst & 0x10)
+       {
+         set_reg_offset (this_cache, 17, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
+       }
+      /* Check if the S0 register was pushed on the stack.  */
+      if (save_inst & 0x20)
+       {
+         set_reg_offset (this_cache, 16, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
+       }
+
+      /* Check if A0-A3 were pushed on the stack.  */
+      for (reg = MIPS_A0_REGNUM + 3; reg > MIPS_A0_REGNUM + 3 - astatic; reg--)
+       {
+         set_reg_offset (this_cache, reg, sp + offset);
+         offset -= mips_abi_regsize (gdbarch);
        }
     }
 
   if (this_cache != NULL)
     {
       this_cache->base =
        }
     }
 
   if (this_cache != NULL)
     {
       this_cache->base =
-        (frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + frame_reg)
+        (get_frame_register_signed (this_frame,
+                                   gdbarch_num_regs (gdbarch) + frame_reg)
          + frame_offset - frame_adjust);
       /* FIXME: brobecker/2004-10-10: Just as in the mips32 case, we should
          be able to get rid of the assignment below, evetually. But it's
          still needed for now.  */
          + frame_offset - frame_adjust);
       /* FIXME: brobecker/2004-10-10: Just as in the mips32 case, we should
          be able to get rid of the assignment below, evetually. But it's
          still needed for now.  */
-      this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
-                            + mips_regnum (current_gdbarch)->pc]
-        = this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
-                                + MIPS_RA_REGNUM];
+      this_cache->saved_regs[gdbarch_num_regs (gdbarch)
+                            + mips_regnum (gdbarch)->pc]
+        = this_cache->saved_regs[gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM];
     }
 
   /* If we didn't reach the end of the prologue when scanning the function
     }
 
   /* If we didn't reach the end of the prologue when scanning the function
@@ -1750,7 +1791,7 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
    mips_insn32 unwinder.  */
 
 static struct mips_frame_cache *
    mips_insn32 unwinder.  */
 
 static struct mips_frame_cache *
-mips_insn16_frame_cache (struct frame_info *next_frame, void **this_cache)
+mips_insn16_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
   struct mips_frame_cache *cache;
 
 {
   struct mips_frame_cache *cache;
 
@@ -1758,12 +1799,11 @@ mips_insn16_frame_cache (struct frame_info *next_frame, void **this_cache)
     return (*this_cache);
   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
   (*this_cache) = cache;
     return (*this_cache);
   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
   (*this_cache) = cache;
-  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+  cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
   /* Analyze the function prologue.  */
   {
 
   /* Analyze the function prologue.  */
   {
-    const CORE_ADDR pc =
-      frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+    const CORE_ADDR pc = get_frame_address_in_block (this_frame);
     CORE_ADDR start_addr;
 
     find_pc_partial_function (pc, NULL, &start_addr, NULL);
     CORE_ADDR start_addr;
 
     find_pc_partial_function (pc, NULL, &start_addr, NULL);
@@ -1774,60 +1814,60 @@ mips_insn16_frame_cache (struct frame_info *next_frame, void **this_cache)
     if (start_addr == 0)
       return cache;
 
     if (start_addr == 0)
       return cache;
 
-    mips16_scan_prologue (start_addr, pc, next_frame, *this_cache);
+    mips16_scan_prologue (start_addr, pc, this_frame, *this_cache);
   }
   
   }
   
-  /* SP_REGNUM, contains the value and not the address.  */
-  trad_frame_set_value (cache->saved_regs, gdbarch_num_regs (current_gdbarch)
-                                          + MIPS_SP_REGNUM, cache->base);
+  /* gdbarch_sp_regnum contains the value and not the address.  */
+  trad_frame_set_value (cache->saved_regs,
+                       gdbarch_num_regs (get_frame_arch (this_frame))
+                       + MIPS_SP_REGNUM,
+                       cache->base);
 
   return (*this_cache);
 }
 
 static void
 
   return (*this_cache);
 }
 
 static void
-mips_insn16_frame_this_id (struct frame_info *next_frame, void **this_cache,
+mips_insn16_frame_this_id (struct frame_info *this_frame, void **this_cache,
                           struct frame_id *this_id)
 {
                           struct frame_id *this_id)
 {
-  struct mips_frame_cache *info = mips_insn16_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
                                                           this_cache);
                                                           this_cache);
-  (*this_id) = frame_id_build (info->base,
-                              frame_func_unwind (next_frame, NORMAL_FRAME));
+  (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
 }
 
 }
 
-static void
-mips_insn16_frame_prev_register (struct frame_info *next_frame,
-                                void **this_cache,
-                                int regnum, int *optimizedp,
-                                enum lval_type *lvalp, CORE_ADDR *addrp,
-                                int *realnump, gdb_byte *valuep)
+static struct value *
+mips_insn16_frame_prev_register (struct frame_info *this_frame,
+                                void **this_cache, int regnum)
 {
 {
-  struct mips_frame_cache *info = mips_insn16_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
                                                           this_cache);
                                                           this_cache);
-  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
-                               optimizedp, lvalp, addrp, realnump, valuep);
+  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
+}
+
+static int
+mips_insn16_frame_sniffer (const struct frame_unwind *self,
+                          struct frame_info *this_frame, void **this_cache)
+{
+  CORE_ADDR pc = get_frame_pc (this_frame);
+  if (mips_pc_is_mips16 (pc))
+    return 1;
+  return 0;
 }
 
 static const struct frame_unwind mips_insn16_frame_unwind =
 {
   NORMAL_FRAME,
   mips_insn16_frame_this_id,
 }
 
 static const struct frame_unwind mips_insn16_frame_unwind =
 {
   NORMAL_FRAME,
   mips_insn16_frame_this_id,
-  mips_insn16_frame_prev_register
+  mips_insn16_frame_prev_register,
+  NULL,
+  mips_insn16_frame_sniffer
 };
 
 };
 
-static const struct frame_unwind *
-mips_insn16_frame_sniffer (struct frame_info *next_frame)
-{
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
-  if (mips_pc_is_mips16 (pc))
-    return &mips_insn16_frame_unwind;
-  return NULL;
-}
-
 static CORE_ADDR
 static CORE_ADDR
-mips_insn16_frame_base_address (struct frame_info *next_frame,
+mips_insn16_frame_base_address (struct frame_info *this_frame,
                                void **this_cache)
 {
                                void **this_cache)
 {
-  struct mips_frame_cache *info = mips_insn16_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
                                                           this_cache);
   return info->base;
 }
                                                           this_cache);
   return info->base;
 }
@@ -1841,9 +1881,10 @@ static const struct frame_base mips_insn16_frame_base =
 };
 
 static const struct frame_base *
 };
 
 static const struct frame_base *
-mips_insn16_frame_base_sniffer (struct frame_info *next_frame)
+mips_insn16_frame_base_sniffer (struct frame_info *this_frame)
 {
 {
-  if (mips_insn16_frame_sniffer (next_frame) != NULL)
+  CORE_ADDR pc = get_frame_pc (this_frame);
+  if (mips_pc_is_mips16 (pc))
     return &mips_insn16_frame_base;
   else
     return NULL;
     return &mips_insn16_frame_base;
   else
     return NULL;
@@ -1875,7 +1916,7 @@ reset_saved_regs (struct mips_frame_cache *this_cache)
 
 static CORE_ADDR
 mips32_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
 
 static CORE_ADDR
 mips32_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
-                      struct frame_info *next_frame,
+                      struct frame_info *this_frame,
                       struct mips_frame_cache *this_cache)
 {
   CORE_ADDR cur_pc;
                       struct mips_frame_cache *this_cache)
 {
   CORE_ADDR cur_pc;
@@ -1887,13 +1928,15 @@ mips32_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
   CORE_ADDR end_prologue_addr = 0;
   int seen_sp_adjust = 0;
   int load_immediate_bytes = 0;
   CORE_ADDR end_prologue_addr = 0;
   int seen_sp_adjust = 0;
   int load_immediate_bytes = 0;
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  int regsize_is_64_bits = (mips_abi_regsize (gdbarch) == 8);
 
   /* Can be called when there's no process, and hence when there's no
 
   /* Can be called when there's no process, and hence when there's no
-     NEXT_FRAME.  */
-  if (next_frame != NULL)
-    sp = frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + MIPS_SP_REGNUM);
+     THIS_FRAME.  */
+  if (this_frame != NULL)
+    sp = get_frame_register_signed (this_frame,
+                                   gdbarch_num_regs (gdbarch)
+                                   + MIPS_SP_REGNUM);
   else
     sp = 0;
 
   else
     sp = 0;
 
@@ -1929,11 +1972,13 @@ restart:
            break;
           seen_sp_adjust = 1;
        }
            break;
           seen_sp_adjust = 1;
        }
-      else if ((high_word & 0xFFE0) == 0xafa0) /* sw reg,offset($sp) */
+      else if (((high_word & 0xFFE0) == 0xafa0) /* sw reg,offset($sp) */
+               && !regsize_is_64_bits)
        {
          set_reg_offset (this_cache, reg, sp + low_word);
        }
        {
          set_reg_offset (this_cache, reg, sp + low_word);
        }
-      else if ((high_word & 0xFFE0) == 0xffa0) /* sd reg,offset($sp) */
+      else if (((high_word & 0xFFE0) == 0xffa0)        /* sd reg,offset($sp) */
+               && regsize_is_64_bits)
        {
          /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra.  */
          set_reg_offset (this_cache, reg, sp + low_word);
        {
          /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra.  */
          set_reg_offset (this_cache, reg, sp + low_word);
@@ -1943,14 +1988,13 @@ restart:
          /* Old gcc frame, r30 is virtual frame pointer.  */
          if ((long) low_word != frame_offset)
            frame_addr = sp + low_word;
          /* Old gcc frame, r30 is virtual frame pointer.  */
          if ((long) low_word != frame_offset)
            frame_addr = sp + low_word;
-         else if (next_frame && frame_reg == MIPS_SP_REGNUM)
+         else if (this_frame && frame_reg == MIPS_SP_REGNUM)
            {
              unsigned alloca_adjust;
 
              frame_reg = 30;
            {
              unsigned alloca_adjust;
 
              frame_reg = 30;
-             frame_addr = frame_unwind_register_signed
-                            (next_frame,
-                             gdbarch_num_regs (current_gdbarch) + 30);
+             frame_addr = get_frame_register_signed
+               (this_frame, gdbarch_num_regs (gdbarch) + 30);
 
              alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
              if (alloca_adjust > 0)
 
              alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
              if (alloca_adjust > 0)
@@ -1974,14 +2018,13 @@ restart:
       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
        {
          /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
        {
          /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
-         if (next_frame && frame_reg == MIPS_SP_REGNUM)
+         if (this_frame && frame_reg == MIPS_SP_REGNUM)
            {
              unsigned alloca_adjust;
 
              frame_reg = 30;
            {
              unsigned alloca_adjust;
 
              frame_reg = 30;
-             frame_addr = frame_unwind_register_signed
-                            (next_frame,
-                             gdbarch_num_regs (current_gdbarch) + 30);
+             frame_addr = get_frame_register_signed
+               (this_frame, gdbarch_num_regs (gdbarch) + 30);
 
              alloca_adjust = (unsigned) (frame_addr - sp);
              if (alloca_adjust > 0)
 
              alloca_adjust = (unsigned) (frame_addr - sp);
              if (alloca_adjust > 0)
@@ -1999,7 +2042,8 @@ restart:
                }
            }
        }
                }
            }
        }
-      else if ((high_word & 0xFFE0) == 0xafc0) /* sw reg,offset($30) */
+      else if ((high_word & 0xFFE0) == 0xafc0  /* sw reg,offset($30) */
+               && !regsize_is_64_bits)
        {
          set_reg_offset (this_cache, reg, frame_addr + low_word);
        }
        {
          set_reg_offset (this_cache, reg, frame_addr + low_word);
        }
@@ -2047,16 +2091,15 @@ restart:
   if (this_cache != NULL)
     {
       this_cache->base = 
   if (this_cache != NULL)
     {
       this_cache->base = 
-        (frame_unwind_register_signed (next_frame,
-                                      gdbarch_num_regs (current_gdbarch)
-                                      + frame_reg)
+        (get_frame_register_signed (this_frame,
+                                   gdbarch_num_regs (gdbarch) + frame_reg)
          + frame_offset);
       /* FIXME: brobecker/2004-09-15: We should be able to get rid of
          this assignment below, eventually.  But it's still needed
          for now.  */
          + frame_offset);
       /* FIXME: brobecker/2004-09-15: We should be able to get rid of
          this assignment below, eventually.  But it's still needed
          for now.  */
-      this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
-                            + mips_regnum (current_gdbarch)->pc]
-        = this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
+      this_cache->saved_regs[gdbarch_num_regs (gdbarch)
+                            + mips_regnum (gdbarch)->pc]
+        = this_cache->saved_regs[gdbarch_num_regs (gdbarch)
                                 + MIPS_RA_REGNUM];
     }
 
                                 + MIPS_RA_REGNUM];
     }
 
@@ -2084,7 +2127,7 @@ restart:
    unwinder.  */
 
 static struct mips_frame_cache *
    unwinder.  */
 
 static struct mips_frame_cache *
-mips_insn32_frame_cache (struct frame_info *next_frame, void **this_cache)
+mips_insn32_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
   struct mips_frame_cache *cache;
 
 {
   struct mips_frame_cache *cache;
 
@@ -2093,12 +2136,11 @@ mips_insn32_frame_cache (struct frame_info *next_frame, void **this_cache)
 
   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
   (*this_cache) = cache;
 
   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
   (*this_cache) = cache;
-  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+  cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
   /* Analyze the function prologue.  */
   {
 
   /* Analyze the function prologue.  */
   {
-    const CORE_ADDR pc =
-      frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+    const CORE_ADDR pc = get_frame_address_in_block (this_frame);
     CORE_ADDR start_addr;
 
     find_pc_partial_function (pc, NULL, &start_addr, NULL);
     CORE_ADDR start_addr;
 
     find_pc_partial_function (pc, NULL, &start_addr, NULL);
@@ -2109,61 +2151,60 @@ mips_insn32_frame_cache (struct frame_info *next_frame, void **this_cache)
     if (start_addr == 0)
       return cache;
 
     if (start_addr == 0)
       return cache;
 
-    mips32_scan_prologue (start_addr, pc, next_frame, *this_cache);
+    mips32_scan_prologue (start_addr, pc, this_frame, *this_cache);
   }
   
   }
   
-  /* SP_REGNUM, contains the value and not the address.  */
+  /* gdbarch_sp_regnum contains the value and not the address.  */
   trad_frame_set_value (cache->saved_regs,
   trad_frame_set_value (cache->saved_regs,
-                       gdbarch_num_regs (current_gdbarch) + MIPS_SP_REGNUM,
+                       gdbarch_num_regs (get_frame_arch (this_frame))
+                       + MIPS_SP_REGNUM,
                        cache->base);
 
   return (*this_cache);
 }
 
 static void
                        cache->base);
 
   return (*this_cache);
 }
 
 static void
-mips_insn32_frame_this_id (struct frame_info *next_frame, void **this_cache,
+mips_insn32_frame_this_id (struct frame_info *this_frame, void **this_cache,
                           struct frame_id *this_id)
 {
                           struct frame_id *this_id)
 {
-  struct mips_frame_cache *info = mips_insn32_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
                                                           this_cache);
                                                           this_cache);
-  (*this_id) = frame_id_build (info->base,
-                              frame_func_unwind (next_frame, NORMAL_FRAME));
+  (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
 }
 
 }
 
-static void
-mips_insn32_frame_prev_register (struct frame_info *next_frame,
-                                void **this_cache,
-                                int regnum, int *optimizedp,
-                                enum lval_type *lvalp, CORE_ADDR *addrp,
-                                int *realnump, gdb_byte *valuep)
+static struct value *
+mips_insn32_frame_prev_register (struct frame_info *this_frame,
+                                void **this_cache, int regnum)
 {
 {
-  struct mips_frame_cache *info = mips_insn32_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
                                                           this_cache);
                                                           this_cache);
-  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
-                               optimizedp, lvalp, addrp, realnump, valuep);
+  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
+}
+
+static int
+mips_insn32_frame_sniffer (const struct frame_unwind *self,
+                          struct frame_info *this_frame, void **this_cache)
+{
+  CORE_ADDR pc = get_frame_pc (this_frame);
+  if (! mips_pc_is_mips16 (pc))
+    return 1;
+  return 0;
 }
 
 static const struct frame_unwind mips_insn32_frame_unwind =
 {
   NORMAL_FRAME,
   mips_insn32_frame_this_id,
 }
 
 static const struct frame_unwind mips_insn32_frame_unwind =
 {
   NORMAL_FRAME,
   mips_insn32_frame_this_id,
-  mips_insn32_frame_prev_register
+  mips_insn32_frame_prev_register,
+  NULL,
+  mips_insn32_frame_sniffer
 };
 
 };
 
-static const struct frame_unwind *
-mips_insn32_frame_sniffer (struct frame_info *next_frame)
-{
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
-  if (! mips_pc_is_mips16 (pc))
-    return &mips_insn32_frame_unwind;
-  return NULL;
-}
-
 static CORE_ADDR
 static CORE_ADDR
-mips_insn32_frame_base_address (struct frame_info *next_frame,
+mips_insn32_frame_base_address (struct frame_info *this_frame,
                                void **this_cache)
 {
                                void **this_cache)
 {
-  struct mips_frame_cache *info = mips_insn32_frame_cache (next_frame,
+  struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
                                                           this_cache);
   return info->base;
 }
                                                           this_cache);
   return info->base;
 }
@@ -2177,36 +2218,42 @@ static const struct frame_base mips_insn32_frame_base =
 };
 
 static const struct frame_base *
 };
 
 static const struct frame_base *
-mips_insn32_frame_base_sniffer (struct frame_info *next_frame)
+mips_insn32_frame_base_sniffer (struct frame_info *this_frame)
 {
 {
-  if (mips_insn32_frame_sniffer (next_frame) != NULL)
+  CORE_ADDR pc = get_frame_pc (this_frame);
+  if (! mips_pc_is_mips16 (pc))
     return &mips_insn32_frame_base;
   else
     return NULL;
 }
 
 static struct trad_frame_cache *
     return &mips_insn32_frame_base;
   else
     return NULL;
 }
 
 static struct trad_frame_cache *
-mips_stub_frame_cache (struct frame_info *next_frame, void **this_cache)
+mips_stub_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
   CORE_ADDR pc;
   CORE_ADDR start_addr;
   CORE_ADDR stack_addr;
   struct trad_frame_cache *this_trad_cache;
 {
   CORE_ADDR pc;
   CORE_ADDR start_addr;
   CORE_ADDR stack_addr;
   struct trad_frame_cache *this_trad_cache;
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  int num_regs = gdbarch_num_regs (gdbarch);
 
   if ((*this_cache) != NULL)
     return (*this_cache);
 
   if ((*this_cache) != NULL)
     return (*this_cache);
-  this_trad_cache = trad_frame_cache_zalloc (next_frame);
+  this_trad_cache = trad_frame_cache_zalloc (this_frame);
   (*this_cache) = this_trad_cache;
 
   /* The return address is in the link register.  */
   (*this_cache) = this_trad_cache;
 
   /* The return address is in the link register.  */
-  trad_frame_set_reg_realreg (this_trad_cache, PC_REGNUM, MIPS_RA_REGNUM);
+  trad_frame_set_reg_realreg (this_trad_cache,
+                             gdbarch_pc_regnum (gdbarch),
+                             num_regs + MIPS_RA_REGNUM);
 
   /* Frame ID, since it's a frameless / stackless function, no stack
      space is allocated and SP on entry is the current SP.  */
 
   /* Frame ID, since it's a frameless / stackless function, no stack
      space is allocated and SP on entry is the current SP.  */
-  pc = frame_pc_unwind (next_frame);
+  pc = get_frame_pc (this_frame);
   find_pc_partial_function (pc, NULL, &start_addr, NULL);
   find_pc_partial_function (pc, NULL, &start_addr, NULL);
-  stack_addr = frame_unwind_register_signed (next_frame, MIPS_SP_REGNUM);
-  trad_frame_set_id (this_trad_cache, frame_id_build (start_addr, stack_addr));
+  stack_addr = get_frame_register_signed (this_frame,
+                                         num_regs + MIPS_SP_REGNUM);
+  trad_frame_set_id (this_trad_cache, frame_id_build (stack_addr, start_addr));
 
   /* Assume that the frame's base is the same as the
      stack-pointer.  */
 
   /* Assume that the frame's base is the same as the
      stack-pointer.  */
@@ -2216,42 +2263,37 @@ mips_stub_frame_cache (struct frame_info *next_frame, void **this_cache)
 }
 
 static void
 }
 
 static void
-mips_stub_frame_this_id (struct frame_info *next_frame, void **this_cache,
+mips_stub_frame_this_id (struct frame_info *this_frame, void **this_cache,
                         struct frame_id *this_id)
 {
   struct trad_frame_cache *this_trad_cache
                         struct frame_id *this_id)
 {
   struct trad_frame_cache *this_trad_cache
-    = mips_stub_frame_cache (next_frame, this_cache);
+    = mips_stub_frame_cache (this_frame, this_cache);
   trad_frame_get_id (this_trad_cache, this_id);
 }
 
   trad_frame_get_id (this_trad_cache, this_id);
 }
 
-static void
-mips_stub_frame_prev_register (struct frame_info *next_frame,
-                                void **this_cache,
-                                int regnum, int *optimizedp,
-                                enum lval_type *lvalp, CORE_ADDR *addrp,
-                                int *realnump, gdb_byte *valuep)
+static struct value *
+mips_stub_frame_prev_register (struct frame_info *this_frame,
+                              void **this_cache, int regnum)
 {
   struct trad_frame_cache *this_trad_cache
 {
   struct trad_frame_cache *this_trad_cache
-    = mips_stub_frame_cache (next_frame, this_cache);
-  trad_frame_get_register (this_trad_cache, next_frame, regnum, optimizedp,
-                          lvalp, addrp, realnump, valuep);
+    = mips_stub_frame_cache (this_frame, this_cache);
+  return trad_frame_get_register (this_trad_cache, this_frame, regnum);
 }
 
 }
 
-static const struct frame_unwind mips_stub_frame_unwind =
-{
-  NORMAL_FRAME,
-  mips_stub_frame_this_id,
-  mips_stub_frame_prev_register
-};
-
-static const struct frame_unwind *
-mips_stub_frame_sniffer (struct frame_info *next_frame)
+static int
+mips_stub_frame_sniffer (const struct frame_unwind *self,
+                        struct frame_info *this_frame, void **this_cache)
 {
 {
+  gdb_byte dummy[4];
   struct obj_section *s;
   struct obj_section *s;
-  CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+  CORE_ADDR pc = get_frame_address_in_block (this_frame);
+
+  /* Use the stub unwinder for unreadable code.  */
+  if (target_read_memory (get_frame_pc (this_frame), dummy, 4) != 0)
+    return 1;
 
   if (in_plt_section (pc, NULL))
 
   if (in_plt_section (pc, NULL))
-    return &mips_stub_frame_unwind;
+    return 1;
 
   /* Binutils for MIPS puts lazy resolution stubs into .MIPS.stubs.  */
   s = find_pc_section (pc);
 
   /* Binutils for MIPS puts lazy resolution stubs into .MIPS.stubs.  */
   s = find_pc_section (pc);
@@ -2259,17 +2301,26 @@ mips_stub_frame_sniffer (struct frame_info *next_frame)
   if (s != NULL
       && strcmp (bfd_get_section_name (s->objfile->obfd, s->the_bfd_section),
                 ".MIPS.stubs") == 0)
   if (s != NULL
       && strcmp (bfd_get_section_name (s->objfile->obfd, s->the_bfd_section),
                 ".MIPS.stubs") == 0)
-    return &mips_stub_frame_unwind;
+    return 1;
 
 
-  return NULL;
+  return 0;
 }
 
 }
 
+static const struct frame_unwind mips_stub_frame_unwind =
+{
+  NORMAL_FRAME,
+  mips_stub_frame_this_id,
+  mips_stub_frame_prev_register,
+  NULL,
+  mips_stub_frame_sniffer
+};
+
 static CORE_ADDR
 static CORE_ADDR
-mips_stub_frame_base_address (struct frame_info *next_frame,
+mips_stub_frame_base_address (struct frame_info *this_frame,
                              void **this_cache)
 {
   struct trad_frame_cache *this_trad_cache
                              void **this_cache)
 {
   struct trad_frame_cache *this_trad_cache
-    = mips_stub_frame_cache (next_frame, this_cache);
+    = mips_stub_frame_cache (this_frame, this_cache);
   return trad_frame_get_this_base (this_trad_cache);
 }
 
   return trad_frame_get_this_base (this_trad_cache);
 }
 
@@ -2282,9 +2333,9 @@ static const struct frame_base mips_stub_frame_base =
 };
 
 static const struct frame_base *
 };
 
 static const struct frame_base *
-mips_stub_frame_base_sniffer (struct frame_info *next_frame)
+mips_stub_frame_base_sniffer (struct frame_info *this_frame)
 {
 {
-  if (mips_stub_frame_sniffer (next_frame) != NULL)
+  if (mips_stub_frame_sniffer (&mips_stub_frame_unwind, this_frame, NULL))
     return &mips_stub_frame_base;
   else
     return NULL;
     return &mips_stub_frame_base;
   else
     return NULL;
@@ -2317,6 +2368,111 @@ mips_addr_bits_remove (CORE_ADDR addr)
     return addr;
 }
 
     return addr;
 }
 
+/* Instructions used during single-stepping of atomic sequences.  */
+#define LL_OPCODE 0x30
+#define LLD_OPCODE 0x34
+#define SC_OPCODE 0x38
+#define SCD_OPCODE 0x3c
+
+/* Checks for an atomic sequence of instructions beginning with a LL/LLD
+   instruction and ending with a SC/SCD instruction.  If such a sequence
+   is found, attempt to step through it.  A breakpoint is placed at the end of 
+   the sequence.  */
+
+static int
+deal_with_atomic_sequence (CORE_ADDR pc)
+{
+  CORE_ADDR breaks[2] = {-1, -1};
+  CORE_ADDR loc = pc;
+  CORE_ADDR branch_bp; /* Breakpoint at branch instruction's destination.  */
+  unsigned long insn;
+  int insn_count;
+  int index;
+  int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */  
+  const int atomic_sequence_length = 16; /* Instruction sequence length.  */
+
+  if (pc & 0x01)
+    return 0;
+
+  insn = mips_fetch_instruction (loc);
+  /* Assume all atomic sequences start with a ll/lld instruction.  */
+  if (itype_op (insn) != LL_OPCODE && itype_op (insn) != LLD_OPCODE)
+    return 0;
+
+  /* Assume that no atomic sequence is longer than "atomic_sequence_length" 
+     instructions.  */
+  for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
+    {
+      int is_branch = 0;
+      loc += MIPS_INSN32_SIZE;
+      insn = mips_fetch_instruction (loc);
+
+      /* Assume that there is at most one branch in the atomic
+        sequence.  If a branch is found, put a breakpoint in its
+        destination address.  */
+      switch (itype_op (insn))
+       {
+       case 0: /* SPECIAL */
+         if (rtype_funct (insn) >> 1 == 4) /* JR, JALR */
+           return 0; /* fallback to the standard single-step code. */
+         break;
+       case 1: /* REGIMM */
+         is_branch = ((itype_rt (insn) & 0xc0) == 0); /* B{LT,GE}Z* */
+         break;
+       case 2: /* J */
+       case 3: /* JAL */
+         return 0; /* fallback to the standard single-step code. */
+       case 4: /* BEQ */
+       case 5: /* BNE */
+       case 6: /* BLEZ */
+       case 7: /* BGTZ */
+       case 20: /* BEQL */
+       case 21: /* BNEL */
+       case 22: /* BLEZL */
+       case 23: /* BGTTL */
+         is_branch = 1;
+         break;
+       case 17: /* COP1 */
+       case 18: /* COP2 */
+       case 19: /* COP3 */
+         is_branch = (itype_rs (insn) == 8); /* BCzF, BCzFL, BCzT, BCzTL */
+         break;
+       }
+      if (is_branch)
+       {
+         branch_bp = loc + mips32_relative_offset (insn) + 4;
+         if (last_breakpoint >= 1)
+           return 0; /* More than one branch found, fallback to the
+                        standard single-step code.  */
+         breaks[1] = branch_bp;
+         last_breakpoint++;
+       }
+
+      if (itype_op (insn) == SC_OPCODE || itype_op (insn) == SCD_OPCODE)
+       break;
+    }
+
+  /* Assume that the atomic sequence ends with a sc/scd instruction.  */
+  if (itype_op (insn) != SC_OPCODE && itype_op (insn) != SCD_OPCODE)
+    return 0;
+
+  loc += MIPS_INSN32_SIZE;
+
+  /* Insert a breakpoint right after the end of the atomic sequence.  */
+  breaks[0] = loc;
+
+  /* Check for duplicated breakpoints.  Check also for a breakpoint
+     placed (branch instruction's destination) in the atomic sequence */
+  if (last_breakpoint && pc <= breaks[1] && breaks[1] <= breaks[0])
+    last_breakpoint = 0;
+
+  /* Effectively inserts the breakpoints.  */
+  for (index = 0; index <= last_breakpoint; index++)
+      insert_single_step_breakpoint (breaks[index]);
+
+  return 1;
+}
+
 /* mips_software_single_step() is called just before we want to resume
    the inferior, if we want to single-step it but there is no hardware
    or kernel single-step support (MIPS on GNU/Linux for example).  We find
 /* mips_software_single_step() is called just before we want to resume
    the inferior, if we want to single-step it but there is no hardware
    or kernel single-step support (MIPS on GNU/Linux for example).  We find
@@ -2328,6 +2484,9 @@ mips_software_single_step (struct frame_info *frame)
   CORE_ADDR pc, next_pc;
 
   pc = get_frame_pc (frame);
   CORE_ADDR pc, next_pc;
 
   pc = get_frame_pc (frame);
+  if (deal_with_atomic_sequence (pc))
+    return 1;
+
   next_pc = mips_next_pc (frame, pc);
 
   insert_single_step_breakpoint (next_pc);
   next_pc = mips_next_pc (frame, pc);
 
   insert_single_step_breakpoint (next_pc);
@@ -2422,15 +2581,28 @@ heuristic-fence-post' command.\n", paddr_nz (pc), paddr_nz (pc));
 
        /* On MIPS16, any one of the following is likely to be the
           start of a function:
 
        /* On MIPS16, any one of the following is likely to be the
           start of a function:
+          extend save
+          save
           entry
           addiu sp,-n
           daddiu sp,-n
           extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'  */
        inst = mips_fetch_instruction (start_pc);
           entry
           addiu sp,-n
           daddiu sp,-n
           extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'  */
        inst = mips_fetch_instruction (start_pc);
-       if (((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)      /* entry */
-           || (inst & 0xff80) == 0x6380        /* addiu sp,-n */
-           || (inst & 0xff80) == 0xfb80        /* daddiu sp,-n */
-           || ((inst & 0xf810) == 0xf010 && seen_adjsp))       /* extend -n */
+       if ((inst & 0xff80) == 0x6480)          /* save */
+         {
+           if (start_pc - instlen >= fence)
+             {
+               inst = mips_fetch_instruction (start_pc - instlen);
+               if ((inst & 0xf800) == 0xf000)  /* extend */
+                 start_pc -= instlen;
+             }
+           break;
+         }
+       else if (((inst & 0xf81f) == 0xe809
+                 && (inst & 0x700) != 0x700)   /* entry */
+                || (inst & 0xff80) == 0x6380   /* addiu sp,-n */
+                || (inst & 0xff80) == 0xfb80   /* daddiu sp,-n */
+                || ((inst & 0xf810) == 0xf010 && seen_adjsp))  /* extend -n */
          break;
        else if ((inst & 0xff00) == 0x6300      /* addiu sp */
                 || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
          break;
        else if ((inst & 0xff00) == 0x6300      /* addiu sp */
                 || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
@@ -2556,7 +2728,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
-  float_argreg = mips_fpa0_regnum (current_gdbarch);
+  float_argreg = mips_fpa0_regnum (gdbarch);
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
@@ -2633,7 +2805,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
             making the ABI determination.  */
          if (len == 8 && mips_abi (gdbarch) == MIPS_ABI_EABI32)
            {
             making the ABI determination.  */
          if (len == 8 && mips_abi (gdbarch) == MIPS_ABI_EABI32)
            {
-             int low_offset = gdbarch_byte_order (current_gdbarch)
+             int low_offset = gdbarch_byte_order (gdbarch)
                               == BFD_ENDIAN_BIG ? 4 : 0;
              unsigned long regval;
 
                               == BFD_ENDIAN_BIG ? 4 : 0;
              unsigned long regval;
 
@@ -2698,7 +2870,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
                    {
                      if (regsize == 8
                          && (typecode == TYPE_CODE_INT
                    {
                      if (regsize == 8
                          && (typecode == TYPE_CODE_INT
@@ -2780,20 +2952,122 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 /* Determine the return value convention being used.  */
 
 static enum return_value_convention
 /* Determine the return value convention being used.  */
 
 static enum return_value_convention
-mips_eabi_return_value (struct gdbarch *gdbarch,
+mips_eabi_return_value (struct gdbarch *gdbarch, struct type *func_type,
                        struct type *type, struct regcache *regcache,
                        gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                        struct type *type, struct regcache *regcache,
                        gdb_byte *readbuf, const gdb_byte *writebuf)
 {
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  int fp_return_type = 0;
+  int offset, regnum, xfer;
+
   if (TYPE_LENGTH (type) > 2 * mips_abi_regsize (gdbarch))
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (TYPE_LENGTH (type) > 2 * mips_abi_regsize (gdbarch))
     return RETURN_VALUE_STRUCT_CONVENTION;
-  if (readbuf)
-    memset (readbuf, 0, TYPE_LENGTH (type));
+
+  /* Floating point type?  */
+  if (tdep->mips_fpu_type != MIPS_FPU_NONE)
+    {
+      if (TYPE_CODE (type) == TYPE_CODE_FLT)
+       fp_return_type = 1;
+      /* Structs with a single field of float type 
+        are returned in a floating point register.  */
+      if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
+          || TYPE_CODE (type) == TYPE_CODE_UNION)
+         && TYPE_NFIELDS (type) == 1)
+       {
+         struct type *fieldtype = TYPE_FIELD_TYPE (type, 0);
+
+         if (TYPE_CODE (check_typedef (fieldtype)) == TYPE_CODE_FLT)
+           fp_return_type = 1;
+       }
+    }
+
+  if (fp_return_type)      
+    {
+      /* A floating-point value belongs in the least significant part
+        of FP0/FP1.  */
+      if (mips_debug)
+       fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
+      regnum = mips_regnum (gdbarch)->fp0;
+    }
+  else 
+    {
+      /* An integer value goes in V0/V1.  */
+      if (mips_debug)
+       fprintf_unfiltered (gdb_stderr, "Return scalar in $v0\n");
+      regnum = MIPS_V0_REGNUM;
+    }
+  for (offset = 0;
+       offset < TYPE_LENGTH (type);
+       offset += mips_abi_regsize (gdbarch), regnum++)
+    {
+      xfer = mips_abi_regsize (gdbarch);
+      if (offset + xfer > TYPE_LENGTH (type))
+       xfer = TYPE_LENGTH (type) - offset;
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch) + regnum, xfer,
+                         gdbarch_byte_order (gdbarch), readbuf, writebuf,
+                         offset);
+    }
+
   return RETURN_VALUE_REGISTER_CONVENTION;
 }
 
 
 /* N32/N64 ABI stuff.  */
 
   return RETURN_VALUE_REGISTER_CONVENTION;
 }
 
 
 /* N32/N64 ABI stuff.  */
 
+/* Search for a naturally aligned double at OFFSET inside a struct
+   ARG_TYPE.  The N32 / N64 ABIs pass these in floating point
+   registers.  */
+
+static int
+mips_n32n64_fp_arg_chunk_p (struct type *arg_type, int offset)
+{
+  int i;
+
+  if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
+    return 0;
+
+  if (MIPS_FPU_TYPE != MIPS_FPU_DOUBLE)
+    return 0;
+
+  if (TYPE_LENGTH (arg_type) < offset + MIPS64_REGSIZE)
+    return 0;
+
+  for (i = 0; i < TYPE_NFIELDS (arg_type); i++)
+    {
+      int pos;
+      struct type *field_type;
+
+      /* We're only looking at normal fields.  */
+      if (TYPE_FIELD_STATIC (arg_type, i)
+         || (TYPE_FIELD_BITPOS (arg_type, i) % 8) != 0)
+       continue;
+
+      /* If we have gone past the offset, there is no double to pass.  */
+      pos = TYPE_FIELD_BITPOS (arg_type, i) / 8;
+      if (pos > offset)
+       return 0;
+
+      field_type = check_typedef (TYPE_FIELD_TYPE (arg_type, i));
+
+      /* If this field is entirely before the requested offset, go
+        on to the next one.  */
+      if (pos + TYPE_LENGTH (field_type) <= offset)
+       continue;
+
+      /* If this is our special aligned double, we can stop.  */
+      if (TYPE_CODE (field_type) == TYPE_CODE_FLT
+         && TYPE_LENGTH (field_type) == MIPS64_REGSIZE)
+       return 1;
+
+      /* This field starts at or before the requested offset, and
+        overlaps it.  If it is a structure, recurse inwards.  */
+      return mips_n32n64_fp_arg_chunk_p (field_type, offset - pos);
+    }
+
+  return 0;
+}
+
 static CORE_ADDR
 mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                             struct regcache *regcache, CORE_ADDR bp_addr,
 static CORE_ADDR
 mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                             struct regcache *regcache, CORE_ADDR bp_addr,
@@ -2837,7 +3111,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
-  float_argreg = mips_fpa0_regnum (current_gdbarch);
+  float_argreg = mips_fpa0_regnum (gdbarch);
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
@@ -2868,35 +3142,36 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       val = value_contents (arg);
 
       if (fp_register_arg_p (typecode, arg_type)
       val = value_contents (arg);
 
       if (fp_register_arg_p (typecode, arg_type)
-         && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
+         && argreg <= MIPS_LAST_ARG_REGNUM)
        {
          /* This is a floating point value that fits entirely
             in a single register.  */
        {
          /* This is a floating point value that fits entirely
             in a single register.  */
-         /* On 32 bit ABI's the float_argreg is further adjusted
-            above to ensure that it is even register aligned.  */
          LONGEST regval = extract_unsigned_integer (val, len);
          if (mips_debug)
            fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
                                float_argreg, phex (regval, len));
          LONGEST regval = extract_unsigned_integer (val, len);
          if (mips_debug)
            fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
                                float_argreg, phex (regval, len));
-         regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
+         regcache_cooked_write_unsigned (regcache, float_argreg, regval);
 
          if (mips_debug)
            fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
                                argreg, phex (regval, len));
          regcache_cooked_write_unsigned (regcache, argreg, regval);
 
          if (mips_debug)
            fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
                                argreg, phex (regval, len));
          regcache_cooked_write_unsigned (regcache, argreg, regval);
-         argreg += 1;
+         float_argreg++;
+         argreg++;
        }
       else
        {
          /* Copy the argument to general registers or the stack in
             register-sized pieces.  Large arguments are split between
             registers and stack.  */
        }
       else
        {
          /* Copy the argument to general registers or the stack in
             register-sized pieces.  Large arguments are split between
             registers and stack.  */
-         /* Note: structs whose size is not a multiple of MIPS64_REGSIZE
-            are treated specially: Irix cc passes them in registers
-            where gcc sometimes puts them on the stack.  For maximum
-            compatibility, we will put them in both places.  */
-         int odd_sized_struct = (len > MIPS64_REGSIZE
-                                 && len % MIPS64_REGSIZE != 0);
+         /* For N32/N64, structs, unions, or other composite types are
+            treated as a sequence of doublewords, and are passed in integer
+            or floating point registers as though they were simple scalar
+            parameters to the extent that they fit, with any excess on the
+            stack packed according to the normal memory layout of the
+            object.
+            The caller does not reserve space for the register arguments;
+            the callee is responsible for reserving it if required.  */
          /* Note: Floating-point values that didn't fit into an FP
             register are only written to memory.  */
          while (len > 0)
          /* Note: Floating-point values that didn't fit into an FP
             register are only written to memory.  */
          while (len > 0)
@@ -2909,17 +3184,18 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
                                    partial_len);
 
                fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
                                    partial_len);
 
+             if (fp_register_arg_p (typecode, arg_type))
+               gdb_assert (argreg > MIPS_LAST_ARG_REGNUM);
+
              /* Write this portion of the argument to the stack.  */
              /* Write this portion of the argument to the stack.  */
-             if (argreg > MIPS_LAST_ARG_REGNUM
-                 || odd_sized_struct
-                 || fp_register_arg_p (typecode, arg_type))
+             if (argreg > MIPS_LAST_ARG_REGNUM)
                {
                  /* Should shorter than int integer values be
                     promoted to int before being stored? */
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
                {
                  /* Should shorter than int integer values be
                     promoted to int before being stored? */
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
                    {
                      if ((typecode == TYPE_CODE_INT
                           || typecode == TYPE_CODE_PTR
                    {
                      if ((typecode == TYPE_CODE_INT
                           || typecode == TYPE_CODE_PTR
@@ -2953,15 +3229,26 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                }
 
              /* Note!!! This is NOT an else clause.  Odd sized
                }
 
              /* Note!!! This is NOT an else clause.  Odd sized
-                structs may go thru BOTH paths.  Floating point
-                arguments will not.  */
+                structs may go thru BOTH paths.  */
              /* Write this portion of the argument to a general
                 purpose register.  */
              /* Write this portion of the argument to a general
                 purpose register.  */
-             if (argreg <= MIPS_LAST_ARG_REGNUM
-                 && !fp_register_arg_p (typecode, arg_type))
+             if (argreg <= MIPS_LAST_ARG_REGNUM)
                {
                {
-                 LONGEST regval =
-                   extract_unsigned_integer (val, partial_len);
+                 LONGEST regval;
+
+                 /* Sign extend pointers, 32-bit integers and signed
+                    16-bit and 8-bit integers; everything else is taken
+                    as is.  */
+
+                 if ((partial_len == 4
+                      && (typecode == TYPE_CODE_PTR
+                          || typecode == TYPE_CODE_INT))
+                     || (partial_len < 4
+                         && typecode == TYPE_CODE_INT
+                         && !TYPE_UNSIGNED (arg_type)))
+                   regval = extract_signed_integer (val, partial_len);
+                 else
+                   regval = extract_unsigned_integer (val, partial_len);
 
                  /* A non-floating-point argument being passed in a
                     general register.  If a struct or union, and if
 
                  /* A non-floating-point argument being passed in a
                     general register.  If a struct or union, and if
@@ -2972,7 +3259,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                     It does not seem to be necessary to do the
                     same for integral types.  */
 
                     It does not seem to be necessary to do the
                     same for integral types.  */
 
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
                      && partial_len < MIPS64_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
                      && partial_len < MIPS64_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
@@ -2984,6 +3271,19 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                                      argreg,
                                      phex (regval, MIPS64_REGSIZE));
                  regcache_cooked_write_unsigned (regcache, argreg, regval);
                                      argreg,
                                      phex (regval, MIPS64_REGSIZE));
                  regcache_cooked_write_unsigned (regcache, argreg, regval);
+
+                 if (mips_n32n64_fp_arg_chunk_p (arg_type,
+                                                 TYPE_LENGTH (arg_type) - len))
+                   {
+                     if (mips_debug)
+                       fprintf_filtered (gdb_stdlog, " - fpreg=%d val=%s",
+                                         float_argreg,
+                                         phex (regval, MIPS64_REGSIZE));
+                     regcache_cooked_write_unsigned (regcache, float_argreg,
+                                                     regval);
+                   }
+
+                 float_argreg++;
                  argreg++;
                }
 
                  argreg++;
                }
 
@@ -3011,14 +3311,35 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention
-mips_n32n64_return_value (struct gdbarch *gdbarch,
+mips_n32n64_return_value (struct gdbarch *gdbarch, struct type *func_type,
                          struct type *type, struct regcache *regcache,
                          gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                          struct type *type, struct regcache *regcache,
                          gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-  if (TYPE_CODE (type) == TYPE_CODE_STRUCT
-      || TYPE_CODE (type) == TYPE_CODE_UNION
-      || TYPE_CODE (type) == TYPE_CODE_ARRAY
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  /* From MIPSpro N32 ABI Handbook, Document Number: 007-2816-004
+
+     Function results are returned in $2 (and $3 if needed), or $f0 (and $f2
+     if needed), as appropriate for the type.  Composite results (struct,
+     union, or array) are returned in $2/$f0 and $3/$f2 according to the
+     following rules:
+
+     * A struct with only one or two floating point fields is returned in $f0
+     (and $f2 if necessary).  This is a generalization of the Fortran COMPLEX
+     case.
+
+     * Any other struct or union results of at most 128 bits are returned in
+     $2 (first 64 bits) and $3 (remainder, if necessary).
+
+     * Larger composite results are handled by converting the function to a
+     procedure with an implicit first parameter, which is a pointer to an area
+     reserved by the caller to receive the result.  [The o32-bit ABI requires
+     that all composite results be handled by conversion to implicit first
+     parameters.  The MIPS/SGI Fortran implementation has always made a
+     specific exception to return COMPLEX results in the floating point
+     registers.]  */
+
+  if (TYPE_CODE (type) == TYPE_CODE_ARRAY
       || TYPE_LENGTH (type) > 2 * MIPS64_REGSIZE)
     return RETURN_VALUE_STRUCT_CONVENTION;
   else if (TYPE_CODE (type) == TYPE_CODE_FLT
       || TYPE_LENGTH (type) > 2 * MIPS64_REGSIZE)
     return RETURN_VALUE_STRUCT_CONVENTION;
   else if (TYPE_CODE (type) == TYPE_CODE_FLT
@@ -3030,15 +3351,15 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
         eight bytes with the lower memory address are in $f0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $f0 and $f2\n");
         eight bytes with the lower memory address are in $f0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $f0 and $f2\n");
-      mips_xfer_register (regcache,
-                         gdbarch_num_regs (current_gdbarch)
-                         + mips_regnum (current_gdbarch)->fp0,
-                         8, gdbarch_byte_order (current_gdbarch),
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch)
+                         + mips_regnum (gdbarch)->fp0,
+                         8, gdbarch_byte_order (gdbarch),
                          readbuf, writebuf, 0);
                          readbuf, writebuf, 0);
-      mips_xfer_register (regcache,
-                         gdbarch_num_regs (current_gdbarch)
-                         + mips_regnum (current_gdbarch)->fp0 + 2,
-                         8, gdbarch_byte_order (current_gdbarch),
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch)
+                         + mips_regnum (gdbarch)->fp0 + 2,
+                         8, gdbarch_byte_order (gdbarch),
                          readbuf ? readbuf + 8 : readbuf,
                          writebuf ? writebuf + 8 : writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
                          readbuf ? readbuf + 8 : readbuf,
                          writebuf ? writebuf + 8 : writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3046,15 +3367,14 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
   else if (TYPE_CODE (type) == TYPE_CODE_FLT
           && tdep->mips_fpu_type != MIPS_FPU_NONE)
     {
   else if (TYPE_CODE (type) == TYPE_CODE_FLT
           && tdep->mips_fpu_type != MIPS_FPU_NONE)
     {
-      /* A floating-point value belongs in the least significant part
-         of FP0.  */
+      /* A single or double floating-point value that fits in FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
-      mips_xfer_register (regcache,
-                         gdbarch_num_regs (current_gdbarch)
-                         + mips_regnum (current_gdbarch)->fp0,
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch)
+                         + mips_regnum (gdbarch)->fp0,
                          TYPE_LENGTH (type),
                          TYPE_LENGTH (type),
-                         gdbarch_byte_order (current_gdbarch),
+                         gdbarch_byte_order (gdbarch),
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -3062,12 +3382,12 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
           && TYPE_NFIELDS (type) <= 2
           && TYPE_NFIELDS (type) >= 1
           && ((TYPE_NFIELDS (type) == 1
           && TYPE_NFIELDS (type) <= 2
           && TYPE_NFIELDS (type) >= 1
           && ((TYPE_NFIELDS (type) == 1
-               && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
+               && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 0)))
                    == TYPE_CODE_FLT))
               || (TYPE_NFIELDS (type) == 2
                    == TYPE_CODE_FLT))
               || (TYPE_NFIELDS (type) == 2
-                  && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
+                  && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 0)))
                       == TYPE_CODE_FLT)
                       == TYPE_CODE_FLT)
-                  && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
+                  && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 1)))
                       == TYPE_CODE_FLT)))
           && tdep->mips_fpu_type != MIPS_FPU_NONE)
     {
                       == TYPE_CODE_FLT)))
           && tdep->mips_fpu_type != MIPS_FPU_NONE)
     {
@@ -3076,7 +3396,7 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
          register..  */
       int regnum;
       int field;
          register..  */
       int regnum;
       int field;
-      for (field = 0, regnum = mips_regnum (current_gdbarch)->fp0;
+      for (field = 0, regnum = mips_regnum (gdbarch)->fp0;
           field < TYPE_NFIELDS (type); field++, regnum += 2)
        {
          int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
           field < TYPE_NFIELDS (type); field++, regnum += 2)
        {
          int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
@@ -3084,10 +3404,10 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
                                offset);
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
                                offset);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum,
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum,
                              TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
                              TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
-                             gdbarch_byte_order (current_gdbarch),
+                             gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3102,17 +3422,18 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
-          offset += register_size (current_gdbarch, regnum), regnum++)
+          offset += register_size (gdbarch, regnum), regnum++)
        {
        {
-         int xfer = register_size (current_gdbarch, regnum);
+         int xfer = register_size (gdbarch, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
                                offset, xfer, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
                                offset, xfer, regnum);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum, xfer,
-                             BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum,
+                             xfer, BFD_ENDIAN_UNKNOWN, readbuf, writebuf,
+                             offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -3124,17 +3445,17 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
-          offset += register_size (current_gdbarch, regnum), regnum++)
+          offset += register_size (gdbarch, regnum), regnum++)
        {
        {
-         int xfer = register_size (current_gdbarch, regnum);
+         int xfer = register_size (gdbarch, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum, xfer,
-                             gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum,
+                             xfer, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3195,7 +3516,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
-  float_argreg = mips_fpa0_regnum (current_gdbarch);
+  float_argreg = mips_fpa0_regnum (gdbarch);
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
@@ -3252,7 +3573,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
        {
          if (register_size (gdbarch, float_argreg) < 8 && len == 8)
            {
        {
          if (register_size (gdbarch, float_argreg) < 8 && len == 8)
            {
-             int low_offset = gdbarch_byte_order (current_gdbarch)
+             int low_offset = gdbarch_byte_order (gdbarch)
                               == BFD_ENDIAN_BIG ? 4 : 0;
              unsigned long regval;
 
                               == BFD_ENDIAN_BIG ? 4 : 0;
              unsigned long regval;
 
@@ -3404,7 +3725,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                     identified as such and GDB gets tweaked
                     accordingly.  */
 
                     identified as such and GDB gets tweaked
                     accordingly.  */
 
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
                      && partial_len < MIPS32_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
                      && partial_len < MIPS32_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
@@ -3448,11 +3769,11 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention
-mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
-                      struct regcache *regcache,
+mips_o32_return_value (struct gdbarch *gdbarch, struct type *func_type,
+                      struct type *type, struct regcache *regcache,
                       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
       || TYPE_CODE (type) == TYPE_CODE_UNION
 
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
       || TYPE_CODE (type) == TYPE_CODE_UNION
@@ -3465,11 +3786,11 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
          least significant part of FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
          least significant part of FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
-      mips_xfer_register (regcache,
-                         gdbarch_num_regs (current_gdbarch)
-                           + mips_regnum (current_gdbarch)->fp0,
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch)
+                           + mips_regnum (gdbarch)->fp0,
                          TYPE_LENGTH (type),
                          TYPE_LENGTH (type),
-                         gdbarch_byte_order (current_gdbarch),
+                         gdbarch_byte_order (gdbarch),
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -3481,30 +3802,30 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
          FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp1/$fp0\n");
          FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp1/$fp0\n");
-      switch (gdbarch_byte_order (current_gdbarch))
+      switch (gdbarch_byte_order (gdbarch))
        {
        case BFD_ENDIAN_LITTLE:
        {
        case BFD_ENDIAN_LITTLE:
-         mips_xfer_register (regcache,
-                             gdbarch_num_regs (current_gdbarch)
-                               + mips_regnum (current_gdbarch)->fp0 +
-                             0, 4, gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch)
+                               + mips_regnum (gdbarch)->fp0 +
+                             0, 4, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, 0);
                              readbuf, writebuf, 0);
-         mips_xfer_register (regcache,
-                             gdbarch_num_regs (current_gdbarch)
-                               + mips_regnum (current_gdbarch)->fp0 + 1,
-                             4, gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch)
+                               + mips_regnum (gdbarch)->fp0 + 1,
+                             4, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, 4);
          break;
        case BFD_ENDIAN_BIG:
                              readbuf, writebuf, 4);
          break;
        case BFD_ENDIAN_BIG:
-         mips_xfer_register (regcache,
-                             gdbarch_num_regs (current_gdbarch)
-                               + mips_regnum (current_gdbarch)->fp0 + 1,
-                             4, gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch)
+                               + mips_regnum (gdbarch)->fp0 + 1,
+                             4, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, 0);
                              readbuf, writebuf, 0);
-         mips_xfer_register (regcache,
-                             gdbarch_num_regs (current_gdbarch)
-                               + mips_regnum (current_gdbarch)->fp0 + 0,
-                             4, gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch)
+                               + mips_regnum (gdbarch)->fp0 + 0,
+                             4, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, 4);
          break;
        default:
                              readbuf, writebuf, 4);
          break;
        default:
@@ -3532,7 +3853,7 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
       gdb_byte reg[MAX_REGISTER_SIZE];
       int regnum;
       int field;
       gdb_byte reg[MAX_REGISTER_SIZE];
       int regnum;
       int field;
-      for (field = 0, regnum = mips_regnum (current_gdbarch)->fp0;
+      for (field = 0, regnum = mips_regnum (gdbarch)->fp0;
           field < TYPE_NFIELDS (type); field++, regnum += 2)
        {
          int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
           field < TYPE_NFIELDS (type); field++, regnum += 2)
        {
          int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
@@ -3540,10 +3861,10 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
                                offset);
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
                                offset);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum,
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum,
                              TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
                              TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
-                             gdbarch_byte_order (current_gdbarch),
+                             gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3560,16 +3881,16 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
       int regnum;
       for (offset = 0, regnum = MIPS_V0_REGNUM;
           offset < TYPE_LENGTH (type);
-          offset += register_size (current_gdbarch, regnum), regnum++)
+          offset += register_size (gdbarch, regnum), regnum++)
        {
        {
-         int xfer = register_size (current_gdbarch, regnum);
+         int xfer = register_size (gdbarch, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
                                offset, xfer, regnum);
          if (offset + xfer > TYPE_LENGTH (type))
            xfer = TYPE_LENGTH (type) - offset;
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
                                offset, xfer, regnum);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum, xfer,
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum, xfer,
                              BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3592,9 +3913,9 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum, xfer,
-                             gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum, xfer,
+                             gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3654,7 +3975,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
-  float_argreg = mips_fpa0_regnum (current_gdbarch);
+  float_argreg = mips_fpa0_regnum (gdbarch);
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
 
   /* The struct_return pointer occupies the first parameter-passing reg.  */
   if (struct_return)
@@ -3741,7 +4062,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
                  int longword_offset = 0;
                  CORE_ADDR addr;
                  stack_used_p = 1;
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
                    {
                      if ((typecode == TYPE_CODE_INT
                           || typecode == TYPE_CODE_PTR
                    {
                      if ((typecode == TYPE_CODE_INT
                           || typecode == TYPE_CODE_PTR
@@ -3793,7 +4114,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                     It does not seem to be necessary to do the
                     same for integral types. */
 
                     It does not seem to be necessary to do the
                     same for integral types. */
 
-                 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
+                 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
                      && partial_len < MIPS64_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
                      && partial_len < MIPS64_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT
                          || typecode == TYPE_CODE_UNION))
@@ -3837,11 +4158,11 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention
-mips_o64_return_value (struct gdbarch *gdbarch,
+mips_o64_return_value (struct gdbarch *gdbarch, struct type *func_type,
                       struct type *type, struct regcache *regcache,
                       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                       struct type *type, struct regcache *regcache,
                       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
       || TYPE_CODE (type) == TYPE_CODE_UNION
 
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
       || TYPE_CODE (type) == TYPE_CODE_UNION
@@ -3853,11 +4174,11 @@ mips_o64_return_value (struct gdbarch *gdbarch,
          part of FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
          part of FP0.  */
       if (mips_debug)
        fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
-      mips_xfer_register (regcache,
-                         gdbarch_num_regs (current_gdbarch)
-                           + mips_regnum (current_gdbarch)->fp0,
+      mips_xfer_register (gdbarch, regcache,
+                         gdbarch_num_regs (gdbarch)
+                           + mips_regnum (gdbarch)->fp0,
                          TYPE_LENGTH (type),
                          TYPE_LENGTH (type),
-                         gdbarch_byte_order (current_gdbarch),
+                         gdbarch_byte_order (gdbarch),
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
                          readbuf, writebuf, 0);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -3877,9 +4198,9 @@ mips_o64_return_value (struct gdbarch *gdbarch,
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
          if (mips_debug)
            fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
                                offset, xfer, regnum);
-         mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
-                                       + regnum, xfer,
-                             gdbarch_byte_order (current_gdbarch),
+         mips_xfer_register (gdbarch, regcache,
+                             gdbarch_num_regs (gdbarch) + regnum,
+                             xfer, gdbarch_byte_order (gdbarch),
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
                              readbuf, writebuf, offset);
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -3935,19 +4256,20 @@ static void
 mips_read_fp_register_single (struct frame_info *frame, int regno,
                              gdb_byte *rare_buffer)
 {
 mips_read_fp_register_single (struct frame_info *frame, int regno,
                              gdb_byte *rare_buffer)
 {
-  int raw_size = register_size (current_gdbarch, regno);
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  int raw_size = register_size (gdbarch, regno);
   gdb_byte *raw_buffer = alloca (raw_size);
 
   if (!frame_register_read (frame, regno, raw_buffer))
     error (_("can't read register %d (%s)"),
   gdb_byte *raw_buffer = alloca (raw_size);
 
   if (!frame_register_read (frame, regno, raw_buffer))
     error (_("can't read register %d (%s)"),
-          regno, gdbarch_register_name (current_gdbarch, regno));
+          regno, gdbarch_register_name (gdbarch, regno));
   if (raw_size == 8)
     {
       /* We have a 64-bit value for this register.  Find the low-order
          32 bits.  */
       int offset;
 
   if (raw_size == 8)
     {
       /* We have a 64-bit value for this register.  Find the low-order
          32 bits.  */
       int offset;
 
-      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       else
        offset = 0;
        offset = 4;
       else
        offset = 0;
@@ -3968,7 +4290,8 @@ static void
 mips_read_fp_register_double (struct frame_info *frame, int regno,
                              gdb_byte *rare_buffer)
 {
 mips_read_fp_register_double (struct frame_info *frame, int regno,
                              gdb_byte *rare_buffer)
 {
-  int raw_size = register_size (current_gdbarch, regno);
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  int raw_size = register_size (gdbarch, regno);
 
   if (raw_size == 8 && !mips2_fp_compat (frame))
     {
 
   if (raw_size == 8 && !mips2_fp_compat (frame))
     {
@@ -3976,18 +4299,20 @@ mips_read_fp_register_double (struct frame_info *frame, int regno,
          all 64 bits.  */
       if (!frame_register_read (frame, regno, rare_buffer))
        error (_("can't read register %d (%s)"),
          all 64 bits.  */
       if (!frame_register_read (frame, regno, rare_buffer))
        error (_("can't read register %d (%s)"),
-              regno, gdbarch_register_name (current_gdbarch, regno));
+              regno, gdbarch_register_name (gdbarch, regno));
     }
   else
     {
     }
   else
     {
-      if ((regno - mips_regnum (current_gdbarch)->fp0) & 1)
+      int rawnum = regno % gdbarch_num_regs (gdbarch);
+
+      if ((rawnum - mips_regnum (gdbarch)->fp0) & 1)
        internal_error (__FILE__, __LINE__,
                        _("mips_read_fp_register_double: bad access to "
                        "odd-numbered FP register"));
 
       /* mips_read_fp_register_single will find the correct 32 bits from
          each register.  */
        internal_error (__FILE__, __LINE__,
                        _("mips_read_fp_register_double: bad access to "
                        "odd-numbered FP register"));
 
       /* mips_read_fp_register_single will find the correct 32 bits from
          each register.  */
-      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        {
          mips_read_fp_register_single (frame, regno, rare_buffer + 4);
          mips_read_fp_register_single (frame, regno + 1, rare_buffer);
        {
          mips_read_fp_register_single (frame, regno, rare_buffer + 4);
          mips_read_fp_register_single (frame, regno + 1, rare_buffer);
@@ -4004,21 +4329,19 @@ static void
 mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
                        int regnum)
 {                              /* do values for FP (float) regs */
 mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
                        int regnum)
 {                              /* do values for FP (float) regs */
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   gdb_byte *raw_buffer;
   double doub, flt1;   /* doubles extracted from raw hex data */
   int inv1, inv2;
 
   gdb_byte *raw_buffer;
   double doub, flt1;   /* doubles extracted from raw hex data */
   int inv1, inv2;
 
-  raw_buffer = alloca (2 * register_size (current_gdbarch,
-                                         mips_regnum (current_gdbarch)->fp0));
+  raw_buffer = alloca (2 * register_size (gdbarch, mips_regnum (gdbarch)->fp0));
 
 
-  fprintf_filtered (file, "%s:",
-                   gdbarch_register_name (current_gdbarch, regnum));
+  fprintf_filtered (file, "%s:", gdbarch_register_name (gdbarch, regnum));
   fprintf_filtered (file, "%*s",
   fprintf_filtered (file, "%*s",
-                   4 - (int) strlen (gdbarch_register_name
-                                       (current_gdbarch, regnum)),
+                   4 - (int) strlen (gdbarch_register_name (gdbarch, regnum)),
                    "");
 
                    "");
 
-  if (register_size (current_gdbarch, regnum) == 4 || mips2_fp_compat (frame))
+  if (register_size (gdbarch, regnum) == 4 || mips2_fp_compat (frame))
     {
       /* 4-byte registers: Print hex and floating.  Also print even
          numbered registers as doubles.  */
     {
       /* 4-byte registers: Print hex and floating.  Also print even
          numbered registers as doubles.  */
@@ -4034,7 +4357,7 @@ mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
       else
        fprintf_filtered (file, "%-17.9g", flt1);
 
       else
        fprintf_filtered (file, "%-17.9g", flt1);
 
-      if (regnum % 2 == 0)
+      if ((regnum - gdbarch_num_regs (gdbarch)) % 2 == 0)
        {
          mips_read_fp_register_double (frame, regnum, raw_buffer);
          doub = unpack_double (mips_double_register_type (), raw_buffer,
        {
          mips_read_fp_register_double (frame, regnum, raw_buffer);
          doub = unpack_double (mips_double_register_type (), raw_buffer,
@@ -4092,11 +4415,11 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
   if (!frame_register_read (frame, regnum, raw_buffer))
     {
       fprintf_filtered (file, "%s: [Invalid]",
   if (!frame_register_read (frame, regnum, raw_buffer))
     {
       fprintf_filtered (file, "%s: [Invalid]",
-                       gdbarch_register_name (current_gdbarch, regnum));
+                       gdbarch_register_name (gdbarch, regnum));
       return;
     }
 
       return;
     }
 
-  fputs_filtered (gdbarch_register_name (current_gdbarch, regnum), file);
+  fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
 
   /* The problem with printing numeric register names (r26, etc.) is that
      the user can't use them on input.  Probably the best solution is to
 
   /* The problem with printing numeric register names (r26, etc.) is that
      the user can't use them on input.  Probably the best solution is to
@@ -4107,10 +4430,9 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
   else
     fprintf_filtered (file, ": ");
 
   else
     fprintf_filtered (file, ": ");
 
-  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
     offset =
     offset =
-      register_size (current_gdbarch,
-                    regnum) - register_size (current_gdbarch, regnum);
+      register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
   else
     offset = 0;
 
   else
     offset = 0;
 
@@ -4148,18 +4470,17 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
 
   /* For GP registers, we print a separate row of names above the vals */
   for (col = 0, regnum = start_regnum;
 
   /* For GP registers, we print a separate row of names above the vals */
   for (col = 0, regnum = start_regnum;
-       col < ncols && regnum < gdbarch_num_regs (current_gdbarch)
-                              + gdbarch_num_pseudo_regs (current_gdbarch);
+       col < ncols && regnum < gdbarch_num_regs (gdbarch)
+                              + gdbarch_num_pseudo_regs (gdbarch);
        regnum++)
     {
        regnum++)
     {
-      if (*gdbarch_register_name (current_gdbarch, regnum) == '\0')
+      if (*gdbarch_register_name (gdbarch, regnum) == '\0')
        continue;               /* unused register */
       if (TYPE_CODE (register_type (gdbarch, regnum)) ==
          TYPE_CODE_FLT)
        break;                  /* end the row: reached FP register */
       /* Large registers are handled separately.  */
        continue;               /* unused register */
       if (TYPE_CODE (register_type (gdbarch, regnum)) ==
          TYPE_CODE_FLT)
        break;                  /* end the row: reached FP register */
       /* Large registers are handled separately.  */
-      if (register_size (current_gdbarch, regnum)
-         > mips_abi_regsize (current_gdbarch))
+      if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
        {
          if (col > 0)
            break;              /* End the row before this register.  */
        {
          if (col > 0)
            break;              /* End the row before this register.  */
@@ -4172,8 +4493,8 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
       if (col == 0)
        fprintf_filtered (file, "     ");
       fprintf_filtered (file,
       if (col == 0)
        fprintf_filtered (file, "     ");
       fprintf_filtered (file,
-                       mips_abi_regsize (current_gdbarch) == 8 ? "%17s" : "%9s",
-                       gdbarch_register_name (current_gdbarch, regnum));
+                       mips_abi_regsize (gdbarch) == 8 ? "%17s" : "%9s",
+                       gdbarch_register_name (gdbarch, regnum));
       col++;
     }
 
       col++;
     }
 
@@ -4181,45 +4502,43 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
     return regnum;
 
   /* print the R0 to R31 names */
     return regnum;
 
   /* print the R0 to R31 names */
-  if ((start_regnum % gdbarch_num_regs (current_gdbarch)) < MIPS_NUMREGS)
+  if ((start_regnum % gdbarch_num_regs (gdbarch)) < MIPS_NUMREGS)
     fprintf_filtered (file, "\n R%-4d",
     fprintf_filtered (file, "\n R%-4d",
-                     start_regnum % gdbarch_num_regs (current_gdbarch));
+                     start_regnum % gdbarch_num_regs (gdbarch));
   else
     fprintf_filtered (file, "\n      ");
 
   /* now print the values in hex, 4 or 8 to the row */
   for (col = 0, regnum = start_regnum;
   else
     fprintf_filtered (file, "\n      ");
 
   /* now print the values in hex, 4 or 8 to the row */
   for (col = 0, regnum = start_regnum;
-       col < ncols && regnum < gdbarch_num_regs (current_gdbarch)
-                              + gdbarch_num_pseudo_regs (current_gdbarch);
+       col < ncols && regnum < gdbarch_num_regs (gdbarch)
+                              + gdbarch_num_pseudo_regs (gdbarch);
        regnum++)
     {
        regnum++)
     {
-      if (*gdbarch_register_name (current_gdbarch, regnum) == '\0')
+      if (*gdbarch_register_name (gdbarch, regnum) == '\0')
        continue;               /* unused register */
       if (TYPE_CODE (register_type (gdbarch, regnum)) ==
          TYPE_CODE_FLT)
        break;                  /* end row: reached FP register */
        continue;               /* unused register */
       if (TYPE_CODE (register_type (gdbarch, regnum)) ==
          TYPE_CODE_FLT)
        break;                  /* end row: reached FP register */
-      if (register_size (current_gdbarch, regnum)
-         > mips_abi_regsize (current_gdbarch))
+      if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
        break;                  /* End row: large register.  */
 
       /* OK: get the data in raw format.  */
       if (!frame_register_read (frame, regnum, raw_buffer))
        error (_("can't read register %d (%s)"),
        break;                  /* End row: large register.  */
 
       /* OK: get the data in raw format.  */
       if (!frame_register_read (frame, regnum, raw_buffer))
        error (_("can't read register %d (%s)"),
-              regnum, gdbarch_register_name (current_gdbarch, regnum));
+              regnum, gdbarch_register_name (gdbarch, regnum));
       /* pad small registers */
       for (byte = 0;
       /* pad small registers */
       for (byte = 0;
-          byte < (mips_abi_regsize (current_gdbarch)
-                  - register_size (current_gdbarch, regnum)); byte++)
+          byte < (mips_abi_regsize (gdbarch)
+                  - register_size (gdbarch, regnum)); byte++)
        printf_filtered ("  ");
       /* Now print the register value in hex, endian order. */
        printf_filtered ("  ");
       /* Now print the register value in hex, endian order. */
-      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        for (byte =
        for (byte =
-            register_size (current_gdbarch,
-                           regnum) - register_size (current_gdbarch, regnum);
-            byte < register_size (current_gdbarch, regnum); byte++)
+            register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
+            byte < register_size (gdbarch, regnum); byte++)
          fprintf_filtered (file, "%02x", raw_buffer[byte]);
       else
          fprintf_filtered (file, "%02x", raw_buffer[byte]);
       else
-       for (byte = register_size (current_gdbarch, regnum) - 1;
+       for (byte = register_size (gdbarch, regnum) - 1;
             byte >= 0; byte--)
          fprintf_filtered (file, "%02x", raw_buffer[byte]);
       fprintf_filtered (file, " ");
             byte >= 0; byte--)
          fprintf_filtered (file, "%02x", raw_buffer[byte]);
       fprintf_filtered (file, " ");
@@ -4239,8 +4558,8 @@ mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 {
   if (regnum != -1)            /* do one specified register */
     {
 {
   if (regnum != -1)            /* do one specified register */
     {
-      gdb_assert (regnum >= gdbarch_num_regs (current_gdbarch));
-      if (*(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
+      gdb_assert (regnum >= gdbarch_num_regs (gdbarch));
+      if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
        error (_("Not a valid register for the current processor type"));
 
       mips_print_register (file, frame, regnum);
        error (_("Not a valid register for the current processor type"));
 
       mips_print_register (file, frame, regnum);
@@ -4249,9 +4568,9 @@ mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
   else
     /* do all (or most) registers */
     {
   else
     /* do all (or most) registers */
     {
-      regnum = gdbarch_num_regs (current_gdbarch);
-      while (regnum < gdbarch_num_regs (current_gdbarch)
-                     + gdbarch_num_pseudo_regs (current_gdbarch))
+      regnum = gdbarch_num_regs (gdbarch);
+      while (regnum < gdbarch_num_regs (gdbarch)
+                     + gdbarch_num_pseudo_regs (gdbarch))
        {
          if (TYPE_CODE (register_type (gdbarch, regnum)) ==
              TYPE_CODE_FLT)
        {
          if (TYPE_CODE (register_type (gdbarch, regnum)) ==
              TYPE_CODE_FLT)
@@ -4314,7 +4633,7 @@ mips_single_step_through_delay (struct gdbarch *gdbarch,
    delay slot of a non-prologue instruction).  */
 
 static CORE_ADDR
    delay slot of a non-prologue instruction).  */
 
 static CORE_ADDR
-mips_skip_prologue (CORE_ADDR pc)
+mips_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   CORE_ADDR limit_pc;
   CORE_ADDR func_addr;
 {
   CORE_ADDR limit_pc;
   CORE_ADDR func_addr;
@@ -4345,6 +4664,95 @@ mips_skip_prologue (CORE_ADDR pc)
     return mips32_scan_prologue (pc, limit_pc, NULL, NULL);
 }
 
     return mips32_scan_prologue (pc, limit_pc, NULL, NULL);
 }
 
+/* Check whether the PC is in a function epilogue (32-bit version).
+   This is a helper function for mips_in_function_epilogue_p.  */
+static int
+mips32_in_function_epilogue_p (CORE_ADDR pc)
+{
+  CORE_ADDR func_addr = 0, func_end = 0;
+
+  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+    {
+      /* The MIPS epilogue is max. 12 bytes long.  */
+      CORE_ADDR addr = func_end - 12;
+
+      if (addr < func_addr + 4)
+        addr = func_addr + 4;
+      if (pc < addr)
+        return 0;
+
+      for (; pc < func_end; pc += MIPS_INSN32_SIZE)
+       {
+         unsigned long high_word;
+         unsigned long inst;
+
+         inst = mips_fetch_instruction (pc);
+         high_word = (inst >> 16) & 0xffff;
+
+         if (high_word != 0x27bd       /* addiu $sp,$sp,offset */
+             && high_word != 0x67bd    /* daddiu $sp,$sp,offset */
+             && inst != 0x03e00008     /* jr $ra */
+             && inst != 0x00000000)    /* nop */
+           return 0;
+       }
+
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Check whether the PC is in a function epilogue (16-bit version).
+   This is a helper function for mips_in_function_epilogue_p.  */
+static int
+mips16_in_function_epilogue_p (CORE_ADDR pc)
+{
+  CORE_ADDR func_addr = 0, func_end = 0;
+
+  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+    {
+      /* The MIPS epilogue is max. 12 bytes long.  */
+      CORE_ADDR addr = func_end - 12;
+
+      if (addr < func_addr + 4)
+        addr = func_addr + 4;
+      if (pc < addr)
+        return 0;
+
+      for (; pc < func_end; pc += MIPS_INSN16_SIZE)
+       {
+         unsigned short inst;
+
+         inst = mips_fetch_instruction (pc);
+
+         if ((inst & 0xf800) == 0xf000)        /* extend */
+           continue;
+
+         if (inst != 0x6300            /* addiu $sp,offset */
+             && inst != 0xfb00         /* daddiu $sp,$sp,offset */
+             && inst != 0xe820         /* jr $ra */
+             && inst != 0xe8a0         /* jrc $ra */
+             && inst != 0x6500)        /* nop */
+           return 0;
+       }
+
+      return 1;
+    }
+
+  return 0;
+}
+
+/* The epilogue is defined here as the area at the end of a function,
+   after an instruction which destroys the function's stack frame.  */
+static int
+mips_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+  if (mips_pc_is_mips16 (pc))
+    return mips16_in_function_epilogue_p (pc);
+  else
+    return mips32_in_function_epilogue_p (pc);
+}
+
 /* Root of all "set mips "/"show mips " commands. This will eventually be
    used for all MIPS-specific commands.  */
 
 /* Root of all "set mips "/"show mips " commands. This will eventually be
    used for all MIPS-specific commands.  */
 
@@ -4368,6 +4776,15 @@ static void
 show_mipsfpu_command (char *args, int from_tty)
 {
   char *fpu;
 show_mipsfpu_command (char *args, int from_tty)
 {
   char *fpu;
+
+  if (gdbarch_bfd_arch_info (current_gdbarch)->arch != bfd_arch_mips)
+    {
+      printf_unfiltered
+       ("The MIPS floating-point coprocessor is unknown "
+        "because the current architecture is not MIPS.\n");
+      return;
+    }
+
   switch (MIPS_FPU_TYPE)
     {
     case MIPS_FPU_SINGLE:
   switch (MIPS_FPU_TYPE)
     {
     case MIPS_FPU_SINGLE:
@@ -4460,7 +4877,7 @@ deprecated_mips_set_processor_regs_hack (void)
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
   ULONGEST prid;
 
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
   ULONGEST prid;
 
-  regcache_cooked_read_unsigned (current_regcache,
+  regcache_cooked_read_unsigned (get_current_regcache (),
                                 MIPS_PRID_REGNUM, &prid);
   if ((prid & ~0xf) == 0x700)
     tdep->mips_processor_reg_names = mips_r3041_reg_names;
                                 MIPS_PRID_REGNUM, &prid);
   if ((prid & ~0xf) == 0x700)
     tdep->mips_processor_reg_names = mips_r3041_reg_names;
@@ -4511,7 +4928,7 @@ gdb_print_insn_mips (bfd_vma memaddr, struct disassemble_info *info)
     info->disassembler_options = "gpr-names=32";
 
   /* Call the appropriate disassembler based on the target endian-ness.  */
     info->disassembler_options = "gpr-names=32";
 
   /* Call the appropriate disassembler based on the target endian-ness.  */
-  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+  if (info->endian == BFD_ENDIAN_BIG)
     return print_insn_big_mips (memaddr, info);
   else
     return print_insn_little_mips (memaddr, info);
     return print_insn_big_mips (memaddr, info);
   else
     return print_insn_little_mips (memaddr, info);
@@ -4525,9 +4942,9 @@ gdb_print_insn_mips (bfd_vma memaddr, struct disassemble_info *info)
    should be inserted.  */
 
 static const gdb_byte *
    should be inserted.  */
 
 static const gdb_byte *
-mips_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+mips_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
 {
-  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
     {
       if (mips_pc_is_mips16 (*pcptr))
        {
     {
       if (mips_pc_is_mips16 (*pcptr))
        {
@@ -4686,23 +5103,22 @@ mips_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
    [1 * gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
 
 static int
    [1 * gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
 
 static int
-mips_stab_reg_to_regnum (int num)
+mips_stab_reg_to_regnum (struct gdbarch *gdbarch, int num)
 {
   int regnum;
   if (num >= 0 && num < 32)
     regnum = num;
   else if (num >= 38 && num < 70)
 {
   int regnum;
   if (num >= 0 && num < 32)
     regnum = num;
   else if (num >= 38 && num < 70)
-    regnum = num + mips_regnum (current_gdbarch)->fp0 - 38;
+    regnum = num + mips_regnum (gdbarch)->fp0 - 38;
   else if (num == 70)
   else if (num == 70)
-    regnum = mips_regnum (current_gdbarch)->hi;
+    regnum = mips_regnum (gdbarch)->hi;
   else if (num == 71)
   else if (num == 71)
-    regnum = mips_regnum (current_gdbarch)->lo;
+    regnum = mips_regnum (gdbarch)->lo;
   else
     /* This will hopefully (eventually) provoke a warning.  Should
        we be calling complaint() here?  */
   else
     /* This will hopefully (eventually) provoke a warning.  Should
        we be calling complaint() here?  */
-    return gdbarch_num_regs (current_gdbarch)
-          + gdbarch_num_pseudo_regs (current_gdbarch);
-  return gdbarch_num_regs (current_gdbarch) + regnum;
+    return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
+  return gdbarch_num_regs (gdbarch) + regnum;
 }
 
 
 }
 
 
@@ -4710,39 +5126,36 @@ mips_stab_reg_to_regnum (int num)
    gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
 
 static int
    gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
 
 static int
-mips_dwarf_dwarf2_ecoff_reg_to_regnum (int num)
+mips_dwarf_dwarf2_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int num)
 {
   int regnum;
   if (num >= 0 && num < 32)
     regnum = num;
   else if (num >= 32 && num < 64)
 {
   int regnum;
   if (num >= 0 && num < 32)
     regnum = num;
   else if (num >= 32 && num < 64)
-    regnum = num + mips_regnum (current_gdbarch)->fp0 - 32;
+    regnum = num + mips_regnum (gdbarch)->fp0 - 32;
   else if (num == 64)
   else if (num == 64)
-    regnum = mips_regnum (current_gdbarch)->hi;
+    regnum = mips_regnum (gdbarch)->hi;
   else if (num == 65)
   else if (num == 65)
-    regnum = mips_regnum (current_gdbarch)->lo;
+    regnum = mips_regnum (gdbarch)->lo;
   else
     /* This will hopefully (eventually) provoke a warning.  Should we
        be calling complaint() here?  */
   else
     /* This will hopefully (eventually) provoke a warning.  Should we
        be calling complaint() here?  */
-    return gdbarch_num_regs (current_gdbarch)
-          + gdbarch_num_pseudo_regs (current_gdbarch);
-  return gdbarch_num_regs (current_gdbarch) + regnum;
+    return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
+  return gdbarch_num_regs (gdbarch) + regnum;
 }
 
 static int
 }
 
 static int
-mips_register_sim_regno (int regnum)
+mips_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 {
   /* Only makes sense to supply raw registers.  */
 {
   /* Only makes sense to supply raw registers.  */
-  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch));
+  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
   /* FIXME: cagney/2002-05-13: Need to look at the pseudo register to
      decide if it is valid.  Should instead define a standard sim/gdb
      register numbering scheme.  */
   /* FIXME: cagney/2002-05-13: Need to look at the pseudo register to
      decide if it is valid.  Should instead define a standard sim/gdb
      register numbering scheme.  */
-  if (gdbarch_register_name (current_gdbarch,
-                            gdbarch_num_regs
-                              (current_gdbarch) + regnum) != NULL
-      && gdbarch_register_name (current_gdbarch,
-                               gdbarch_num_regs
-                                 (current_gdbarch) + regnum)[0] != '\0')
+  if (gdbarch_register_name (gdbarch,
+                            gdbarch_num_regs (gdbarch) + regnum) != NULL
+      && gdbarch_register_name (gdbarch,
+                               gdbarch_num_regs (gdbarch) + regnum)[0] != '\0')
     return regnum;
   else
     return LEGACY_SIM_REGNO_IGNORE;
     return regnum;
   else
     return LEGACY_SIM_REGNO_IGNORE;
@@ -4759,6 +5172,19 @@ mips_integer_to_address (struct gdbarch *gdbarch,
   return (CORE_ADDR) extract_signed_integer (buf, TYPE_LENGTH (type));
 }
 
   return (CORE_ADDR) extract_signed_integer (buf, TYPE_LENGTH (type));
 }
 
+/* Dummy virtual frame pointer method.  This is no more or less accurate
+   than most other architectures; we just need to be explicit about it,
+   because the pseudo-register gdbarch_sp_regnum will otherwise lead to
+   an assertion failure.  */
+
+static void
+mips_virtual_frame_pointer (struct gdbarch *gdbarch, 
+                           CORE_ADDR pc, int *reg, LONGEST *offset)
+{
+  *reg = MIPS_SP_REGNUM;
+  *offset = 0;
+}
+
 static void
 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
 {
 static void
 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
 {
@@ -4816,30 +5242,16 @@ global_mips_abi (void)
 static void
 mips_register_g_packet_guesses (struct gdbarch *gdbarch)
 {
 static void
 mips_register_g_packet_guesses (struct gdbarch *gdbarch)
 {
-  static struct target_desc *tdesc_gp32, *tdesc_gp64;
-
-  if (tdesc_gp32 == NULL)
-    {
-      /* Create feature sets with the appropriate properties.  The values
-        are not important.  */
-
-      tdesc_gp32 = allocate_target_description ();
-      set_tdesc_property (tdesc_gp32, PROPERTY_GP32, "");
-
-      tdesc_gp64 = allocate_target_description ();
-      set_tdesc_property (tdesc_gp64, PROPERTY_GP64, "");
-    }
-
   /* If the size matches the set of 32-bit or 64-bit integer registers,
      assume that's what we've got.  */
   /* If the size matches the set of 32-bit or 64-bit integer registers,
      assume that's what we've got.  */
-  register_remote_g_packet_guess (gdbarch, 38 * 4, tdesc_gp32);
-  register_remote_g_packet_guess (gdbarch, 38 * 8, tdesc_gp64);
+  register_remote_g_packet_guess (gdbarch, 38 * 4, mips_tdesc_gp32);
+  register_remote_g_packet_guess (gdbarch, 38 * 8, mips_tdesc_gp64);
 
   /* If the size matches the full set of registers GDB traditionally
      knows about, including floating point, for either 32-bit or
      64-bit, assume that's what we've got.  */
 
   /* If the size matches the full set of registers GDB traditionally
      knows about, including floating point, for either 32-bit or
      64-bit, assume that's what we've got.  */
-  register_remote_g_packet_guess (gdbarch, 90 * 4, tdesc_gp32);
-  register_remote_g_packet_guess (gdbarch, 90 * 8, tdesc_gp64);
+  register_remote_g_packet_guess (gdbarch, 90 * 4, mips_tdesc_gp32);
+  register_remote_g_packet_guess (gdbarch, 90 * 8, mips_tdesc_gp64);
 
   /* Otherwise we don't have a useful guess.  */
 }
 
   /* Otherwise we don't have a useful guess.  */
 }
@@ -4861,6 +5273,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   int i, num_regs;
   enum mips_fpu_type fpu_type;
   struct tdesc_arch_data *tdesc_data = NULL;
   int i, num_regs;
   enum mips_fpu_type fpu_type;
   struct tdesc_arch_data *tdesc_data = NULL;
+  int elf_fpu_type = 0;
 
   /* Check any target description for validity.  */
   if (tdesc_has_registers (info.target_desc))
 
   /* Check any target description for validity.  */
   if (tdesc_has_registers (info.target_desc))
@@ -5068,8 +5481,32 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
                        mips64_transfers_32bit_regs_p);
 
   /* Determine the MIPS FPU type.  */
                        mips64_transfers_32bit_regs_p);
 
   /* Determine the MIPS FPU type.  */
+#ifdef HAVE_ELF
+  if (info.abfd
+      && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
+    elf_fpu_type = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
+                                            Tag_GNU_MIPS_ABI_FP);
+#endif /* HAVE_ELF */
+
   if (!mips_fpu_type_auto)
     fpu_type = mips_fpu_type;
   if (!mips_fpu_type_auto)
     fpu_type = mips_fpu_type;
+  else if (elf_fpu_type != 0)
+    {
+      switch (elf_fpu_type)
+       {
+       case 1:
+         fpu_type = MIPS_FPU_DOUBLE;
+         break;
+       case 2:
+         fpu_type = MIPS_FPU_SINGLE;
+         break;
+       case 3:
+       default:
+         /* Soft float or unknown.  */
+         fpu_type = MIPS_FPU_NONE;
+         break;
+       }
+    }
   else if (info.bfd_arch_info != NULL
           && info.bfd_arch_info->arch == bfd_arch_mips)
     switch (info.bfd_arch_info->mach)
   else if (info.bfd_arch_info != NULL
           && info.bfd_arch_info->arch == bfd_arch_mips)
     switch (info.bfd_arch_info->mach)
@@ -5221,7 +5658,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
        else
          reg_names = mips_generic_reg_names;
       }
        else
          reg_names = mips_generic_reg_names;
       }
-    /* FIXME: cagney/2003-11-15: For MIPS, hasn't PC_REGNUM been
+    /* FIXME: cagney/2003-11-15: For MIPS, hasn't gdbarch_pc_regnum been
        replaced by read_pc?  */
     set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs);
     set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
        replaced by read_pc?  */
     set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs);
     set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
@@ -5229,6 +5666,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
     set_gdbarch_num_regs (gdbarch, num_regs);
     set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
     set_gdbarch_register_name (gdbarch, mips_register_name);
     set_gdbarch_num_regs (gdbarch, num_regs);
     set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
     set_gdbarch_register_name (gdbarch, mips_register_name);
+    set_gdbarch_virtual_frame_pointer (gdbarch, mips_virtual_frame_pointer);
     tdep->mips_processor_reg_names = reg_names;
     tdep->regnum = regnum;
   }
     tdep->mips_processor_reg_names = reg_names;
     tdep->regnum = regnum;
   }
@@ -5285,7 +5723,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_ptr_bit (gdbarch, 32);
       set_gdbarch_long_long_bit (gdbarch, 64);
       set_gdbarch_long_double_bit (gdbarch, 128);
       set_gdbarch_ptr_bit (gdbarch, 32);
       set_gdbarch_long_long_bit (gdbarch, 64);
       set_gdbarch_long_double_bit (gdbarch, 128);
-      set_gdbarch_long_double_format (gdbarch, floatformats_n32n64_long);
+      set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
       break;
     case MIPS_ABI_N64:
       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
       break;
     case MIPS_ABI_N64:
       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
@@ -5297,7 +5735,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_ptr_bit (gdbarch, 64);
       set_gdbarch_long_long_bit (gdbarch, 64);
       set_gdbarch_long_double_bit (gdbarch, 128);
       set_gdbarch_ptr_bit (gdbarch, 64);
       set_gdbarch_long_long_bit (gdbarch, 64);
       set_gdbarch_long_double_bit (gdbarch, 128);
-      set_gdbarch_long_double_format (gdbarch, floatformats_n32n64_long);
+      set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
       break;
     default:
       internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
       break;
     default:
       internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
@@ -5386,14 +5824,12 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Unwind the frame.  */
   set_gdbarch_unwind_pc (gdbarch, mips_unwind_pc);
   set_gdbarch_unwind_sp (gdbarch, mips_unwind_sp);
   /* Unwind the frame.  */
   set_gdbarch_unwind_pc (gdbarch, mips_unwind_pc);
   set_gdbarch_unwind_sp (gdbarch, mips_unwind_sp);
-  set_gdbarch_unwind_dummy_id (gdbarch, mips_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, mips_dummy_id);
 
   /* Map debug register numbers onto internal register numbers.  */
   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
   set_gdbarch_ecoff_reg_to_regnum (gdbarch,
                                   mips_dwarf_dwarf2_ecoff_reg_to_regnum);
 
   /* Map debug register numbers onto internal register numbers.  */
   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
   set_gdbarch_ecoff_reg_to_regnum (gdbarch,
                                   mips_dwarf_dwarf2_ecoff_reg_to_regnum);
-  set_gdbarch_dwarf_reg_to_regnum (gdbarch,
-                                  mips_dwarf_dwarf2_ecoff_reg_to_regnum);
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch,
                                    mips_dwarf_dwarf2_ecoff_reg_to_regnum);
   set_gdbarch_register_sim_regno (gdbarch, mips_register_sim_regno);
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch,
                                    mips_dwarf_dwarf2_ecoff_reg_to_regnum);
   set_gdbarch_register_sim_regno (gdbarch, mips_register_sim_regno);
@@ -5415,6 +5851,8 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
 
 
   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
 
+  set_gdbarch_in_function_epilogue_p (gdbarch, mips_in_function_epilogue_p);
+
   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
@@ -5447,10 +5885,10 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   gdbarch_init_osabi (info, gdbarch);
 
   /* Unwind the frame.  */
   gdbarch_init_osabi (info, gdbarch);
 
   /* Unwind the frame.  */
-  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
-  frame_unwind_append_sniffer (gdbarch, mips_stub_frame_sniffer);
-  frame_unwind_append_sniffer (gdbarch, mips_insn16_frame_sniffer);
-  frame_unwind_append_sniffer (gdbarch, mips_insn32_frame_sniffer);
+  dwarf2_append_unwinders (gdbarch);
+  frame_unwind_append_unwinder (gdbarch, &mips_stub_frame_unwind);
+  frame_unwind_append_unwinder (gdbarch, &mips_insn16_frame_unwind);
+  frame_unwind_append_unwinder (gdbarch, &mips_insn32_frame_unwind);
   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
   frame_base_append_sniffer (gdbarch, mips_stub_frame_base_sniffer);
   frame_base_append_sniffer (gdbarch, mips_insn16_frame_base_sniffer);
   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
   frame_base_append_sniffer (gdbarch, mips_stub_frame_base_sniffer);
   frame_base_append_sniffer (gdbarch, mips_insn16_frame_base_sniffer);
@@ -5459,7 +5897,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   if (tdesc_data)
     {
       set_tdesc_pseudo_register_type (gdbarch, mips_pseudo_register_type);
   if (tdesc_data)
     {
       set_tdesc_pseudo_register_type (gdbarch, mips_pseudo_register_type);
-      tdesc_use_registers (gdbarch, tdesc_data);
+      tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
 
       /* Override the normal target description methods to handle our
         dual real and pseudo registers.  */
 
       /* Override the normal target description methods to handle our
         dual real and pseudo registers.  */
@@ -5542,9 +5980,9 @@ show_mips_abi (struct ui_file *file,
 }
 
 static void
 }
 
 static void
-mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+mips_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
 {
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   if (tdep != NULL)
     {
       int ef_mips_arch;
   if (tdep != NULL)
     {
       int ef_mips_arch;
@@ -5621,6 +6059,14 @@ _initialize_mips_tdep (void)
 
   mips_pdr_data = register_objfile_data ();
 
 
   mips_pdr_data = register_objfile_data ();
 
+  /* Create feature sets with the appropriate properties.  The values
+     are not important.  */
+  mips_tdesc_gp32 = allocate_target_description ();
+  set_tdesc_property (mips_tdesc_gp32, PROPERTY_GP32, "");
+
+  mips_tdesc_gp64 = allocate_target_description ();
+  set_tdesc_property (mips_tdesc_gp64, PROPERTY_GP64, "");
+
   /* Add root prefix command for all "set mips"/"show mips" commands */
   add_prefix_cmd ("mips", no_class, set_mips_command,
                  _("Various MIPS specific commands."),
   /* Add root prefix command for all "set mips"/"show mips" commands */
   add_prefix_cmd ("mips", no_class, set_mips_command,
                  _("Various MIPS specific commands."),
This page took 0.077395 seconds and 4 git commands to generate.