2007-10-10 Markus Deuling <deuling@de.ibm.com>

	* remote-mips.c (mips_wait, mips_fetch_registers)
	(mips_store_registers): Use get_regcache_arch to get at the
	current architecture by regcache.

	* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
	(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
	get at the current architecture by regcache.
	(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
	architecture by frame_info.

	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
	(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips-linux-tdep.c (mips_linux_get_longjmp_target)
	(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
	(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
	current architecture by frame_info.
	(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
	(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
	(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
	(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
	get at the current architecture by regcache.

	* mips-linux-nat.c (mips_linux_register_addr)
	(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
	(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
	(mips64_linux_regsets_fetch_registers)
	(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
	get at the current architecture by frame_info.

7 files changed, 214 insertions, 180 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 9cb2194..25f7930 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,41 @@
 2007-10-10  Markus Deuling  <deuling@de.ibm.com>
 
+	* remote-mips.c (mips_wait, mips_fetch_registers)
+	(mips_store_registers): Use get_regcache_arch to get at the
+	current architecture by regcache.
+
+	* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
+	(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
+	get at the current architecture by regcache.
+	(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
+	architecture by frame_info.
+
+	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
+	(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
+	the current architecture by regcache.
+
+	* mips-linux-tdep.c (mips_linux_get_longjmp_target)
+	(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
+	(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
+	current architecture by frame_info.
+	(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
+	(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
+	(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
+	(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
+	get at the current architecture by regcache.
+
+	* mips-linux-nat.c (mips_linux_register_addr)
+	(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
+	(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
+	(mips64_linux_regsets_fetch_registers)
+	(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
+	the current architecture by regcache.
+
+	* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
+	get at the current architecture by frame_info.
+
+2007-10-10  Markus Deuling  <deuling@de.ibm.com>
+
 	* mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the
 	current architecture by regcache.
 	(mips2_fp_compat, mips32_next_pc, mips16_scan_prologue)
diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c
index 980b41f..7d87c87 100644
--- a/gdb/mips-linux-nat.c
+++ b/gdb/mips-linux-nat.c
@@ -60,7 +60,7 @@ mips_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
 {
   CORE_ADDR regaddr;
 
-  if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch))
+  if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
     error (_("Bogon register number %d."), regno);
 
   if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
@@ -95,14 +95,14 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
 {
   CORE_ADDR regaddr;
 
-  if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch))
+  if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
     error (_("Bogon register number %d."), regno);
 
   if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
     regaddr = regno;
   else if ((regno >= mips_regnum (gdbarch)->fp0)
 	   && (regno < mips_regnum (gdbarch)->fp0 + 32))
-    regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (current_gdbarch));
+    regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (gdbarch));
   else if (regno == mips_regnum (gdbarch)->pc)
     regaddr = MIPS64_PC;
   else if (regno == mips_regnum (gdbarch)->cause)
@@ -147,7 +147,7 @@ ps_get_thread_area (const struct ps_prochandle *ph,
 void
 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 {
-  if (mips_isa_regsize (current_gdbarch) == 4)
+  if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
     mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp);
   else
     mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp);
@@ -157,7 +157,7 @@ void
 fill_gregset (const struct regcache *regcache,
 	      gdb_gregset_t *gregsetp, int regno)
 {
-  if (mips_isa_regsize (current_gdbarch) == 4)
+  if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
     mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno);
   else
     mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno);
@@ -166,7 +166,7 @@ fill_gregset (const struct regcache *regcache,
 void
 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 {
-  if (mips_isa_regsize (current_gdbarch) == 4)
+  if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
     mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp);
   else
     mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp);
@@ -176,7 +176,7 @@ void
 fill_fpregset (const struct regcache *regcache,
 	       gdb_fpregset_t *fpregsetp, int regno)
 {
-  if (mips_isa_regsize (current_gdbarch) == 4)
+  if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
     mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno);
   else
     mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno);
@@ -189,15 +189,16 @@ fill_fpregset (const struct regcache *regcache,
 static void
 mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int is_fp;
   int tid;
 
-  if (regno >= mips_regnum (current_gdbarch)->fp0
-      && regno <= mips_regnum (current_gdbarch)->fp0 + 32)
+  if (regno >= mips_regnum (gdbarch)->fp0
+      && regno <= mips_regnum (gdbarch)->fp0 + 32)
     is_fp = 1;
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     is_fp = 1;
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+  else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
     is_fp = 1;
   else
     is_fp = 0;
@@ -250,15 +251,16 @@ mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
 static void
 mips64_linux_regsets_store_registers (const struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int is_fp;
   int tid;
 
-  if (regno >= mips_regnum (current_gdbarch)->fp0
-      && regno <= mips_regnum (current_gdbarch)->fp0 + 32)
+  if (regno >= mips_regnum (gdbarch)->fp0
+      && regno <= mips_regnum (gdbarch)->fp0 + 32)
     is_fp = 1;
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     is_fp = 1;
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+  else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
     is_fp = 1;
   else
     is_fp = 0;
diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c
index 9efe3fb..d4137f4 100644
--- a/gdb/mips-linux-tdep.c
+++ b/gdb/mips-linux-tdep.c
@@ -53,19 +53,18 @@ static int
 mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 {
   CORE_ADDR jb_addr;
-  char buf[gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT];
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
 
   jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
 
   if (target_read_memory (jb_addr
 			    + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
-			  buf,
-			  gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
+			  buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
     return 0;
 
   *pc = extract_unsigned_integer (buf,
-				  gdbarch_ptr_bit (current_gdbarch)
-				    / TARGET_CHAR_BIT);
+				  gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
 
   return 1;
 }
@@ -78,7 +77,8 @@ static void
 supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr)
 {
   gdb_byte buf[MAX_REGISTER_SIZE];
-  store_signed_integer (buf, register_size (current_gdbarch, regnum),
+  store_signed_integer (buf,
+			register_size (get_regcache_arch (regcache), regnum),
                         extract_signed_integer (addr, 4));
   regcache_raw_supply (regcache, regnum, buf);
 }
@@ -92,26 +92,25 @@ mips_supply_gregset (struct regcache *regcache,
   int regi;
   const mips_elf_greg_t *regp = *gregsetp;
   char zerobuf[MAX_REGISTER_SIZE];
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++)
     supply_32bit_reg (regcache, regi - EF_REG0, regp + regi);
 
-  if (mips_linux_restart_reg_p (current_gdbarch))
+  if (mips_linux_restart_reg_p (gdbarch))
     supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0);
 
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->lo,
-		    regp + EF_LO);
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->hi,
-		    regp + EF_HI);
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->lo, regp + EF_LO);
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
 
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->pc,
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->pc,
 		    regp + EF_CP0_EPC);
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr,
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
 		    regp + EF_CP0_BADVADDR);
   supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS);
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->cause,
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->cause,
 		    regp + EF_CP0_CAUSE);
 
   /* Fill inaccessible registers with zero.  */
@@ -129,6 +128,7 @@ void
 mips_fill_gregset (const struct regcache *regcache,
 		   mips_elf_gregset_t *gregsetp, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regaddr, regi;
   mips_elf_greg_t *regp = *gregsetp;
   void *dst;
@@ -138,17 +138,12 @@ mips_fill_gregset (const struct regcache *regcache,
       memset (regp, 0, sizeof (mips_elf_gregset_t));
       for (regi = 1; regi < 32; regi++)
 	mips_fill_gregset (regcache, gregsetp, regi);
-      mips_fill_gregset (regcache, gregsetp,
-			 mips_regnum (current_gdbarch)->lo);
-      mips_fill_gregset (regcache, gregsetp,
-			 mips_regnum (current_gdbarch)->hi);
-      mips_fill_gregset (regcache, gregsetp,
-			 mips_regnum (current_gdbarch)->pc);
-      mips_fill_gregset (regcache, gregsetp,
-			 mips_regnum (current_gdbarch)->badvaddr);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
       mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
-      mips_fill_gregset (regcache, gregsetp,
-			 mips_regnum (current_gdbarch)->cause);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
       mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
       return;
    }
@@ -160,19 +155,19 @@ mips_fill_gregset (const struct regcache *regcache,
       return;
     }
 
-  if (regno == mips_regnum (current_gdbarch)->lo)
-    regaddr = EF_LO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
+  if (regno == mips_regnum (gdbarch)->lo)
+     regaddr = EF_LO;
+  else if (regno == mips_regnum (gdbarch)->hi)
     regaddr = EF_HI;
-  else if (regno == mips_regnum (current_gdbarch)->pc)
+  else if (regno == mips_regnum (gdbarch)->pc)
     regaddr = EF_CP0_EPC;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
+  else if (regno == mips_regnum (gdbarch)->badvaddr)
     regaddr = EF_CP0_BADVADDR;
   else if (regno == MIPS_PS_REGNUM)
     regaddr = EF_CP0_STATUS;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
+  else if (regno == mips_regnum (gdbarch)->cause)
     regaddr = EF_CP0_CAUSE;
-  else if (mips_linux_restart_reg_p (current_gdbarch)
+  else if (mips_linux_restart_reg_p (gdbarch)
 	   && regno == MIPS_RESTART_REGNUM)
     regaddr = EF_REG0;
   else
@@ -191,6 +186,7 @@ void
 mips_supply_fpregset (struct regcache *regcache,
 		      const mips_elf_fpregset_t *fpregsetp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regi;
   char zerobuf[MAX_REGISTER_SIZE];
 
@@ -198,16 +194,16 @@ mips_supply_fpregset (struct regcache *regcache,
 
   for (regi = 0; regi < 32; regi++)
     regcache_raw_supply (regcache,
-			 gdbarch_fp0_regnum (current_gdbarch) + regi,
+			 gdbarch_fp0_regnum (gdbarch) + regi,
 			 *fpregsetp + regi);
 
   regcache_raw_supply (regcache,
-		       mips_regnum (current_gdbarch)->fp_control_status,
+		       mips_regnum (gdbarch)->fp_control_status,
 		       *fpregsetp + 32);
 
   /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us.  */
   regcache_raw_supply (regcache,
-		       mips_regnum (current_gdbarch)->fp_implementation_revision,
+		       mips_regnum (gdbarch)->fp_implementation_revision,
 		       zerobuf);
 }
 
@@ -218,15 +214,16 @@ void
 mips_fill_fpregset (const struct regcache *regcache,
 		    mips_elf_fpregset_t *fpregsetp, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   char *from, *to;
 
-  if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
-      && (regno < gdbarch_fp0_regnum (current_gdbarch) + 32))
+  if ((regno >= gdbarch_fp0_regnum (gdbarch))
+      && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
     {
-      to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (current_gdbarch));
+      to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
       regcache_raw_collect (regcache, regno, to);
     }
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     {
       to = (char *) (*fpregsetp + 32);
       regcache_raw_collect (regcache, regno, to);
@@ -237,9 +234,9 @@ mips_fill_fpregset (const struct regcache *regcache,
 
       for (regi = 0; regi < 32; regi++)
 	mips_fill_fpregset (regcache, fpregsetp,
-			    gdbarch_fp0_regnum (current_gdbarch) + regi);
+			    gdbarch_fp0_regnum (gdbarch) + regi);
       mips_fill_fpregset (regcache, fpregsetp,
-			  mips_regnum (current_gdbarch)->fp_control_status);
+			  mips_regnum (gdbarch)->fp_control_status);
     }
 }
 
@@ -259,19 +256,19 @@ static int
 mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 {
   CORE_ADDR jb_addr;
-  void *buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
-  int element_size = gdbarch_ptr_bit (current_gdbarch) == 32 ? 4 : 8;
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  void *buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
+  int element_size = gdbarch_ptr_bit (gdbarch) == 32 ? 4 : 8;
 
   jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
 
   if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
 			  buf,
-			  gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
+			  gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
     return 0;
 
   *pc = extract_unsigned_integer (buf,
-				  gdbarch_ptr_bit (current_gdbarch)
-				    / TARGET_CHAR_BIT);
+				  gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
 
   return 1;
 }
@@ -286,8 +283,9 @@ void
 supply_64bit_reg (struct regcache *regcache, int regnum,
 		  const gdb_byte *buf)
 {
-  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
-      && register_size (current_gdbarch, regnum) == 4)
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
+      && register_size (gdbarch, regnum) == 4)
     regcache_raw_supply (regcache, regnum, buf + 4);
   else
     regcache_raw_supply (regcache, regnum, buf);
@@ -302,6 +300,7 @@ mips64_supply_gregset (struct regcache *regcache,
   int regi;
   const mips64_elf_greg_t *regp = *gregsetp;
   gdb_byte zerobuf[MAX_REGISTER_SIZE];
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
@@ -309,22 +308,22 @@ mips64_supply_gregset (struct regcache *regcache,
     supply_64bit_reg (regcache, regi - MIPS64_EF_REG0,
 		      (const gdb_byte *)(regp + regi));
 
-  if (mips_linux_restart_reg_p (current_gdbarch))
+  if (mips_linux_restart_reg_p (gdbarch))
     supply_64bit_reg (regcache, MIPS_RESTART_REGNUM,
 		      (const gdb_byte *)(regp + MIPS64_EF_REG0));
 
-  supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->lo,
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo,
 		    (const gdb_byte *) (regp + MIPS64_EF_LO));
-  supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->hi,
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->hi,
 		    (const gdb_byte *) (regp + MIPS64_EF_HI));
 
-  supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->pc,
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->pc,
 		    (const gdb_byte *) (regp + MIPS64_EF_CP0_EPC));
-  supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr,
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
 		    (const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR));
   supply_64bit_reg (regcache, MIPS_PS_REGNUM,
 		    (const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS));
-  supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->cause,
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->cause,
 		    (const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE));
 
   /* Fill inaccessible registers with zero.  */
@@ -342,6 +341,7 @@ void
 mips64_fill_gregset (const struct regcache *regcache,
 		     mips64_elf_gregset_t *gregsetp, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regaddr, regi;
   mips64_elf_greg_t *regp = *gregsetp;
   void *src, *dst;
@@ -351,36 +351,31 @@ mips64_fill_gregset (const struct regcache *regcache,
       memset (regp, 0, sizeof (mips64_elf_gregset_t));
       for (regi = 1; regi < 32; regi++)
         mips64_fill_gregset (regcache, gregsetp, regi);
-      mips64_fill_gregset (regcache, gregsetp,
-			   mips_regnum (current_gdbarch)->lo);
-      mips64_fill_gregset (regcache, gregsetp,
-			   mips_regnum (current_gdbarch)->hi);
-      mips64_fill_gregset (regcache, gregsetp,
-			   mips_regnum (current_gdbarch)->pc);
-      mips64_fill_gregset (regcache, gregsetp,
-			   mips_regnum (current_gdbarch)->badvaddr);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
       mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
-      mips64_fill_gregset (regcache, gregsetp,
-			   mips_regnum (current_gdbarch)->cause);
+      mips64_fill_gregset (regcache, gregsetp,  mips_regnum (gdbarch)->cause);
       mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
       return;
    }
 
   if (regno > 0 && regno < 32)
     regaddr = regno + MIPS64_EF_REG0;
-  else if (regno == mips_regnum (current_gdbarch)->lo)
+  else if (regno == mips_regnum (gdbarch)->lo)
     regaddr = MIPS64_EF_LO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
+  else if (regno == mips_regnum (gdbarch)->hi)
     regaddr = MIPS64_EF_HI;
-  else if (regno == mips_regnum (current_gdbarch)->pc)
+  else if (regno == mips_regnum (gdbarch)->pc)
     regaddr = MIPS64_EF_CP0_EPC;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
+  else if (regno == mips_regnum (gdbarch)->badvaddr)
     regaddr = MIPS64_EF_CP0_BADVADDR;
   else if (regno == MIPS_PS_REGNUM)
     regaddr = MIPS64_EF_CP0_STATUS;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
+  else if (regno == mips_regnum (gdbarch)->cause)
     regaddr = MIPS64_EF_CP0_CAUSE;
-  else if (mips_linux_restart_reg_p (current_gdbarch)
+  else if (mips_linux_restart_reg_p (gdbarch)
 	   && regno == MIPS_RESTART_REGNUM)
     regaddr = MIPS64_EF_REG0;
   else
@@ -392,8 +387,7 @@ mips64_fill_gregset (const struct regcache *regcache,
       LONGEST val;
 
       regcache_raw_collect (regcache, regno, buf);
-      val = extract_signed_integer (buf,
-				    register_size (current_gdbarch, regno));
+      val = extract_signed_integer (buf, register_size (gdbarch, regno));
       dst = regp + regaddr;
       store_signed_integer (dst, 8, val);
     }
@@ -405,36 +399,35 @@ void
 mips64_supply_fpregset (struct regcache *regcache,
 			const mips64_elf_fpregset_t *fpregsetp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regi;
 
   /* See mips_linux_o32_sigframe_init for a description of the
      peculiar FP register layout.  */
-  if (register_size (current_gdbarch,
-		     gdbarch_fp0_regnum (current_gdbarch)) == 4)
+  if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4)
     for (regi = 0; regi < 32; regi++)
       {
 	const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1));
-	if ((gdbarch_byte_order (current_gdbarch)
-	    == BFD_ENDIAN_BIG) != (regi & 1))
+	if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
 	  reg_ptr += 4;
 	regcache_raw_supply (regcache,
-			     gdbarch_fp0_regnum (current_gdbarch) + regi,
+			     gdbarch_fp0_regnum (gdbarch) + regi,
 			     reg_ptr);
       }
   else
     for (regi = 0; regi < 32; regi++)
       regcache_raw_supply (regcache,
-			   gdbarch_fp0_regnum (current_gdbarch) + regi,
+			   gdbarch_fp0_regnum (gdbarch) + regi,
 			   (const char *)(*fpregsetp + regi));
 
-  supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->fp_control_status,
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
 		    (const gdb_byte *)(*fpregsetp + 32));
 
   /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
      include it - but the result of PTRACE_GETFPREGS does.  The best we
      can do is to assume that its value is present.  */
   supply_32bit_reg (regcache,
-		    mips_regnum (current_gdbarch)->fp_implementation_revision,
+		    mips_regnum (gdbarch)->fp_implementation_revision,
 		    (const gdb_byte *)(*fpregsetp + 32) + 4);
 }
 
@@ -445,49 +438,46 @@ void
 mips64_fill_fpregset (const struct regcache *regcache,
 		      mips64_elf_fpregset_t *fpregsetp, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   gdb_byte *to;
 
-  if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
-      && (regno < gdbarch_fp0_regnum (current_gdbarch) + 32))
+  if ((regno >= gdbarch_fp0_regnum (gdbarch))
+      && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
     {
       /* See mips_linux_o32_sigframe_init for a description of the
 	 peculiar FP register layout.  */
-      if (register_size (current_gdbarch, regno) == 4)
+      if (register_size (gdbarch, regno) == 4)
 	{
-	  int regi = regno - gdbarch_fp0_regnum (current_gdbarch);
+	  int regi = regno - gdbarch_fp0_regnum (gdbarch);
 
 	  to = (gdb_byte *) (*fpregsetp + (regi & ~1));
-	  if ((gdbarch_byte_order (current_gdbarch)
-	      == BFD_ENDIAN_BIG) != (regi & 1))
+	  if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
 	    to += 4;
 	  regcache_raw_collect (regcache, regno, to);
 	}
       else
 	{
-	  to = (gdb_byte *) (*fpregsetp + regno
-			     - gdbarch_fp0_regnum (current_gdbarch));
+	  to = (gdb_byte *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
 	  regcache_raw_collect (regcache, regno, to);
 	}
     }
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     {
       gdb_byte buf[MAX_REGISTER_SIZE];
       LONGEST val;
 
       regcache_raw_collect (regcache, regno, buf);
-      val = extract_signed_integer (buf,
-				    register_size (current_gdbarch, regno));
+      val = extract_signed_integer (buf, register_size (gdbarch, regno));
       to = (gdb_byte *) (*fpregsetp + 32);
       store_signed_integer (to, 4, val);
     }
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+  else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
     {
       gdb_byte buf[MAX_REGISTER_SIZE];
       LONGEST val;
 
       regcache_raw_collect (regcache, regno, buf);
-      val = extract_signed_integer (buf,
-				    register_size (current_gdbarch, regno));
+      val = extract_signed_integer (buf, register_size (gdbarch, regno));
       to = (gdb_byte *) (*fpregsetp + 32) + 4;
       store_signed_integer (to, 4, val);
     }
@@ -497,12 +487,12 @@ mips64_fill_fpregset (const struct regcache *regcache,
 
       for (regi = 0; regi < 32; regi++)
 	mips64_fill_fpregset (regcache, fpregsetp,
-			      gdbarch_fp0_regnum (current_gdbarch) + regi);
+			      gdbarch_fp0_regnum (gdbarch) + regi);
       mips64_fill_fpregset (regcache, fpregsetp,
-			    mips_regnum (current_gdbarch)->fp_control_status);
+			    mips_regnum (gdbarch)->fp_control_status);
       mips64_fill_fpregset (regcache, fpregsetp,
-			    (mips_regnum (current_gdbarch)
-			     ->fp_implementation_revision));
+			    (mips_regnum (gdbarch)
+			      ->fp_implementation_revision));
     }
 }
 
@@ -867,9 +857,10 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
 			      struct trad_frame_cache *this_cache,
 			      CORE_ADDR func)
 {
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   int ireg, reg_position;
   CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
-  const struct mips_regnum *regs = mips_regnum (current_gdbarch);
+  const struct mips_regnum *regs = mips_regnum (gdbarch);
   CORE_ADDR regs_base;
 
   if (self == &mips_linux_o32_sigframe)
@@ -882,21 +873,21 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
      per-frame basis, but right now we don't; the kernel saves eight
      bytes but we only want four.  Use regs_base to access any
      64-bit fields.  */
-  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
     regs_base = sigcontext_base + 4;
   else
     regs_base = sigcontext_base;
 
-  if (mips_linux_restart_reg_p (current_gdbarch))
+  if (mips_linux_restart_reg_p (gdbarch))
     trad_frame_set_reg_addr (this_cache,
 			     (MIPS_RESTART_REGNUM
-			      + gdbarch_num_regs (current_gdbarch)),
+			      + gdbarch_num_regs (gdbarch)),
 			     regs_base + SIGCONTEXT_REGS);
 
   for (ireg = 1; ireg < 32; ireg++)
     trad_frame_set_reg_addr (this_cache,
 			     ireg + MIPS_ZERO_REGNUM
-			       + gdbarch_num_regs (current_gdbarch),
+			       + gdbarch_num_regs (gdbarch),
 			     regs_base + SIGCONTEXT_REGS
 			     + ireg * SIGCONTEXT_REG_SIZE);
 
@@ -909,38 +900,38 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
      layout, since we can't tell, and it's much more common.  Which bits are
      the "high" bits depends on endianness.  */
   for (ireg = 0; ireg < 32; ireg++)
-    if ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
+    if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
       trad_frame_set_reg_addr (this_cache,
 			       ireg + regs->fp0 +
-				 gdbarch_num_regs (current_gdbarch),
+				 gdbarch_num_regs (gdbarch),
 			       sigcontext_base + SIGCONTEXT_FPREGS + 4
 			       + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
     else
       trad_frame_set_reg_addr (this_cache,
 			       ireg + regs->fp0
-				 + gdbarch_num_regs (current_gdbarch),
+				 + gdbarch_num_regs (gdbarch),
 			       sigcontext_base + SIGCONTEXT_FPREGS
 			       + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
 
   trad_frame_set_reg_addr (this_cache,
-			   regs->pc + gdbarch_num_regs (current_gdbarch),
+			   regs->pc + gdbarch_num_regs (gdbarch),
 			   regs_base + SIGCONTEXT_PC);
 
   trad_frame_set_reg_addr (this_cache,
 			   regs->fp_control_status
-			   + gdbarch_num_regs (current_gdbarch),
+			   + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + SIGCONTEXT_FPCSR);
   trad_frame_set_reg_addr (this_cache,
-			   regs->hi + gdbarch_num_regs (current_gdbarch),
+			   regs->hi + gdbarch_num_regs (gdbarch),
 			   regs_base + SIGCONTEXT_HI);
   trad_frame_set_reg_addr (this_cache,
-			   regs->lo + gdbarch_num_regs (current_gdbarch),
+			   regs->lo + gdbarch_num_regs (gdbarch),
 			   regs_base + SIGCONTEXT_LO);
   trad_frame_set_reg_addr (this_cache,
-			   regs->cause + gdbarch_num_regs (current_gdbarch),
+			   regs->cause + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + SIGCONTEXT_CAUSE);
   trad_frame_set_reg_addr (this_cache,
-			   regs->badvaddr + gdbarch_num_regs (current_gdbarch),
+			   regs->badvaddr + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + SIGCONTEXT_BADVADDR);
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
@@ -1028,54 +1019,55 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
 				 struct trad_frame_cache *this_cache,
 				 CORE_ADDR func)
 {
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   int ireg, reg_position;
   CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
-  const struct mips_regnum *regs = mips_regnum (current_gdbarch);
+  const struct mips_regnum *regs = mips_regnum (gdbarch);
 
   if (self == &mips_linux_n32_rt_sigframe)
     sigcontext_base += N32_SIGFRAME_SIGCONTEXT_OFFSET;
   else
     sigcontext_base += N64_SIGFRAME_SIGCONTEXT_OFFSET;
 
-  if (mips_linux_restart_reg_p (current_gdbarch))
+  if (mips_linux_restart_reg_p (gdbarch))
     trad_frame_set_reg_addr (this_cache,
 			     (MIPS_RESTART_REGNUM
-			      + gdbarch_num_regs (current_gdbarch)),
+			      + gdbarch_num_regs (gdbarch)),
 			     sigcontext_base + N64_SIGCONTEXT_REGS);
 
   for (ireg = 1; ireg < 32; ireg++)
     trad_frame_set_reg_addr (this_cache,
 			     ireg + MIPS_ZERO_REGNUM
-			     + gdbarch_num_regs (current_gdbarch),
+			     + gdbarch_num_regs (gdbarch),
 			     sigcontext_base + N64_SIGCONTEXT_REGS
 			     + ireg * N64_SIGCONTEXT_REG_SIZE);
 
   for (ireg = 0; ireg < 32; ireg++)
     trad_frame_set_reg_addr (this_cache,
 			     ireg + regs->fp0
-			     + gdbarch_num_regs (current_gdbarch),
+			     + gdbarch_num_regs (gdbarch),
 			     sigcontext_base + N64_SIGCONTEXT_FPREGS
 			     + ireg * N64_SIGCONTEXT_REG_SIZE);
 
   trad_frame_set_reg_addr (this_cache,
-			   regs->pc + gdbarch_num_regs (current_gdbarch),
+			   regs->pc + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_PC);
 
   trad_frame_set_reg_addr (this_cache,
 			   regs->fp_control_status
-			   + gdbarch_num_regs (current_gdbarch),
+			   + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_FPCSR);
   trad_frame_set_reg_addr (this_cache,
-			   regs->hi + gdbarch_num_regs (current_gdbarch),
+			   regs->hi + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_HI);
   trad_frame_set_reg_addr (this_cache,
-			   regs->lo + gdbarch_num_regs (current_gdbarch),
+			   regs->lo + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_LO);
   trad_frame_set_reg_addr (this_cache,
-			   regs->cause + gdbarch_num_regs (current_gdbarch),
+			   regs->cause + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_CAUSE);
   trad_frame_set_reg_addr (this_cache,
-			   regs->badvaddr + gdbarch_num_regs (current_gdbarch),
+			   regs->badvaddr + gdbarch_num_regs (gdbarch),
 			   sigcontext_base + N64_SIGCONTEXT_BADVADDR);
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
@@ -1087,11 +1079,11 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
 static void
 mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 {
-  regcache_cooked_write_unsigned (regcache,
-				  gdbarch_pc_regnum (current_gdbarch), pc);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
 
   /* Clear the syscall restart flag.  */
-  if (mips_linux_restart_reg_p (current_gdbarch))
+  if (mips_linux_restart_reg_p (gdbarch))
     regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
 }
 
diff --git a/gdb/mips64obsd-tdep.c b/gdb/mips64obsd-tdep.c
index ccc4d5b..cc59634 100644
--- a/gdb/mips64obsd-tdep.c
+++ b/gdb/mips64obsd-tdep.c
@@ -91,30 +91,30 @@ mips64obsd_sigframe_init (const struct tramp_frame *self,
      fixed offset in the signal frame.  */
   sp = frame_unwind_register_signed (next_frame,
 				     MIPS_SP_REGNUM
-				     + gdbarch_num_regs (current_gdbarch));
+				     + gdbarch_num_regs (gdbarch));
   sigcontext_addr = sp + 32;
 
   /* PC.  */
   regnum = mips_regnum (gdbarch)->pc;
   trad_frame_set_reg_addr (cache,
-			   regnum + gdbarch_num_regs (current_gdbarch),
+			   regnum + gdbarch_num_regs (gdbarch),
 			    sigcontext_addr + 16);
 
   /* GPRs.  */
   for (regnum = MIPS_AT_REGNUM, addr = sigcontext_addr + 32;
        regnum <= MIPS_RA_REGNUM; regnum++, addr += 8)
     trad_frame_set_reg_addr (cache,
-			     regnum + gdbarch_num_regs (current_gdbarch),
+			     regnum + gdbarch_num_regs (gdbarch),
 			     addr);
 
   /* HI and LO.  */
   regnum = mips_regnum (gdbarch)->lo;
   trad_frame_set_reg_addr (cache,
-			   regnum + gdbarch_num_regs (current_gdbarch),
+			   regnum + gdbarch_num_regs (gdbarch),
 			   sigcontext_addr + 280);
   regnum = mips_regnum (gdbarch)->hi;
   trad_frame_set_reg_addr (cache,
-			   regnum + gdbarch_num_regs (current_gdbarch),
+			   regnum + gdbarch_num_regs (gdbarch),
 			   sigcontext_addr + 288);
 
   /* TODO: Handle the floating-point registers.  */
diff --git a/gdb/mipsnbsd-nat.c b/gdb/mipsnbsd-nat.c
index 8c3d726..e63c906 100644
--- a/gdb/mipsnbsd-nat.c
+++ b/gdb/mipsnbsd-nat.c
@@ -54,7 +54,7 @@ mipsnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
 	return;
     }
 
-  if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
+  if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
     {
       struct fpreg fpregs;
 
@@ -87,7 +87,7 @@ mipsnbsd_store_inferior_registers (struct regcache *regcache, int regno)
 	return;
     }
 
-  if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
+  if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
     {
       struct fpreg fpregs; 
 
diff --git a/gdb/mipsnbsd-tdep.c b/gdb/mipsnbsd-tdep.c
index 05518cf..f4805a6 100644
--- a/gdb/mipsnbsd-tdep.c
+++ b/gdb/mipsnbsd-tdep.c
@@ -142,17 +142,18 @@ mipsnbsd_regset_from_core_section (struct gdbarch *gdbarch,
 void
 mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int i;
 
-  for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
+  for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
     {
       if (regno == i || regno == -1)
 	{
-	  if (gdbarch_cannot_fetch_register (current_gdbarch, i))
+	  if (gdbarch_cannot_fetch_register (gdbarch, i))
 	    regcache_raw_supply (regcache, i, NULL);
 	  else
             regcache_raw_supply (regcache, i,
-				 regs + (i * mips_isa_regsize (current_gdbarch)));
+				 regs + (i * mips_isa_regsize (gdbarch)));
         }
     }
 }
@@ -160,33 +161,35 @@ mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
 void
 mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int i;
 
-  for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
+  for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
     if ((regno == i || regno == -1)
-	&& ! gdbarch_cannot_store_register (current_gdbarch, i))
+	&& ! gdbarch_cannot_store_register (gdbarch, i))
       regcache_raw_collect (regcache, i,
-			    regs + (i * mips_isa_regsize (current_gdbarch)));
+			    regs + (i * mips_isa_regsize (gdbarch)));
 }
 
 void
 mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int i;
 
-  for (i = gdbarch_fp0_regnum (current_gdbarch);
-       i <= mips_regnum (current_gdbarch)->fp_implementation_revision;
+  for (i = gdbarch_fp0_regnum (gdbarch);
+       i <= mips_regnum (gdbarch)->fp_implementation_revision;
        i++)
     {
       if (regno == i || regno == -1)
 	{
-	  if (gdbarch_cannot_fetch_register (current_gdbarch, i))
+	  if (gdbarch_cannot_fetch_register (gdbarch, i))
 	    regcache_raw_supply (regcache, i, NULL);
 	  else
             regcache_raw_supply (regcache, i,
 				 fpregs 
-				 + ((i - gdbarch_fp0_regnum (current_gdbarch))
-				    * mips_isa_regsize (current_gdbarch)));
+				 + ((i - gdbarch_fp0_regnum (gdbarch))
+				    * mips_isa_regsize (gdbarch)));
 	}
     }
 }
@@ -194,17 +197,17 @@ mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
 void
 mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int i;
 
-  for (i = gdbarch_fp0_regnum (current_gdbarch);
-       i <= mips_regnum (current_gdbarch)->fp_control_status;
+  for (i = gdbarch_fp0_regnum (gdbarch);
+       i <= mips_regnum (gdbarch)->fp_control_status;
        i++)
     if ((regno == i || regno == -1) 
-	&& ! gdbarch_cannot_store_register (current_gdbarch, i))
+	&& ! gdbarch_cannot_store_register (gdbarch, i))
       regcache_raw_collect (regcache, i,
-			    fpregs + ((i - gdbarch_fp0_regnum
-					     (current_gdbarch))
-			      * mips_isa_regsize (current_gdbarch)));
+			    fpregs + ((i - gdbarch_fp0_regnum (gdbarch))
+			      * mips_isa_regsize (gdbarch)));
 }
 
 /* Under NetBSD/mips, signal handler invocations can be identified by the
@@ -244,7 +247,7 @@ static LONGEST
 mipsnbsd_sigtramp_offset (struct frame_info *next_frame)
 {
   CORE_ADDR pc = frame_pc_unwind (next_frame);
-  const char *retcode = gdbarch_byte_order (current_gdbarch)
+  const char *retcode = gdbarch_byte_order (get_frame_arch (next_frame))
 			== BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb :
 			sigtramp_retcode_mipsel;
   unsigned char ret[RETCODE_SIZE], w[4];
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index 0aee843..f153fb4 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -1754,30 +1754,29 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
   if (nfields >= 3)
     {
       struct regcache *regcache = get_current_regcache ();
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
       char buf[MAX_REGISTER_SIZE];
 
       store_unsigned_integer (buf,
 			      register_size
-			        (current_gdbarch, gdbarch_pc_regnum
-						    (current_gdbarch)), rpc);
-      regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), buf);
+			        (gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
+      regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
 
       store_unsigned_integer
-	(buf, register_size (current_gdbarch,
-	 gdbarch_pc_regnum (current_gdbarch)), rfp);
+	(buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
       regcache_raw_supply (regcache, 30, buf);	/* This register they are avoiding and so it is unnamed */
 
