* alpha-tdep.c (alpha_supply_int_regs, alpha_fill_int_regs,

	alpha_supply_fp_regs, alpha_fill_fp_regs): Add REGCACHE parameter,
	use it instead of current_regcache.
	* alpha-tdep.h (struct regcache): Add forward declaration.
	(alpha_supply_int_regs, alpha_fill_int_regs, alpha_supply_fp_regs,
	alpha_fill_fp_regs): Update prototypes.

	* alpha-nat.c: (supply_gregset, fill_gregset, supply_fpregset,
	fill_fpregset): Pass current_regcache to alpha_supply/fill_ routines.
	* alpha-linux-nat.c: Include "regcache.h".
	(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset): Pass
	current_regcache to alpha_supply/fill_ routines.

	* alphabsd-tdep.c: Include "regcache.h".
	(alphabsd_supply_reg, alphabsd_supply_fpreg): Add REGCACHE paramter,
	pass it to alpha_supply_ routines.  Make REGS const.
	(alphabsd_fill_reg, alphabsd_fill_fpreg): Add REGCACHE parameter,
	pass it to alpha_fill_ routines.
	* alphabsd-tdep.h (struct regcache): Add forward declaration.
	(alphabsd_supply_reg, alphabsd_fill_reg, alphabsd_supply_fpreg,
	alphabsd_fill_fpreg): Update prototypes.

	* alphanbsd-nat.c (supply_gregset, fill_gregset, supply_fpregset,
	fill_fpregset, alphabsd_fetch_inferior_registers,
	alphabsd_store_inferior_registers): Pass current_regcache to
	alphabsd_supply/fill_ routines.

	* Makefile.in (alpha-linux-nat.o, alphabsd-tdep.o): Update
	dependencies.

1 files changed, 19 insertions, 16 deletions

diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 92a654f..00eaeb9 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -1296,71 +1296,74 @@ alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
    targets don't supply this value in their core files.  */
 
 void
-alpha_supply_int_regs (int regno, const void *r0_r30,
-		       const void *pc, const void *unique)
+alpha_supply_int_regs (struct regcache *regcache, int regno,
+		       const void *r0_r30, const void *pc, const void *unique)
 {
   const gdb_byte *regs = r0_r30;
   int i;
 
   for (i = 0; i < 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_supply (current_regcache, i, regs + i * 8);
+      regcache_raw_supply (regcache, i, regs + i * 8);
 
   if (regno == ALPHA_ZERO_REGNUM || regno == -1)
-    regcache_raw_supply (current_regcache, ALPHA_ZERO_REGNUM, NULL);
+    regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
 
   if (regno == ALPHA_PC_REGNUM || regno == -1)
-    regcache_raw_supply (current_regcache, ALPHA_PC_REGNUM, pc);
+    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
 
   if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
-    regcache_raw_supply (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
+    regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
 }
 
 void
-alpha_fill_int_regs (int regno, void *r0_r30, void *pc, void *unique)
+alpha_fill_int_regs (const struct regcache *regcache,
+		     int regno, void *r0_r30, void *pc, void *unique)
 {
   gdb_byte *regs = r0_r30;
   int i;
 
   for (i = 0; i < 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_collect (current_regcache, i, regs + i * 8);
+      regcache_raw_collect (regcache, i, regs + i * 8);
 
   if (regno == ALPHA_PC_REGNUM || regno == -1)
-    regcache_raw_collect (current_regcache, ALPHA_PC_REGNUM, pc);
+    regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
 
   if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
-    regcache_raw_collect (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
+    regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
 }
 
 void
-alpha_supply_fp_regs (int regno, const void *f0_f30, const void *fpcr)
+alpha_supply_fp_regs (struct regcache *regcache, int regno,
+		      const void *f0_f30, const void *fpcr)
 {
   const gdb_byte *regs = f0_f30;
   int i;
 
   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_supply (current_regcache, i,
+      regcache_raw_supply (regcache, i,
 			   regs + (i - ALPHA_FP0_REGNUM) * 8);
 
   if (regno == ALPHA_FPCR_REGNUM || regno == -1)
-    regcache_raw_supply (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
+    regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
 }
 
 void
-alpha_fill_fp_regs (int regno, void *f0_f30, void *fpcr)
+alpha_fill_fp_regs (const struct regcache *regcache,
+		    int regno, void *f0_f30, void *fpcr)
 {
   gdb_byte *regs = f0_f30;
   int i;
 
   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_collect (current_regcache, i,
+      regcache_raw_collect (regcache, i,
 			    regs + (i - ALPHA_FP0_REGNUM) * 8);
 
   if (regno == ALPHA_FPCR_REGNUM || regno == -1)
-    regcache_raw_collect (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
+    regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
 }