-      store_unsigned_integer (buf, register_size (current_gdbarch,
-			      gdbarch_sp_regnum (current_gdbarch)), rsp);
-      regcache_raw_supply (regcache, gdbarch_sp_regnum (current_gdbarch), buf);
+      store_unsigned_integer (buf, register_size (gdbarch,
+			      gdbarch_sp_regnum (gdbarch)), rsp);
+      regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
 
       store_unsigned_integer (buf,
-			      register_size (current_gdbarch,
+			      register_size (gdbarch,
 					     gdbarch_deprecated_fp_regnum
-					       (current_gdbarch)),
+					       (gdbarch)),
 			      0);
       regcache_raw_supply (regcache,
-			   gdbarch_deprecated_fp_regnum (current_gdbarch), buf);
+			   gdbarch_deprecated_fp_regnum (gdbarch), buf);
 
       if (nfields == 9)
 	{
@@ -1904,17 +1903,18 @@ mips_map_regno (int regno)
 static void
 mips_fetch_registers (struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   unsigned LONGEST val;
   int err;
 
   if (regno == -1)
     {
-      for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 	mips_fetch_registers (regcache, regno);
       return;
     }
 
-  if (regno == gdbarch_deprecated_fp_regnum (current_gdbarch)
+  if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
       || regno == MIPS_ZERO_REGNUM)
     /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
        supposed to read zero (see also mips-nat.c).  */
@@ -1948,7 +1948,7 @@ mips_fetch_registers (struct regcache *regcache, int regno)
 
     /* We got the number the register holds, but gdb expects to see a
        value in the target byte ordering.  */
-    store_unsigned_integer (buf, register_size (current_gdbarch, regno), val);
+    store_unsigned_integer (buf, register_size (gdbarch, regno), val);
     regcache_raw_supply (regcache, regno, buf);
   }
 }
@@ -1966,12 +1966,13 @@ mips_prepare_to_store (struct regcache *regcache)
 static void
 mips_store_registers (struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   ULONGEST val;
   int err;
 
   if (regno == -1)
     {
-      for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 	mips_store_registers (regcache, regno);
       return;
     }