From: Simon Marchi <simon.marchi@ericsson.com>
Date: Wed, 30 May 2018 18:54:45 +0000 (-0400)
Subject: Remove regcache_raw_supply
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=73e1c03f93f0294b464dc2b67de1f9aaae84838d;p=binutils-gdb.git

Remove regcache_raw_supply

Remove regcache_raw_supply, update callers to use
detached_regcache::raw_supply.

gdb/ChangeLog:

	* regcache.h (regcache_raw_supply): Remove, update callers to
	use detached_regcache::raw_supply.
	* regcache.c (regcache_raw_supply): Remove.
---

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b0fb0c6f64f..c7dd3d62ee5 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
+
+	* regcache.h (regcache_raw_supply): Remove, update callers to
+	use detached_regcache::raw_supply.
+	* regcache.c (regcache_raw_supply): Remove.
+
 2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
 
 	* regcache.h (regcache_cooked_write_part): Remove, update
diff --git a/gdb/aarch32-linux-nat.c b/gdb/aarch32-linux-nat.c
index d1c13141c5c..3297d6c343a 100644
--- a/gdb/aarch32-linux-nat.c
+++ b/gdb/aarch32-linux-nat.c
@@ -34,20 +34,20 @@ aarch32_gp_regcache_supply (struct regcache *regcache, uint32_t *regs,
   int regno;
 
   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
-    regcache_raw_supply (regcache, regno, &regs[regno]);
+    regcache->raw_supply (regno, &regs[regno]);
 
   if (arm_apcs_32)
     {
       /* Clear reserved bits bit 20 to bit 23.  */
       regs[ARM_CPSR_GREGNUM] &= 0xff0fffff;
-      regcache_raw_supply (regcache, ARM_PS_REGNUM, &regs[ARM_CPSR_GREGNUM]);
+      regcache->raw_supply (ARM_PS_REGNUM, &regs[ARM_CPSR_GREGNUM]);
     }
   else
-    regcache_raw_supply (regcache, ARM_PS_REGNUM, &regs[ARM_PC_REGNUM]);
+    regcache->raw_supply (ARM_PS_REGNUM, &regs[ARM_PC_REGNUM]);
 
   regs[ARM_PC_REGNUM] = gdbarch_addr_bits_remove
 			  (regcache->arch (), regs[ARM_PC_REGNUM]);
-  regcache_raw_supply (regcache, ARM_PC_REGNUM, &regs[ARM_PC_REGNUM]);
+  regcache->raw_supply (ARM_PC_REGNUM, &regs[ARM_PC_REGNUM]);
 }
 
 /* Collect GP registers from REGCACHE to buffer REGS.  ARM_APCS_32 is
@@ -88,11 +88,9 @@ aarch32_vfp_regcache_supply (struct regcache *regcache, gdb_byte *regs,
   int regno;
 
   for (regno = 0; regno < vfp_register_count; regno++)
-    regcache_raw_supply (regcache, regno + ARM_D0_REGNUM,
-			 regs + regno * 8);
+    regcache->raw_supply (regno + ARM_D0_REGNUM, regs + regno * 8);
 
-  regcache_raw_supply (regcache, ARM_FPSCR_REGNUM,
-		       regs + 32 * 8);
+  regcache->raw_supply (ARM_FPSCR_REGNUM, regs + 32 * 8);
 }
 
 /* Collect VFP registers from REGCACHE to buffer REGS.
diff --git a/gdb/aarch64-linux-nat.c b/gdb/aarch64-linux-nat.c
index c1fb7ac785a..a46baceab7f 100644
--- a/gdb/aarch64-linux-nat.c
+++ b/gdb/aarch64-linux-nat.c
@@ -227,7 +227,7 @@ fetch_gregs_from_thread (struct regcache *regcache)
       int regno;
 
       for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
-	regcache_raw_supply (regcache, regno, &regs[regno - AARCH64_X0_REGNUM]);
+	regcache->raw_supply (regno, &regs[regno - AARCH64_X0_REGNUM]);
     }
 }
 
@@ -314,11 +314,10 @@ fetch_fpregs_from_thread (struct regcache *regcache)
 	perror_with_name (_("Unable to fetch vFP/SIMD registers."));
 
       for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
-	regcache_raw_supply (regcache, regno,
-			     &regs.vregs[regno - AARCH64_V0_REGNUM]);
+	regcache->raw_supply (regno, &regs.vregs[regno - AARCH64_V0_REGNUM]);
 
-      regcache_raw_supply (regcache, AARCH64_FPSR_REGNUM, &regs.fpsr);
-      regcache_raw_supply (regcache, AARCH64_FPCR_REGNUM, &regs.fpcr);
+      regcache->raw_supply (AARCH64_FPSR_REGNUM, &regs.fpsr);
+      regcache->raw_supply (AARCH64_FPCR_REGNUM, &regs.fpcr);
     }
 }
 
diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index 749065c5e56..838b1a3f561 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -1116,8 +1116,8 @@ supply_gprs64 (struct regcache *regcache, uint64_t *vals)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
-    regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
-			 (char *) (vals + regno));
+    regcache->raw_supply (tdep->ppc_gp0_regnum + regno,
+			  (char *) (vals + regno));
 }
 
 /* Record that 32-bit register REGNO contains VAL.  */
@@ -1125,7 +1125,7 @@ supply_gprs64 (struct regcache *regcache, uint64_t *vals)
 static void
 supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
 {
-  regcache_raw_supply (regcache, regno, (char *) &val);
+  regcache->raw_supply (regno, (char *) &val);
 }
 
 /* Record that the floating-point registers contain VALS.  */
@@ -1144,8 +1144,8 @@ supply_fprs (struct regcache *regcache, double *vals)
   for (regno = tdep->ppc_fp0_regnum;
        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
        regno++)
-    regcache_raw_supply (regcache, regno,
-			 (char *) (vals + regno - tdep->ppc_fp0_regnum));
+    regcache->raw_supply (regno,
+			  (char *) (vals + regno - tdep->ppc_fp0_regnum));
 }
 
 /* Predicate to test whether given register number is a "special" register.  */
@@ -1177,16 +1177,14 @@ supply_sprs64 (struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
-		       (char *) &iar);
-  regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
-  regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
-  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+  regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+  regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+  regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+  regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
   if (tdep->ppc_fpscr_regnum >= 0)
-    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
-			 (char *) &fpscr);
+    regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
 }
 
 /* Record that the special registers contain the specified 32-bit
@@ -1201,16 +1199,14 @@ supply_sprs32 (struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
-		       (char *) &iar);
-  regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
-  regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
-  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+  regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+  regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+  regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+  regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
   if (tdep->ppc_fpscr_regnum >= 0)
-    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
-			 (char *) &fpscr);
+    regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
 }
 
 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
@@ -1349,8 +1345,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
 			 sprs32.pt_fpscr);
 
 	  if (tdep->ppc_mq_regnum >= 0)
-	    regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
-				 (char *) &sprs32.pt_mq);
+	    regcache->raw_supply (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
 	}
     }
 }
diff --git a/gdb/alpha-bsd-nat.c b/gdb/alpha-bsd-nat.c
index e889d22f333..7a3fe9bb25f 100644
--- a/gdb/alpha-bsd-nat.c
+++ b/gdb/alpha-bsd-nat.c
@@ -182,12 +182,11 @@ alphabsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
   if (pcb->pcb_hw.apcb_ksp == 0)
     return 0;
 
-  regcache_raw_supply (regcache, ALPHA_SP_REGNUM, &pcb->pcb_hw.apcb_ksp);
+  regcache->raw_supply (ALPHA_SP_REGNUM, &pcb->pcb_hw.apcb_ksp);
 
   for (regnum = ALPHA_S0_REGNUM; regnum < ALPHA_A0_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum,
-			 &pcb->pcb_context[regnum - ALPHA_S0_REGNUM]);
-  regcache_raw_supply (regcache, ALPHA_RA_REGNUM, &pcb->pcb_context[7]);
+    regcache->raw_supply (regnum, &pcb->pcb_context[regnum - ALPHA_S0_REGNUM]);
+  regcache->raw_supply (ALPHA_RA_REGNUM, &pcb->pcb_context[7]);
 
   return 1;
 }
diff --git a/gdb/alpha-nbsd-tdep.c b/gdb/alpha-nbsd-tdep.c
index 970526e0a3f..dffab3fb37f 100644
--- a/gdb/alpha-nbsd-tdep.c
+++ b/gdb/alpha-nbsd-tdep.c
@@ -58,11 +58,11 @@ alphanbsd_supply_fpregset (const struct regset *regset,
   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + (i - ALPHA_FP0_REGNUM) * 8);
+	regcache->raw_supply (i, regs + (i - ALPHA_FP0_REGNUM) * 8);
     }
 
   if (regnum == ALPHA_FPCR_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 32 * 8);
+    regcache->raw_supply (ALPHA_FPCR_REGNUM, regs + 32 * 8);
 }
 
 /* Supply register REGNUM from the buffer specified by GREGS and LEN
@@ -95,11 +95,11 @@ alphanbsd_aout_supply_gregset (const struct regset *regset,
   for (i = 0; i < ARRAY_SIZE(regmap); i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + regmap[i] * 8);
+	regcache->raw_supply (i, regs + regmap[i] * 8);
     }
 
   if (regnum == ALPHA_PC_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
+    regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8);
 
   if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
     {
@@ -130,11 +130,11 @@ alphanbsd_supply_gregset (const struct regset *regset,
   for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * 8);
+	regcache->raw_supply (i, regs + i * 8);
     }
 
   if (regnum == ALPHA_PC_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
+    regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8);
 }
 
 /* NetBSD/alpha register sets.  */
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 408bedc68db..8ca1e51baaf 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -1499,20 +1499,20 @@ alpha_supply_int_regs (struct regcache *regcache, int regno,
 
   for (i = 0; i < 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_supply (regcache, i, regs + i * 8);
+      regcache->raw_supply (i, regs + i * 8);
 
   if (regno == ALPHA_ZERO_REGNUM || regno == -1)
     {
       const gdb_byte zero[8] = { 0 };
 
-      regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, zero);
+      regcache->raw_supply (ALPHA_ZERO_REGNUM, zero);
     }
 
   if (regno == ALPHA_PC_REGNUM || regno == -1)
-    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
+    regcache->raw_supply (ALPHA_PC_REGNUM, pc);
 
   if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
-    regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
+    regcache->raw_supply (ALPHA_UNIQUE_REGNUM, unique);
 }
 
 void
@@ -1542,11 +1542,10 @@ alpha_supply_fp_regs (struct regcache *regcache, int regno,
 
   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
     if (regno == i || regno == -1)
-      regcache_raw_supply (regcache, i,
-			   regs + (i - ALPHA_FP0_REGNUM) * 8);
+      regcache->raw_supply (i, regs + (i - ALPHA_FP0_REGNUM) * 8);
 
   if (regno == ALPHA_FPCR_REGNUM || regno == -1)
-    regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
+    regcache->raw_supply (ALPHA_FPCR_REGNUM, fpcr);
 }
 
 void
diff --git a/gdb/amd64-bsd-nat.c b/gdb/amd64-bsd-nat.c
index 81ba835fc49..6c46303c587 100644
--- a/gdb/amd64-bsd-nat.c
+++ b/gdb/amd64-bsd-nat.c
@@ -64,7 +64,7 @@ amd64bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
       if (ptrace (PT_GETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 	perror_with_name (_("Couldn't get segment register fs_base"));
 
-      regcache_raw_supply (regcache, AMD64_FSBASE_REGNUM, &base);
+      regcache->raw_supply (AMD64_FSBASE_REGNUM, &base);
       if (regnum != -1)
 	return;
     }
@@ -77,7 +77,7 @@ amd64bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
       if (ptrace (PT_GETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 	perror_with_name (_("Couldn't get segment register gs_base"));
 
-      regcache_raw_supply (regcache, AMD64_GSBASE_REGNUM, &base);
+      regcache->raw_supply (AMD64_GSBASE_REGNUM, &base);
       if (regnum != -1)
 	return;
     }
diff --git a/gdb/amd64-fbsd-nat.c b/gdb/amd64-fbsd-nat.c
index 6e0a1f9636e..6b0367b5d65 100644
--- a/gdb/amd64-fbsd-nat.c
+++ b/gdb/amd64-fbsd-nat.c
@@ -131,24 +131,24 @@ amd64fbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   pcb->pcb_rsp += 8;
-  regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &pcb->pcb_rip);
-  regcache_raw_supply (regcache, AMD64_RBX_REGNUM, &pcb->pcb_rbx);
-  regcache_raw_supply (regcache, AMD64_RSP_REGNUM, &pcb->pcb_rsp);
-  regcache_raw_supply (regcache, AMD64_RBP_REGNUM, &pcb->pcb_rbp);
-  regcache_raw_supply (regcache, 12, &pcb->pcb_r12);
-  regcache_raw_supply (regcache, 13, &pcb->pcb_r13);
-  regcache_raw_supply (regcache, 14, &pcb->pcb_r14);
-  regcache_raw_supply (regcache, 15, &pcb->pcb_r15);
+  regcache->raw_supply (AMD64_RIP_REGNUM, &pcb->pcb_rip);
+  regcache->raw_supply (AMD64_RBX_REGNUM, &pcb->pcb_rbx);
+  regcache->raw_supply (AMD64_RSP_REGNUM, &pcb->pcb_rsp);
+  regcache->raw_supply (AMD64_RBP_REGNUM, &pcb->pcb_rbp);
+  regcache->raw_supply (12, &pcb->pcb_r12);
+  regcache->raw_supply (13, &pcb->pcb_r13);
+  regcache->raw_supply (14, &pcb->pcb_r14);
+  regcache->raw_supply (15, &pcb->pcb_r15);
 #if (__FreeBSD_version < 800075) && (__FreeBSD_kernel_version < 800075)
   /* struct pcb provides the pcb_ds/pcb_es/pcb_fs/pcb_gs fields only
      up until __FreeBSD_version 800074: The removal of these fields
      occurred on 2009-04-01 while the __FreeBSD_version number was
      bumped to 800075 on 2009-04-06.  So 800075 is the closest version
      number where we should not try to access these fields.  */
-  regcache_raw_supply (regcache, AMD64_DS_REGNUM, &pcb->pcb_ds);
-  regcache_raw_supply (regcache, AMD64_ES_REGNUM, &pcb->pcb_es);
-  regcache_raw_supply (regcache, AMD64_FS_REGNUM, &pcb->pcb_fs);
-  regcache_raw_supply (regcache, AMD64_GS_REGNUM, &pcb->pcb_gs);
+  regcache->raw_supply (AMD64_DS_REGNUM, &pcb->pcb_ds);
+  regcache->raw_supply (AMD64_ES_REGNUM, &pcb->pcb_es);
+  regcache->raw_supply (AMD64_FS_REGNUM, &pcb->pcb_fs);
+  regcache->raw_supply (AMD64_GS_REGNUM, &pcb->pcb_gs);
 #endif
 
   return 1;
diff --git a/gdb/amd64-linux-nat.c b/gdb/amd64-linux-nat.c
index 17de388a2fb..623a90e921f 100644
--- a/gdb/amd64-linux-nat.c
+++ b/gdb/amd64-linux-nat.c
@@ -200,7 +200,7 @@ amd64_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
 	    if (ptrace (PTRACE_ARCH_PRCTL, tid, &base, ARCH_GET_FS) < 0)
 	      perror_with_name (_("Couldn't get segment register fs_base"));
 
-	    regcache_raw_supply (regcache, AMD64_FSBASE_REGNUM, &base);
+	    regcache->raw_supply (AMD64_FSBASE_REGNUM, &base);
 	  }
 
 	if (regnum == -1 || regnum == AMD64_GSBASE_REGNUM)
@@ -208,7 +208,7 @@ amd64_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
 	    if (ptrace (PTRACE_ARCH_PRCTL, tid, &base, ARCH_GET_GS) < 0)
 	      perror_with_name (_("Couldn't get segment register gs_base"));
 
-	    regcache_raw_supply (regcache, AMD64_GSBASE_REGNUM, &base);
+	    regcache->raw_supply (AMD64_GSBASE_REGNUM, &base);
 	  }
       }
 #endif
diff --git a/gdb/amd64-nat.c b/gdb/amd64-nat.c
index 12d364a7163..5dde69c7014 100644
--- a/gdb/amd64-nat.c
+++ b/gdb/amd64-nat.c
@@ -113,7 +113,7 @@ amd64_supply_native_gregset (struct regcache *regcache,
 	  int offset = amd64_native_gregset_reg_offset (gdbarch, i);
 
 	  if (offset != -1)
-	    regcache_raw_supply (regcache, i, regs + offset);
+	    regcache->raw_supply (i, regs + offset);
 	}
     }
 }
diff --git a/gdb/amd64-obsd-nat.c b/gdb/amd64-obsd-nat.c
index 0e89e3f574b..c0d6a33e13d 100644
--- a/gdb/amd64-obsd-nat.c
+++ b/gdb/amd64-obsd-nat.c
@@ -106,22 +106,22 @@ amd64obsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     {
       /* Yes, we have a frame that matches cpu_switch().  */
       pcb->pcb_rsp += sizeof (struct switchframe);
-      regcache_raw_supply (regcache, 12, &sf.sf_r12);
-      regcache_raw_supply (regcache, 13, &sf.sf_r13);
-      regcache_raw_supply (regcache, 14, &sf.sf_r14);
-      regcache_raw_supply (regcache, 15, &sf.sf_r15);
-      regcache_raw_supply (regcache, AMD64_RBX_REGNUM, &sf.sf_rbx);
-      regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &sf.sf_rip);
+      regcache->raw_supply (12, &sf.sf_r12);
+      regcache->raw_supply (13, &sf.sf_r13);
+      regcache->raw_supply (14, &sf.sf_r14);
+      regcache->raw_supply (15, &sf.sf_r15);
+      regcache->raw_supply (AMD64_RBX_REGNUM, &sf.sf_rbx);
+      regcache->raw_supply (AMD64_RIP_REGNUM, &sf.sf_rip);
     }
   else
     {
       /* No, the pcb must have been last updated by savectx().  */
       pcb->pcb_rsp += 8;
-      regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &sf);
+      regcache->raw_supply (AMD64_RIP_REGNUM, &sf);
     }
 
-  regcache_raw_supply (regcache, AMD64_RSP_REGNUM, &pcb->pcb_rsp);
-  regcache_raw_supply (regcache, AMD64_RBP_REGNUM, &pcb->pcb_rbp);
+  regcache->raw_supply (AMD64_RSP_REGNUM, &pcb->pcb_rsp);
+  regcache->raw_supply (AMD64_RBP_REGNUM, &pcb->pcb_rbp);
 
   return 1;
 }
diff --git a/gdb/amd64-obsd-tdep.c b/gdb/amd64-obsd-tdep.c
index b1be933a2e0..4089200309d 100644
--- a/gdb/amd64-obsd-tdep.c
+++ b/gdb/amd64-obsd-tdep.c
@@ -241,7 +241,7 @@ amd64obsd_supply_uthread (struct regcache *regcache,
          returned from _thread_machdep_switch.  */
       offset = amd64obsd_uthread_reg_offset[AMD64_RIP_REGNUM] + 8;
       store_unsigned_integer (buf, 8, byte_order, sp + offset);
-      regcache_raw_supply (regcache, AMD64_RSP_REGNUM, buf);
+      regcache->raw_supply (AMD64_RSP_REGNUM, buf);
     }
 
   for (i = 0; i < ARRAY_SIZE (amd64obsd_uthread_reg_offset); i++)
@@ -256,7 +256,7 @@ amd64obsd_supply_uthread (struct regcache *regcache,
 
 	  /* Read the saved register from the stack frame.  */
 	  read_memory (sp + amd64obsd_uthread_reg_offset[i], buf, 8);
-	  regcache_raw_supply (regcache, i, buf);
+	  regcache->raw_supply (i, buf);
 	}
     }
 }
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 975c907527f..8b925fdb3a3 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -3349,9 +3349,9 @@ amd64_supply_fxsave (struct regcache *regcache, int regnum,
       const gdb_byte *regs = (const gdb_byte *) fxsave;
 
       if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
-	regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep), regs + 12);
+	regcache->raw_supply (I387_FISEG_REGNUM (tdep), regs + 12);
       if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
-	regcache_raw_supply (regcache, I387_FOSEG_REGNUM (tdep), regs + 20);
+	regcache->raw_supply (I387_FOSEG_REGNUM (tdep), regs + 20);
     }
 }
 
@@ -3381,11 +3381,9 @@ amd64_supply_xsave (struct regcache *regcache, int regnum,
       if (!(clear_bv & X86_XSTATE_X87))
 	{
 	  if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
-	    regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep),
-				 regs + 12);
+	    regcache->raw_supply (I387_FISEG_REGNUM (tdep), regs + 12);
 	  if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
-	    regcache_raw_supply (regcache, I387_FOSEG_REGNUM (tdep),
-				 regs + 20);
+	    regcache->raw_supply (I387_FOSEG_REGNUM (tdep), regs + 20);
 	}
     }
 }
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index e3cce491ee7..b3169ca89ca 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -946,7 +946,7 @@ default_guess_tracepoint_registers (struct gdbarch *gdbarch,
   regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno));
   store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
 			  gdbarch_byte_order (gdbarch), addr);
-  regcache_raw_supply (regcache, pc_regno, regs);
+  regcache->raw_supply (pc_regno, regs);
 }
 
 int
diff --git a/gdb/arm-bsd-tdep.c b/gdb/arm-bsd-tdep.c
index 7c820d05509..a2719caa4c5 100644
--- a/gdb/arm-bsd-tdep.c
+++ b/gdb/arm-bsd-tdep.c
@@ -58,7 +58,7 @@ armbsd_supply_fpregset (const struct regset *regset,
   for (i = ARM_F0_REGNUM; i <= ARM_FPS_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + armbsd_fpreg_offset (i));
+	regcache->raw_supply (i, regs + armbsd_fpreg_offset (i));
     }
 }
 
@@ -79,11 +79,11 @@ armbsd_supply_gregset (const struct regset *regset,
   for (i = ARM_A1_REGNUM; i <= ARM_PC_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * 4);
+	regcache->raw_supply (i, regs + i * 4);
     }
 
   if (regnum == ARM_PS_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, i, regs + 16 * 4);
+    regcache->raw_supply (i, regs + 16 * 4);
 
   if (len >= ARMBSD_SIZEOF_GREGS + ARMBSD_SIZEOF_FPREGS)
     {
diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c
index a1bef7a4e23..163e1be0b44 100644
--- a/gdb/arm-linux-nat.c
+++ b/gdb/arm-linux-nat.c
@@ -138,8 +138,7 @@ fetch_fpregs (struct regcache *regcache)
     perror_with_name (_("Unable to fetch the floating point registers."));
 
   /* Fetch fpsr.  */
-  regcache_raw_supply (regcache, ARM_FPS_REGNUM,
-		       fp + NWFPE_FPSR_OFFSET);
+  regcache->raw_supply (ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 
   /* Fetch the floating point registers.  */
   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
@@ -292,16 +291,15 @@ fetch_wmmx_regs (struct regcache *regcache)
     perror_with_name (_("Unable to fetch WMMX registers."));
 
   for (regno = 0; regno < 16; regno++)
-    regcache_raw_supply (regcache, regno + ARM_WR0_REGNUM,
-			 &regbuf[regno * 8]);
+    regcache->raw_supply (regno + ARM_WR0_REGNUM, &regbuf[regno * 8]);
 
   for (regno = 0; regno < 2; regno++)
-    regcache_raw_supply (regcache, regno + ARM_WCSSF_REGNUM,
-			 &regbuf[16 * 8 + regno * 4]);
+    regcache->raw_supply (regno + ARM_WCSSF_REGNUM,
+			  &regbuf[16 * 8 + regno * 4]);
 
   for (regno = 0; regno < 4; regno++)
-    regcache_raw_supply (regcache, regno + ARM_WCGR0_REGNUM,
-			 &regbuf[16 * 8 + 2 * 4 + regno * 4]);
+    regcache->raw_supply (regno + ARM_WCGR0_REGNUM,
+			  &regbuf[16 * 8 + 2 * 4 + regno * 4]);
 }
 
 static void
diff --git a/gdb/arm-linux-tdep.c b/gdb/arm-linux-tdep.c
index e8f8c4e6cf0..d8a834716a3 100644
--- a/gdb/arm-linux-tdep.c
+++ b/gdb/arm-linux-tdep.c
@@ -487,16 +487,15 @@ arm_linux_supply_gregset (const struct regset *regset,
 
   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
     if (regnum == -1 || regnum == regno)
-      regcache_raw_supply (regcache, regno,
-			   gregs + INT_REGISTER_SIZE * regno);
+      regcache->raw_supply (regno, gregs + INT_REGISTER_SIZE * regno);
 
   if (regnum == ARM_PS_REGNUM || regnum == -1)
     {
       if (arm_apcs_32)
-	regcache_raw_supply (regcache, ARM_PS_REGNUM,
-			     gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
+	regcache->raw_supply (ARM_PS_REGNUM,
+			      gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
       else
-	regcache_raw_supply (regcache, ARM_PS_REGNUM,
+	regcache->raw_supply (ARM_PS_REGNUM,
 			     gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
     }
 
@@ -507,7 +506,7 @@ arm_linux_supply_gregset (const struct regset *regset,
 					 INT_REGISTER_SIZE, byte_order);
       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
-      regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
+      regcache->raw_supply (ARM_PC_REGNUM, pc_buf);
     }
 }
 
@@ -578,7 +577,7 @@ supply_nwfpe_register (struct regcache *regcache, int regno,
       break;
     }
 
-  regcache_raw_supply (regcache, regno, buf);
+  regcache->raw_supply (regno, buf);
 }
 
 void
@@ -627,7 +626,7 @@ arm_linux_supply_nwfpe (const struct regset *regset,
   int regno;
 
   if (regnum == ARM_FPS_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, ARM_FPS_REGNUM,
+    regcache->raw_supply (ARM_FPS_REGNUM,
 			 regs + NWFPE_FPSR_OFFSET);
 
   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
@@ -665,12 +664,11 @@ arm_linux_supply_vfp (const struct regset *regset,
   int regno;
 
   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
+    regcache->raw_supply (ARM_FPSCR_REGNUM, regs + 32 * 8);
 
   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
     if (regnum == -1 || regnum == regno)
-      regcache_raw_supply (regcache, regno,
-			   regs + (regno - ARM_D0_REGNUM) * 8);
+      regcache->raw_supply (regno, regs + (regno - ARM_D0_REGNUM) * 8);
 }
 
 static void
diff --git a/gdb/arm-nbsd-nat.c b/gdb/arm-nbsd-nat.c
index 3d64346008f..a641ccbb3c0 100644
--- a/gdb/arm-nbsd-nat.c
+++ b/gdb/arm-nbsd-nat.c
@@ -50,22 +50,18 @@ arm_supply_gregset (struct regcache *regcache, struct reg *gregset)
 
   /* Integer registers.  */
   for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++)
-    regcache_raw_supply (regcache, regno, (char *) &gregset->r[regno]);
+    regcache->raw_supply (regno, (char *) &gregset->r[regno]);
 
-  regcache_raw_supply (regcache, ARM_SP_REGNUM,
-		       (char *) &gregset->r_sp);
-  regcache_raw_supply (regcache, ARM_LR_REGNUM,
-		       (char *) &gregset->r_lr);
+  regcache->raw_supply (ARM_SP_REGNUM, (char *) &gregset->r_sp);
+  regcache->raw_supply (ARM_LR_REGNUM, (char *) &gregset->r_lr);
   /* This is ok: we're running native...  */
   r_pc = gdbarch_addr_bits_remove (regcache->arch (), gregset->r_pc);
-  regcache_raw_supply (regcache, ARM_PC_REGNUM, (char *) &r_pc);
+  regcache->raw_supply (ARM_PC_REGNUM, (char *) &r_pc);
 
   if (arm_apcs_32)
-    regcache_raw_supply (regcache, ARM_PS_REGNUM,
-			 (char *) &gregset->r_cpsr);
+    regcache->raw_supply (ARM_PS_REGNUM, (char *) &gregset->r_cpsr);
   else
-    regcache_raw_supply (regcache, ARM_PS_REGNUM,
-			 (char *) &gregset->r_pc);
+    regcache->raw_supply (ARM_PS_REGNUM, (char *) &gregset->r_pc);
 }
 
 static void
@@ -74,11 +70,10 @@ arm_supply_fparegset (struct regcache *regcache, struct fpreg *fparegset)
   int regno;
 
   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
-    regcache_raw_supply (regcache, regno,
-			 (char *) &fparegset->fpr[regno - ARM_F0_REGNUM]);
+    regcache->raw_supply (regno,
+			  (char *) &fparegset->fpr[regno - ARM_F0_REGNUM]);
 
-  regcache_raw_supply (regcache, ARM_FPS_REGNUM,
-		       (char *) &fparegset->fpr_fpsr);
+  regcache->raw_supply (ARM_FPS_REGNUM, (char *) &fparegset->fpr_fpsr);
 }
 
 static void
@@ -99,13 +94,11 @@ fetch_register (struct regcache *regcache, int regno)
   switch (regno)
     {
     case ARM_SP_REGNUM:
-      regcache_raw_supply (regcache, ARM_SP_REGNUM,
-			   (char *) &inferior_registers.r_sp);
+      regcache->raw_supply (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
       break;
 
     case ARM_LR_REGNUM:
-      regcache_raw_supply (regcache, ARM_LR_REGNUM,
-			   (char *) &inferior_registers.r_lr);
+      regcache->raw_supply (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
       break;
 
     case ARM_PC_REGNUM:
@@ -113,22 +106,20 @@ fetch_register (struct regcache *regcache, int regno)
       inferior_registers.r_pc = gdbarch_addr_bits_remove
 				  (regcache->arch (),
 				   inferior_registers.r_pc);
-      regcache_raw_supply (regcache, ARM_PC_REGNUM,
-			   (char *) &inferior_registers.r_pc);
+      regcache->raw_supply (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
       break;
 
     case ARM_PS_REGNUM:
       if (arm_apcs_32)
-	regcache_raw_supply (regcache, ARM_PS_REGNUM,
-			     (char *) &inferior_registers.r_cpsr);
+	regcache->raw_supply (ARM_PS_REGNUM,
+			      (char *) &inferior_registers.r_cpsr);
       else
-	regcache_raw_supply (regcache, ARM_PS_REGNUM,
-			     (char *) &inferior_registers.r_pc);
+	regcache->raw_supply (ARM_PS_REGNUM,
+			      (char *) &inferior_registers.r_pc);
       break;
 
     default:
-      regcache_raw_supply (regcache, regno,
-			   (char *) &inferior_registers.r[regno]);
+      regcache->raw_supply (regno, (char *) &inferior_registers.r[regno]);
       break;
     }
 }
@@ -170,13 +161,13 @@ fetch_fp_register (struct regcache *regcache, int regno)
   switch (regno)
     {
     case ARM_FPS_REGNUM:
-      regcache_raw_supply (regcache, ARM_FPS_REGNUM,
-			   (char *) &inferior_fp_registers.fpr_fpsr);
+      regcache->raw_supply (ARM_FPS_REGNUM,
+			    (char *) &inferior_fp_registers.fpr_fpsr);
       break;
 
     default:
-      regcache_raw_supply (regcache, regno,
-			   (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
+      regcache->raw_supply
+	(regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
       break;
     }
 }
diff --git a/gdb/corelow.c b/gdb/corelow.c
index 0a7d742aad9..a81639542b9 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -705,7 +705,7 @@ core_target::fetch_registers (struct regcache *regcache, int regno)
   /* Mark all registers not found in the core as unavailable.  */
   for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
     if (regcache->get_register_status (i) == REG_UNKNOWN)
-      regcache_raw_supply (regcache, i, NULL);
+      regcache->raw_supply (i, NULL);
 }
 
 void
diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index a0fb3b27ec3..e0371a2a282 100644
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -3809,7 +3809,7 @@ cris_supply_gregset (struct regcache *regcache, cris_elf_gregset_t *gregsetp)
      knows about the actual size of each register so that's no problem.  */
   for (i = 0; i < NUM_GENREGS + NUM_SPECREGS; i++)
     {
-      regcache_raw_supply (regcache, i, (char *)&regp[i]);
+      regcache->raw_supply (i, (char *)&regp[i]);
     }
 
   if (tdep->cris_version == 32)
@@ -3817,8 +3817,8 @@ cris_supply_gregset (struct regcache *regcache, cris_elf_gregset_t *gregsetp)
       /* Needed to set pseudo-register PC for CRISv32.  */
       /* FIXME: If ERP is in a delay slot at this point then the PC will
 	 be wrong.  Issue a warning to alert the user.  */
-      regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
-			   (char *)&regp[ERP_REGNUM]);
+      regcache->raw_supply (gdbarch_pc_regnum (gdbarch),
+			    (char *)&regp[ERP_REGNUM]);
 
       if (*(char *)&regp[ERP_REGNUM] & 0x1)
 	fprintf_unfiltered (gdb_stderr, "Warning: PC in delay slot\n");
diff --git a/gdb/ctf.c b/gdb/ctf.c
index 1ab095d9da3..7e2207484c4 100644
--- a/gdb/ctf.c
+++ b/gdb/ctf.c
@@ -1266,12 +1266,12 @@ ctf_target::fetch_registers (struct regcache *regcache, int regno)
 	    {
 	      if (regno == regn)
 		{
-		  regcache_raw_supply (regcache, regno, regs + offset);
+		  regcache->raw_supply (regno, regs + offset);
 		  break;
 		}
 	      else if (regno == -1)
 		{
-		  regcache_raw_supply (regcache, regn, regs + offset);
+		  regcache->raw_supply (regn, regs + offset);
 		}
 	    }
 	  offset += regsize;
diff --git a/gdb/go32-nat.c b/gdb/go32-nat.c
index 980180b23a1..a2affe16966 100644
--- a/gdb/go32-nat.c
+++ b/gdb/go32-nat.c
@@ -541,8 +541,8 @@ fetch_register (struct regcache *regcache, int regno)
 {
   struct gdbarch *gdbarch = regcache->arch ();
   if (regno < gdbarch_fp0_regnum (gdbarch))
-    regcache_raw_supply (regcache, regno,
-			 (char *) &a_tss + regno_mapping[regno].tss_ofs);
+    regcache->raw_supply (regno,
+			  (char *) &a_tss + regno_mapping[regno].tss_ofs);
   else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch,
 								   regno))
     i387_supply_fsave (regcache, regno, &npx);
diff --git a/gdb/hppa-linux-nat.c b/gdb/hppa-linux-nat.c
index 39ae83fe6ae..7dea0790965 100644
--- a/gdb/hppa-linux-nat.c
+++ b/gdb/hppa-linux-nat.c
@@ -229,7 +229,7 @@ fetch_register (struct regcache *regcache, int regno)
 
   if (gdbarch_cannot_fetch_register (gdbarch, regno))
     {
-      regcache_raw_supply (regcache, regno, NULL);
+      regcache->raw_supply (regno, NULL);
       return;
     }
 
@@ -242,7 +242,7 @@ fetch_register (struct regcache *regcache, int regno)
 	   gdbarch_register_name (gdbarch, regno),
 	   regno, safe_strerror (errno));
 
-  regcache_raw_supply (regcache, regno, &val);
+  regcache->raw_supply (regno, &val);
 }
 
 /* Store one register.  */
@@ -321,7 +321,7 @@ supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
   for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
     {
       int regno = greg_map[i];
-      regcache_raw_supply (regcache, regno, regp);
+      regcache->raw_supply (regno, regp);
     }
 }
 
@@ -359,8 +359,8 @@ supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
   for (regi = 0; regi <= 31; regi++)
     {
       from = (const char *) &((*fpregsetp)[regi]);
-      regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM, from);
-      regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM + 1, from + 4);
+      regcache->raw_supply (2*regi + HPPA_FP0_REGNUM, from);
+      regcache->raw_supply (2*regi + HPPA_FP0_REGNUM + 1, from + 4);
     }
 }
 
diff --git a/gdb/hppa-nbsd-nat.c b/gdb/hppa-nbsd-nat.c
index 2ffa5bc79fc..99dfd32a6bc 100644
--- a/gdb/hppa-nbsd-nat.c
+++ b/gdb/hppa-nbsd-nat.c
@@ -63,19 +63,19 @@ hppanbsd_supply_gregset (struct regcache *regcache, const void *gregs)
   int regnum;
 
   for (regnum = HPPA_R1_REGNUM; regnum <= HPPA_R31_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + regnum * 4);
-
-  regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs + 32 * 4);
-  regcache_raw_supply (regcache, HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
-  regcache_raw_supply (regcache, HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
-  regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
-  regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
-  regcache_raw_supply (regcache, HPPA_IPSW_REGNUM, regs);
-  regcache_raw_supply (regcache, HPPA_SR4_REGNUM, regs + 41 * 4);
-  regcache_raw_supply (regcache, HPPA_SR4_REGNUM + 1, regs + 37 * 4);
-  regcache_raw_supply (regcache, HPPA_SR4_REGNUM + 2, regs + 38 * 4);
-  regcache_raw_supply (regcache, HPPA_SR4_REGNUM + 3, regs + 39 * 4);
-  regcache_raw_supply (regcache, HPPA_SR4_REGNUM + 4, regs + 40 * 4);
+    regcache->raw_supply (regnum, regs + regnum * 4);
+
+  regcache->raw_supply (HPPA_SAR_REGNUM, regs + 32 * 4);
+  regcache->raw_supply (HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
+  regcache->raw_supply (HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
+  regcache->raw_supply (HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
+  regcache->raw_supply (HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
+  regcache->raw_supply (HPPA_IPSW_REGNUM, regs);
+  regcache->raw_supply (HPPA_SR4_REGNUM, regs + 41 * 4);
+  regcache->raw_supply (HPPA_SR4_REGNUM + 1, regs + 37 * 4);
+  regcache->raw_supply (HPPA_SR4_REGNUM + 2, regs + 38 * 4);
+  regcache->raw_supply (HPPA_SR4_REGNUM + 3, regs + 39 * 4);
+  regcache->raw_supply (HPPA_SR4_REGNUM + 4, regs + 40 * 4);
 }
 
 /* Supply the floating-point registers stored in FPREGS to REGCACHE.  */
@@ -89,8 +89,8 @@ hppanbsd_supply_fpregset (struct regcache *regcache, const void *fpregs)
   for (regnum = HPPA_FP0_REGNUM; regnum <= HPPA_FP31R_REGNUM;
        regnum += 2, regs += 8)
     {
-      regcache_raw_supply (regcache, regnum, regs);
-      regcache_raw_supply (regcache, regnum + 1, regs + 4);
+      regcache->raw_supply (regnum, regs);
+      regcache->raw_supply (regnum + 1, regs + 4);
     }
 }
 
diff --git a/gdb/hppa-nbsd-tdep.c b/gdb/hppa-nbsd-tdep.c
index 05249b6017e..f9932b5b805 100644
--- a/gdb/hppa-nbsd-tdep.c
+++ b/gdb/hppa-nbsd-tdep.c
@@ -171,7 +171,7 @@ hppanbsd_supply_gregset (const struct regset *regset,
   for (i = 0; i < ARRAY_SIZE (hppanbsd_reg_offset); i++)
     if (hppanbsd_reg_offset[i] != -1)
       if (regnum == -1 || regnum == i)
-	regcache_raw_supply (regcache, i, regs + hppanbsd_reg_offset[i]);
+	regcache->raw_supply (i, regs + hppanbsd_reg_offset[i]);
 }
 
 /* NetBSD/hppa register set.  */
diff --git a/gdb/hppa-obsd-nat.c b/gdb/hppa-obsd-nat.c
index 2ef2f7ef2cf..53880f691be 100644
--- a/gdb/hppa-obsd-nat.c
+++ b/gdb/hppa-obsd-nat.c
@@ -60,34 +60,34 @@ hppaobsd_supply_gregset (struct regcache *regcache, const void *gregs)
   const char *regs = gregs;
   int regnum;
 
-  regcache_raw_supply (regcache, HPPA_R0_REGNUM, &zero);
+  regcache->raw_supply (HPPA_R0_REGNUM, &zero);
   for (regnum = HPPA_R1_REGNUM; regnum <= HPPA_R31_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + regnum * 4);
+    regcache->raw_supply (regnum, regs + regnum * 4);
 
   if (sizeof(struct reg) >= 46 * 4)
     {
-      regcache_raw_supply (regcache, HPPA_IPSW_REGNUM, regs);
-      regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs + 32 * 4);
-      regcache_raw_supply (regcache, HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
-      regcache_raw_supply (regcache, HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
-      regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
-      regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
-      regcache_raw_supply (regcache, HPPA_SR0_REGNUM, regs + 37 * 4);
-      regcache_raw_supply (regcache, HPPA_SR1_REGNUM, regs + 38 * 4);
-      regcache_raw_supply (regcache, HPPA_SR2_REGNUM, regs + 39 * 4);
-      regcache_raw_supply (regcache, HPPA_SR3_REGNUM, regs + 40 * 4);
-      regcache_raw_supply (regcache, HPPA_SR4_REGNUM, regs + 41 * 4);
-      regcache_raw_supply (regcache, HPPA_SR5_REGNUM, regs + 42 * 4);
-      regcache_raw_supply (regcache, HPPA_SR6_REGNUM, regs + 43 * 4);
-      regcache_raw_supply (regcache, HPPA_SR7_REGNUM, regs + 44 * 4);
-      regcache_raw_supply (regcache, HPPA_CR26_REGNUM, regs + 45 * 4);
-      regcache_raw_supply (regcache, HPPA_CR27_REGNUM, regs + 46 * 4);
+      regcache->raw_supply (HPPA_IPSW_REGNUM, regs);
+      regcache->raw_supply (HPPA_SAR_REGNUM, regs + 32 * 4);
+      regcache->raw_supply (HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
+      regcache->raw_supply (HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
+      regcache->raw_supply (HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
+      regcache->raw_supply (HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
+      regcache->raw_supply (HPPA_SR0_REGNUM, regs + 37 * 4);
+      regcache->raw_supply (HPPA_SR1_REGNUM, regs + 38 * 4);
+      regcache->raw_supply (HPPA_SR2_REGNUM, regs + 39 * 4);
+      regcache->raw_supply (HPPA_SR3_REGNUM, regs + 40 * 4);
+      regcache->raw_supply (HPPA_SR4_REGNUM, regs + 41 * 4);
+      regcache->raw_supply (HPPA_SR5_REGNUM, regs + 42 * 4);
+      regcache->raw_supply (HPPA_SR6_REGNUM, regs + 43 * 4);
+      regcache->raw_supply (HPPA_SR7_REGNUM, regs + 44 * 4);
+      regcache->raw_supply (HPPA_CR26_REGNUM, regs + 45 * 4);
+      regcache->raw_supply (HPPA_CR27_REGNUM, regs + 46 * 4);
     } 
   else
     {
-      regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs);
-      regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
-      regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
+      regcache->raw_supply (HPPA_SAR_REGNUM, regs);
+      regcache->raw_supply (HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
+      regcache->raw_supply (HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
     }
 }
 
@@ -102,8 +102,8 @@ hppaobsd_supply_fpregset (struct regcache *regcache, const void *fpregs)
   for (regnum = HPPA_FP0_REGNUM; regnum <= HPPA_FP31R_REGNUM;
        regnum += 2, regs += 8)
     {
-      regcache_raw_supply (regcache, regnum, regs);
-      regcache_raw_supply (regcache, regnum + 1, regs + 4);
+      regcache->raw_supply (regnum, regs);
+      regcache->raw_supply (regnum + 1, regs + 4);
     }
 }
 
diff --git a/gdb/hppa-obsd-tdep.c b/gdb/hppa-obsd-tdep.c
index 974a0722940..403e9ddc827 100644
--- a/gdb/hppa-obsd-tdep.c
+++ b/gdb/hppa-obsd-tdep.c
@@ -51,56 +51,56 @@ hppaobsd_supply_gregset (const struct regset *regset,
   gdb_assert (len >= HPPAOBSD_SIZEOF_GREGS);
 
   if (regnum == -1 || regnum == HPPA_R0_REGNUM)
-    regcache_raw_supply (regcache, HPPA_R0_REGNUM, &zero);
+    regcache->raw_supply (HPPA_R0_REGNUM, &zero);
   for (i = HPPA_R1_REGNUM, offset = 4; i <= HPPA_R31_REGNUM; i++, offset += 4)
     {
       if (regnum == -1 || regnum == i)
-	regcache_raw_supply (regcache, i, regs + offset);
+	regcache->raw_supply (i, regs + offset);
     }
 
   if (len >= HPPANBSD_SIZEOF_GREGS)
     {
       if (regnum == -1 || regnum == HPPA_IPSW_REGNUM)
-	regcache_raw_supply (regcache, HPPA_IPSW_REGNUM, regs);
+	regcache->raw_supply (HPPA_IPSW_REGNUM, regs);
       if (regnum == -1 || regnum == HPPA_SAR_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs + 32 * 4);
+	regcache->raw_supply (HPPA_SAR_REGNUM, regs + 32 * 4);
       if (regnum == -1 || regnum == HPPA_PCSQ_HEAD_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
+	regcache->raw_supply (HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
       if (regnum == -1 || regnum == HPPA_PCSQ_TAIL_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
+	regcache->raw_supply (HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
       if (regnum == -1 || regnum == HPPA_PCOQ_HEAD_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
+	regcache->raw_supply (HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
       if (regnum == -1 || regnum == HPPA_PCOQ_TAIL_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
+	regcache->raw_supply (HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
       if (regnum == -1 || regnum == HPPA_SR0_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR0_REGNUM, regs + 37 * 4);
+	regcache->raw_supply (HPPA_SR0_REGNUM, regs + 37 * 4);
       if (regnum == -1 || regnum == HPPA_SR1_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR1_REGNUM, regs + 38 * 4);
+	regcache->raw_supply (HPPA_SR1_REGNUM, regs + 38 * 4);
       if (regnum == -1 || regnum == HPPA_SR2_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR2_REGNUM, regs + 39 * 4);
+	regcache->raw_supply (HPPA_SR2_REGNUM, regs + 39 * 4);
       if (regnum == -1 || regnum == HPPA_SR3_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR3_REGNUM, regs + 40 * 4);
+	regcache->raw_supply (HPPA_SR3_REGNUM, regs + 40 * 4);
       if (regnum == -1 || regnum == HPPA_SR4_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR4_REGNUM, regs + 41 * 4);
+	regcache->raw_supply (HPPA_SR4_REGNUM, regs + 41 * 4);
       if (regnum == -1 || regnum == HPPA_SR5_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR5_REGNUM, regs + 42 * 4);
+	regcache->raw_supply (HPPA_SR5_REGNUM, regs + 42 * 4);
       if (regnum == -1 || regnum == HPPA_SR6_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR6_REGNUM, regs + 43 * 4);
+	regcache->raw_supply (HPPA_SR6_REGNUM, regs + 43 * 4);
       if (regnum == -1 || regnum == HPPA_SR7_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SR7_REGNUM, regs + 44 * 4);
+	regcache->raw_supply (HPPA_SR7_REGNUM, regs + 44 * 4);
       if (regnum == -1 || regnum == HPPA_CR26_REGNUM)
-	regcache_raw_supply (regcache, HPPA_CR26_REGNUM, regs + 45 * 4);
+	regcache->raw_supply (HPPA_CR26_REGNUM, regs + 45 * 4);
       if (regnum == -1 || regnum == HPPA_CR27_REGNUM)
-	regcache_raw_supply (regcache, HPPA_CR27_REGNUM, regs + 46 * 4);
+	regcache->raw_supply (HPPA_CR27_REGNUM, regs + 46 * 4);
     }
   else
     {
       if (regnum == -1 || regnum == HPPA_SAR_REGNUM)
-	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs);
+	regcache->raw_supply (HPPA_SAR_REGNUM, regs);
       if (regnum == -1 || regnum == HPPA_PCOQ_HEAD_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
+	regcache->raw_supply (HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
       if (regnum == -1 || regnum == HPPA_PCOQ_TAIL_REGNUM)
-	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
+	regcache->raw_supply (HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
     }
 }
 
@@ -121,7 +121,7 @@ hppaobsd_supply_fpregset (const struct regset *regset,
   for (i = HPPA_FP0_REGNUM; i <= HPPA_FP31R_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + (i - HPPA_FP0_REGNUM) * 4);
+	regcache->raw_supply (i, regs + (i - HPPA_FP0_REGNUM) * 4);
     }
 }
 
diff --git a/gdb/i386-bsd-nat.c b/gdb/i386-bsd-nat.c
index cca46298435..27533666d67 100644
--- a/gdb/i386-bsd-nat.c
+++ b/gdb/i386-bsd-nat.c
@@ -97,7 +97,7 @@ i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
       int offset = i386bsd_r_reg_offset[regnum];
 
       if (offset != -1)
-	regcache_raw_supply (regcache, regnum, regs + offset);
+	regcache->raw_supply (regnum, regs + offset);
     }
 }
 
diff --git a/gdb/i386-darwin-nat.c b/gdb/i386-darwin-nat.c
index 03adb20e989..2dbf95fbd2a 100644
--- a/gdb/i386-darwin-nat.c
+++ b/gdb/i386-darwin-nat.c
@@ -132,9 +132,8 @@ i386_darwin_nat_target::fetch_registers (struct regcache *regcache, int regno)
 	      MACH_CHECK_ERROR (ret);
 	    }
 	  for (i = 0; i < I386_NUM_GREGS; i++)
-	    regcache_raw_supply
-	      (regcache, i,
-	       (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
+	    regcache->raw_supply
+	      (i, (char *) &gp_regs + i386_darwin_thread_state_reg_offset[i]);
 
           fetched++;
         }
@@ -164,7 +163,7 @@ i386_darwin_nat_target::fetch_registers (struct regcache *regcache, int regno)
   if (! fetched)
     {
       warning (_("unknown register %d"), regno);
-      regcache_raw_supply (regcache, regno, NULL);
+      regcache->raw_supply (regno, NULL);
     }
 }
 
diff --git a/gdb/i386-fbsd-nat.c b/gdb/i386-fbsd-nat.c
index 0d3762a7f03..46f9a860063 100644
--- a/gdb/i386-fbsd-nat.c
+++ b/gdb/i386-fbsd-nat.c
@@ -123,13 +123,13 @@ i386fbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   pcb->pcb_esp += 4;
-  regcache_raw_supply (regcache, I386_EDI_REGNUM, &pcb->pcb_edi);
-  regcache_raw_supply (regcache, I386_ESI_REGNUM, &pcb->pcb_esi);
-  regcache_raw_supply (regcache, I386_EBP_REGNUM, &pcb->pcb_ebp);
-  regcache_raw_supply (regcache, I386_ESP_REGNUM, &pcb->pcb_esp);
-  regcache_raw_supply (regcache, I386_EBX_REGNUM, &pcb->pcb_ebx);
-  regcache_raw_supply (regcache, I386_EIP_REGNUM, &pcb->pcb_eip);
-  regcache_raw_supply (regcache, I386_GS_REGNUM, &pcb->pcb_gs);
+  regcache->raw_supply (I386_EDI_REGNUM, &pcb->pcb_edi);
+  regcache->raw_supply (I386_ESI_REGNUM, &pcb->pcb_esi);
+  regcache->raw_supply (I386_EBP_REGNUM, &pcb->pcb_ebp);
+  regcache->raw_supply (I386_ESP_REGNUM, &pcb->pcb_esp);
+  regcache->raw_supply (I386_EBX_REGNUM, &pcb->pcb_ebx);
+  regcache->raw_supply (I386_EIP_REGNUM, &pcb->pcb_eip);
+  regcache->raw_supply (I386_GS_REGNUM, &pcb->pcb_gs);
 
   return 1;
 }
diff --git a/gdb/i386-gnu-nat.c b/gdb/i386-gnu-nat.c
index a738308e51b..1acfc078015 100644
--- a/gdb/i386-gnu-nat.c
+++ b/gdb/i386-gnu-nat.c
@@ -138,7 +138,7 @@ gnu_fetch_registers (struct target_ops *ops,
 	  proc_debug (thread, "fetching all register");
 
 	  for (i = 0; i < I386_NUM_GREGS; i++)
-	    regcache_raw_supply (regcache, i, REG_ADDR (state, i));
+	    regcache->raw_supply (i, REG_ADDR (state, i));
 	  thread->fetched_regs = ~0;
 	}
       else
@@ -147,8 +147,7 @@ gnu_fetch_registers (struct target_ops *ops,
 		      gdbarch_register_name (regcache->arch (),
 					     regno));
 
-	  regcache_raw_supply (regcache, regno,
-			       REG_ADDR (state, regno));
+	  regcache->raw_supply (regno, REG_ADDR (state, regno));
 	  thread->fetched_regs |= (1 << regno);
 	}
     }
@@ -250,8 +249,8 @@ gnu_store_registers (struct target_ops *ops,
 			 gdbarch_register_name (gdbarch, check_regno));
 		if (regno >= 0 && regno != check_regno)
 		  /* Update GDB's copy of the register.  */
-		  regcache_raw_supply (regcache, check_regno,
-				       REG_ADDR (state, check_regno));
+		  regcache->raw_supply (check_regno,
+					REG_ADDR (state, check_regno));
 		else
 		  warning (_("... also writing this register!  "
 			     "Suspicious..."));
diff --git a/gdb/i386-linux-nat.c b/gdb/i386-linux-nat.c
index 054638ba1f0..1d8483af217 100644
--- a/gdb/i386-linux-nat.c
+++ b/gdb/i386-linux-nat.c
@@ -112,7 +112,7 @@ fetch_register (struct regcache *regcache, int regno)
   gdb_assert (!have_ptrace_getregs);
   if (i386_linux_gregset_reg_offset[regno] == -1)
     {
-      regcache_raw_supply (regcache, regno, NULL);
+      regcache->raw_supply (regno, NULL);
       return;
     }
 
@@ -126,7 +126,7 @@ fetch_register (struct regcache *regcache, int regno)
 	   gdbarch_register_name (regcache->arch (), regno),
 	   regno, safe_strerror (errno));
 
-  regcache_raw_supply (regcache, regno, &val);
+  regcache->raw_supply (regno, &val);
 }
 
 /* Store one register.  */
@@ -167,13 +167,13 @@ supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
   int i;
 
   for (i = 0; i < I386_NUM_GREGS; i++)
-    regcache_raw_supply (regcache, i,
-			 regp + i386_linux_gregset_reg_offset[i]);
+    regcache->raw_supply (i, regp + i386_linux_gregset_reg_offset[i]);
 
   if (I386_LINUX_ORIG_EAX_REGNUM
 	< gdbarch_num_regs (regcache->arch ()))
-    regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
-			 + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
+    regcache->raw_supply
+      (I386_LINUX_ORIG_EAX_REGNUM,
+       regp + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
 }
 
 /* Fill register REGNO (if it is a general-purpose register) in
diff --git a/gdb/i386-nbsd-nat.c b/gdb/i386-nbsd-nat.c
index bc875e07cd5..dd1ac2944d2 100644
--- a/gdb/i386-nbsd-nat.c
+++ b/gdb/i386-nbsd-nat.c
@@ -61,12 +61,12 @@ i386nbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
 
   read_memory (pcb->pcb_esp, (gdb_byte *)&sf, sizeof sf);
   pcb->pcb_esp += sizeof (struct switchframe);
-  regcache_raw_supply (regcache, I386_EDI_REGNUM, &sf.sf_edi);
-  regcache_raw_supply (regcache, I386_ESI_REGNUM, &sf.sf_esi);
-  regcache_raw_supply (regcache, I386_EBP_REGNUM, &pcb->pcb_ebp);
-  regcache_raw_supply (regcache, I386_ESP_REGNUM, &pcb->pcb_esp);
-  regcache_raw_supply (regcache, I386_EBX_REGNUM, &sf.sf_ebx);
-  regcache_raw_supply (regcache, I386_EIP_REGNUM, &sf.sf_eip);
+  regcache->raw_supply (I386_EDI_REGNUM, &sf.sf_edi);
+  regcache->raw_supply (I386_ESI_REGNUM, &sf.sf_esi);
+  regcache->raw_supply (I386_EBP_REGNUM, &pcb->pcb_ebp);
+  regcache->raw_supply (I386_ESP_REGNUM, &pcb->pcb_esp);
+  regcache->raw_supply (I386_EBX_REGNUM, &sf.sf_ebx);
+  regcache->raw_supply (I386_EIP_REGNUM, &sf.sf_eip);
 
   return 1;
 }
diff --git a/gdb/i386-obsd-nat.c b/gdb/i386-obsd-nat.c
index a3221edc856..faae83e1d24 100644
--- a/gdb/i386-obsd-nat.c
+++ b/gdb/i386-obsd-nat.c
@@ -67,10 +67,10 @@ i386obsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
       /* Yes, we have a frame that matches cpu_switch().  */
       read_memory (pcb->pcb_esp, (gdb_byte *) &sf, sizeof sf);
       pcb->pcb_esp += sizeof (struct switchframe);
-      regcache_raw_supply (regcache, I386_EDI_REGNUM, &sf.sf_edi);
-      regcache_raw_supply (regcache, I386_ESI_REGNUM, &sf.sf_esi);
-      regcache_raw_supply (regcache, I386_EBX_REGNUM, &sf.sf_ebx);
-      regcache_raw_supply (regcache, I386_EIP_REGNUM, &sf.sf_eip);
+      regcache->raw_supply (I386_EDI_REGNUM, &sf.sf_edi);
+      regcache->raw_supply (I386_ESI_REGNUM, &sf.sf_esi);
+      regcache->raw_supply (I386_EBX_REGNUM, &sf.sf_ebx);
+      regcache->raw_supply (I386_EIP_REGNUM, &sf.sf_eip);
     }
   else
 #endif
@@ -79,11 +79,11 @@ i386obsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
       pcb->pcb_esp = pcb->pcb_ebp;
       pcb->pcb_ebp = read_memory_integer(pcb->pcb_esp, 4, byte_order);
       sf.sf_eip = read_memory_integer(pcb->pcb_esp + 4, 4, byte_order);
-      regcache_raw_supply (regcache, I386_EIP_REGNUM, &sf.sf_eip);
+      regcache->raw_supply (I386_EIP_REGNUM, &sf.sf_eip);
     }
 
-  regcache_raw_supply (regcache, I386_EBP_REGNUM, &pcb->pcb_ebp);
-  regcache_raw_supply (regcache, I386_ESP_REGNUM, &pcb->pcb_esp);
+  regcache->raw_supply (I386_EBP_REGNUM, &pcb->pcb_ebp);
+  regcache->raw_supply (I386_ESP_REGNUM, &pcb->pcb_esp);
 
   return 1;
 }
diff --git a/gdb/i386-obsd-tdep.c b/gdb/i386-obsd-tdep.c
index 1533ed21210..da2b88aadd0 100644
--- a/gdb/i386-obsd-tdep.c
+++ b/gdb/i386-obsd-tdep.c
@@ -210,7 +210,7 @@ i386obsd_supply_uthread (struct regcache *regcache,
          returned from _thread_machdep_switch.  */
       offset = i386obsd_uthread_reg_offset[I386_EIP_REGNUM] + 4;
       store_unsigned_integer (buf, 4, byte_order, sp + offset);
-      regcache_raw_supply (regcache, I386_ESP_REGNUM, buf);
+      regcache->raw_supply (I386_ESP_REGNUM, buf);
     }
 
   for (i = 0; i < ARRAY_SIZE (i386obsd_uthread_reg_offset); i++)
@@ -225,7 +225,7 @@ i386obsd_supply_uthread (struct regcache *regcache,
 
 	  /* Read the saved register from the stack frame.  */
 	  read_memory (sp + i386obsd_uthread_reg_offset[i], buf, 4);
-	  regcache_raw_supply (regcache, i, buf);
+	  regcache->raw_supply (i, buf);
 	}
     }
 }
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 158344f2309..f535cb386f0 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -3815,7 +3815,7 @@ i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
     {
       if ((regnum == i || regnum == -1)
 	  && tdep->gregset_reg_offset[i] != -1)
-	regcache_raw_supply (regcache, i, regs + tdep->gregset_reg_offset[i]);
+	regcache->raw_supply (i, regs + tdep->gregset_reg_offset[i]);
     }
 }
 
diff --git a/gdb/i386-v4-nat.c b/gdb/i386-v4-nat.c
index 36e07fa0b68..2313ff87fff 100644
--- a/gdb/i386-v4-nat.c
+++ b/gdb/i386-v4-nat.c
@@ -107,7 +107,7 @@ supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
   int regnum;
 
   for (regnum = 0; regnum < I386_NUM_GREGS; regnum++)
-    regcache_raw_supply (regcache, regnum, regp + regmap[regnum]);
+    regcache->raw_supply (regnum, regp + regmap[regnum]);
 }
 
 /* Fill register REGNUM (if it is a general-purpose register) in
diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index b465fda5afb..b545f74092c 100644
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -450,7 +450,7 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
       {
 	if (fsave == NULL)
 	  {
-	    regcache_raw_supply (regcache, i, NULL);
+	    regcache->raw_supply (i, NULL);
 	    continue;
 	  }
 
@@ -465,22 +465,22 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
 	    val[2] = val[3] = 0;
 	    if (i == I387_FOP_REGNUM (tdep))
 	      val[1] &= ((1 << 3) - 1);
-	    regcache_raw_supply (regcache, i, val);
+	    regcache->raw_supply (i, val);
 	  }
 	else
-	  regcache_raw_supply (regcache, i, FSAVE_ADDR (tdep, regs, i));
+	  regcache->raw_supply (i, FSAVE_ADDR (tdep, regs, i));
       }
 
   /* Provide dummy values for the SSE registers.  */
   for (i = I387_XMM0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)
     if (regnum == -1 || regnum == i)
-      regcache_raw_supply (regcache, i, NULL);
+      regcache->raw_supply (i, NULL);
   if (regnum == -1 || regnum == I387_MXCSR_REGNUM (tdep))
     {
       gdb_byte buf[4];
 
       store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
-      regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf);
+      regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
     }
 }
 
@@ -597,7 +597,7 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
       {
 	if (regs == NULL)
 	  {
-	    regcache_raw_supply (regcache, i, NULL);
+	    regcache->raw_supply (i, NULL);
 	    continue;
 	  }
 
@@ -644,18 +644,18 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
 		val[0] = ftag & 0xff;
 		val[1] = (ftag >> 8) & 0xff;
 	      }
-	    regcache_raw_supply (regcache, i, val);
+	    regcache->raw_supply (i, val);
 	  }
 	else
-	  regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+	  regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
       }
 
   if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
     {
       if (regs == NULL)
-	regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), NULL);
+	regcache->raw_supply (I387_MXCSR_REGNUM (tdep), NULL);
       else
-	regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),
+	regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
 			     FXSAVE_MXCSR_ADDR (regs));
     }
 }
@@ -996,74 +996,68 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 
     case pkeys:
       if ((clear_bv & X86_XSTATE_PKRU))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_PKEYS_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, XSAVE_PKEYS_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_zmm_h:
       if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum,
+			      XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_k:
       if ((clear_bv & X86_XSTATE_K))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_ymmh_avx512:
       if ((clear_bv & X86_XSTATE_ZMM))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum,
+			      XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_xmm_avx512:
       if ((clear_bv & X86_XSTATE_ZMM))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum,
+			      XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
       return;
 
     case avxh:
       if ((clear_bv & X86_XSTATE_AVX))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_AVXH_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, XSAVE_AVXH_ADDR (tdep, regs, regnum));
       return;
 
     case mpx:
       if ((clear_bv & X86_XSTATE_BNDREGS))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     XSAVE_MPX_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, XSAVE_MPX_ADDR (tdep, regs, regnum));
       return;
 
     case sse:
       if ((clear_bv & X86_XSTATE_SSE))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     FXSAVE_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
       return;
 
     case x87:
       if ((clear_bv & X86_XSTATE_X87))
-	regcache_raw_supply (regcache, regnum, zero);
+	regcache->raw_supply (regnum, zero);
       else
-	regcache_raw_supply (regcache, regnum,
-			     FXSAVE_ADDR (tdep, regs, regnum));
+	regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
       return;
 
     case all:
@@ -1075,15 +1069,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_PKRU_REGNUM (tdep);
 		   i < I387_PKEYSEND_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_PKRU_REGNUM (tdep);
 		   i < I387_PKEYSEND_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_PKEYS_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_PKEYS_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1095,15 +1088,15 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_ZMM0H_REGNUM (tdep);
 		   i < I387_ZMMENDH_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_ZMM0H_REGNUM (tdep);
 		   i < I387_ZMMENDH_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
+		regcache->raw_supply (i,
+				      XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1115,15 +1108,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_K0_REGNUM (tdep);
 		   i < I387_KEND_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_K0_REGNUM (tdep);
 		   i < I387_KEND_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_AVX512_K_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_AVX512_K_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1135,24 +1127,22 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_YMM16H_REGNUM (tdep);
 		   i < I387_YMMH_AVX512_END_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	      for (i = I387_XMM16_REGNUM (tdep);
 		   i < I387_XMM_AVX512_END_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_YMM16H_REGNUM (tdep);
 		   i < I387_YMMH_AVX512_END_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
 	      for (i = I387_XMM16_REGNUM (tdep);
 		   i < I387_XMM_AVX512_END_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
 	    }
 	}
       /* Handle the upper YMM registers.  */
@@ -1163,15 +1153,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_YMM0H_REGNUM (tdep);
 		   i < I387_YMMENDH_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_YMM0H_REGNUM (tdep);
 		   i < I387_YMMENDH_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_AVXH_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_AVXH_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1182,14 +1171,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	    {
 	      for (i = I387_BND0R_REGNUM (tdep);
 		   i < I387_BNDCFGU_REGNUM (tdep); i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_BND0R_REGNUM (tdep);
 		   i < I387_BNDCFGU_REGNUM (tdep); i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_MPX_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1200,14 +1188,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	    {
 	      for (i = I387_BNDCFGU_REGNUM (tdep);
 		   i < I387_MPXEND_REGNUM (tdep); i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_BNDCFGU_REGNUM (tdep);
 		   i < I387_MPXEND_REGNUM (tdep); i++)
-		regcache_raw_supply (regcache, i,
-				     XSAVE_MPX_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1219,14 +1206,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_XMM0_REGNUM (tdep);
 		   i < I387_MXCSR_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_XMM0_REGNUM (tdep);
 		   i < I387_MXCSR_REGNUM (tdep); i++)
-		regcache_raw_supply (regcache, i,
-				     FXSAVE_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
 	    }
 	}
 
@@ -1238,14 +1224,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	      for (i = I387_ST0_REGNUM (tdep);
 		   i < I387_FCTRL_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, zero);
+		regcache->raw_supply (i, zero);
 	    }
 	  else
 	    {
 	      for (i = I387_ST0_REGNUM (tdep);
 		   i < I387_FCTRL_REGNUM (tdep);
 		   i++)
-		regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+		regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
 	    }
 	}
       break;
@@ -1263,17 +1249,17 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 
 		store_unsigned_integer (buf, 4, byte_order,
 					I387_FCTRL_INIT_VAL);
-		regcache_raw_supply (regcache, i, buf);
+		regcache->raw_supply (i, buf);
 	      }
 	    else if (i == I387_FTAG_REGNUM (tdep))
 	      {
 		gdb_byte buf[4];
 
 		store_unsigned_integer (buf, 4, byte_order, 0xffff);
-		regcache_raw_supply (regcache, i, buf);
+		regcache->raw_supply (i, buf);
 	      }
 	    else
-	      regcache_raw_supply (regcache, i, zero);
+	      regcache->raw_supply (i, zero);
 	  }
 	/* Most of the FPU control registers occupy only 16 bits in
 	   the xsave extended state.  Give those a special treatment.  */
@@ -1318,10 +1304,10 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 		val[0] = ftag & 0xff;
 		val[1] = (ftag >> 8) & 0xff;
 	      }
-	    regcache_raw_supply (regcache, i, val);
+	    regcache->raw_supply (i, val);
 	  }
 	else
-	  regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+	  regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
       }
 
   if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
@@ -1334,11 +1320,11 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 	  gdb_byte buf[4];
 
 	  store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
-	  regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf);
+	  regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
 	}
       else
-	regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),
-			     FXSAVE_MXCSR_ADDR (regs));
+	regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
+			      FXSAVE_MXCSR_ADDR (regs));
     }
 }
 
diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c
index d095bde2ffb..98fd9538c7b 100644
--- a/gdb/ia64-linux-nat.c
+++ b/gdb/ia64-linux-nat.c
@@ -414,33 +414,32 @@ supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
-      regcache_raw_supply (regcache, regi, regp + (regi - IA64_GR0_REGNUM));
+      regcache->raw_supply (regi, regp + (regi - IA64_GR0_REGNUM));
     }
 
   /* FIXME: NAT collection bits are at index 32; gotta deal with these
      somehow...  */
 
-  regcache_raw_supply (regcache, IA64_PR_REGNUM, regp + 33);
+  regcache->raw_supply (IA64_PR_REGNUM, regp + 33);
 
   for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
     {
-      regcache_raw_supply (regcache, regi,
-			   regp + 34 + (regi - IA64_BR0_REGNUM));
+      regcache->raw_supply (regi, regp + 34 + (regi - IA64_BR0_REGNUM));
     }
 
-  regcache_raw_supply (regcache, IA64_IP_REGNUM, regp + 42);
-  regcache_raw_supply (regcache, IA64_CFM_REGNUM, regp + 43);
-  regcache_raw_supply (regcache, IA64_PSR_REGNUM, regp + 44);
-  regcache_raw_supply (regcache, IA64_RSC_REGNUM, regp + 45);
-  regcache_raw_supply (regcache, IA64_BSP_REGNUM, regp + 46);
-  regcache_raw_supply (regcache, IA64_BSPSTORE_REGNUM, regp + 47);
-  regcache_raw_supply (regcache, IA64_RNAT_REGNUM, regp + 48);
-  regcache_raw_supply (regcache, IA64_CCV_REGNUM, regp + 49);
-  regcache_raw_supply (regcache, IA64_UNAT_REGNUM, regp + 50);
-  regcache_raw_supply (regcache, IA64_FPSR_REGNUM, regp + 51);
-  regcache_raw_supply (regcache, IA64_PFS_REGNUM, regp + 52);
-  regcache_raw_supply (regcache, IA64_LC_REGNUM, regp + 53);
-  regcache_raw_supply (regcache, IA64_EC_REGNUM, regp + 54);
+  regcache->raw_supply (IA64_IP_REGNUM, regp + 42);
+  regcache->raw_supply (IA64_CFM_REGNUM, regp + 43);
+  regcache->raw_supply (IA64_PSR_REGNUM, regp + 44);
+  regcache->raw_supply (IA64_RSC_REGNUM, regp + 45);
+  regcache->raw_supply (IA64_BSP_REGNUM, regp + 46);
+  regcache->raw_supply (IA64_BSPSTORE_REGNUM, regp + 47);
+  regcache->raw_supply (IA64_RNAT_REGNUM, regp + 48);
+  regcache->raw_supply (IA64_CCV_REGNUM, regp + 49);
+  regcache->raw_supply (IA64_UNAT_REGNUM, regp + 50);
+  regcache->raw_supply (IA64_FPSR_REGNUM, regp + 51);
+  regcache->raw_supply (IA64_PFS_REGNUM, regp + 52);
+  regcache->raw_supply (IA64_LC_REGNUM, regp + 53);
+  regcache->raw_supply (IA64_EC_REGNUM, regp + 54);
 }
 
 void
@@ -500,14 +499,14 @@ supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
      for fr0/fr1 and always supply their expected values.  */
 
   /* fr0 is always read as zero.  */
-  regcache_raw_supply (regcache, IA64_FR0_REGNUM, f_zero);
+  regcache->raw_supply (IA64_FR0_REGNUM, f_zero);
   /* fr1 is always read as one (1.0).  */
-  regcache_raw_supply (regcache, IA64_FR1_REGNUM, f_one);
+  regcache->raw_supply (IA64_FR1_REGNUM, f_one);
 
   for (regi = IA64_FR2_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
     {
       from = (const char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
-      regcache_raw_supply (regcache, regi, from);
+      regcache->raw_supply (regi, from);
     }
 }
 
@@ -748,7 +747,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
       const gdb_byte zero[8] = { 0 };
 
       gdb_assert (sizeof (zero) == register_size (gdbarch, regnum));
-      regcache_raw_supply (regcache, regnum, zero);
+      regcache->raw_supply (regnum, zero);
       return;
     }
 
@@ -758,7 +757,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
       const gdb_byte f_zero[16] = { 0 };
 
       gdb_assert (sizeof (f_zero) == register_size (gdbarch, regnum));
-      regcache_raw_supply (regcache, regnum, f_zero);
+      regcache->raw_supply (regnum, f_zero);
       return;
     }
 
@@ -769,13 +768,13 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
 	{ 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
 
       gdb_assert (sizeof (f_one) == register_size (gdbarch, regnum));
-      regcache_raw_supply (regcache, regnum, f_one);
+      regcache->raw_supply (regnum, f_one);
       return;
     }
 
   if (ia64_cannot_fetch_register (gdbarch, regnum))
     {
-      regcache_raw_supply (regcache, regnum, NULL);
+      regcache->raw_supply (regnum, NULL);
       return;
     }
 
@@ -800,7 +799,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
 
       addr += sizeof (PTRACE_TYPE_RET);
     }
-  regcache_raw_supply (regcache, regnum, buf);
+  regcache->raw_supply (regnum, buf);
 }
 
 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
diff --git a/gdb/ia64-linux-tdep.c b/gdb/ia64-linux-tdep.c
index b1662f2ea38..19d0cf2debf 100644
--- a/gdb/ia64-linux-tdep.c
+++ b/gdb/ia64-linux-tdep.c
@@ -184,9 +184,9 @@ ia64_linux_supply_fpregset (const struct regset *regset,
      did the same.  So ignore whatever might be recorded in fpregset_t
      for fr0/fr1 and always supply their expected values.  */
   if (regnum == -1 || regnum == IA64_FR0_REGNUM)
-    regcache_raw_supply (regcache, IA64_FR0_REGNUM, f_zero);
+    regcache->raw_supply (IA64_FR0_REGNUM, f_zero);
   if (regnum == -1 || regnum == IA64_FR1_REGNUM)
-    regcache_raw_supply (regcache, IA64_FR1_REGNUM, f_one);
+    regcache->raw_supply (IA64_FR1_REGNUM, f_one);
 }
 
 static const struct regset ia64_linux_gregset =
diff --git a/gdb/linux-nat-trad.c b/gdb/linux-nat-trad.c
index ed75eeda82c..23abb0f7f84 100644
--- a/gdb/linux-nat-trad.c
+++ b/gdb/linux-nat-trad.c
@@ -41,7 +41,7 @@ linux_nat_trad_target::fetch_register (struct regcache *regcache, int regnum)
   if (addr == (CORE_ADDR)-1
       || gdbarch_cannot_fetch_register (gdbarch, regnum))
     {
-      regcache_raw_supply (regcache, regnum, NULL);
+      regcache->raw_supply (regnum, NULL);
       return;
     }
 
@@ -66,7 +66,7 @@ linux_nat_trad_target::fetch_register (struct regcache *regcache, int regnum)
 
       addr += sizeof (PTRACE_TYPE_RET);
     }
-  regcache_raw_supply (regcache, regnum, buf);
+  regcache->raw_supply (regnum, buf);
 }
 
 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
diff --git a/gdb/m32r-linux-nat.c b/gdb/m32r-linux-nat.c
index 9d833fa19ec..3c723575df4 100644
--- a/gdb/m32r-linux-nat.c
+++ b/gdb/m32r-linux-nat.c
@@ -101,11 +101,11 @@ supply_gregset (struct regcache *regcache, const elf_gregset_t * gregsetp)
 	}
 
       if (i != M32R_SP_REGNUM)
-	regcache_raw_supply (regcache, i, &regval);
+	regcache->raw_supply (i, &regval);
       else if (psw & 0x8000)
-	regcache_raw_supply (regcache, i, regp + SPU_REGMAP);
+	regcache->raw_supply (i, regp + SPU_REGMAP);
       else
-	regcache_raw_supply (regcache, i, regp + SPI_REGMAP);
+	regcache->raw_supply (i, regp + SPI_REGMAP);
     }
 }
 
diff --git a/gdb/m32r-linux-tdep.c b/gdb/m32r-linux-tdep.c
index 352a6f00f6c..56182180239 100644
--- a/gdb/m32r-linux-tdep.c
+++ b/gdb/m32r-linux-tdep.c
@@ -385,7 +385,7 @@ m32r_linux_supply_gregset (const struct regset *regset,
 	  p = regs + m32r_pt_regs_offset[i];
 	}
 
-      regcache_raw_supply (regcache, i, p);
+      regcache->raw_supply (i, p);
     }
 }
 
diff --git a/gdb/m68k-bsd-nat.c b/gdb/m68k-bsd-nat.c
index c44f736328e..8d2f5489374 100644
--- a/gdb/m68k-bsd-nat.c
+++ b/gdb/m68k-bsd-nat.c
@@ -58,7 +58,7 @@ m68kbsd_supply_gregset (struct regcache *regcache, const void *gregs)
   int regnum;
 
   for (regnum = M68K_D0_REGNUM; regnum <= M68K_PC_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + regnum * 4);
+    regcache->raw_supply (regnum, regs + regnum * 4);
 }
 
 /* Supply the floating-point registers stored in FPREGS to REGCACHE.  */
@@ -71,8 +71,8 @@ m68kbsd_supply_fpregset (struct regcache *regcache, const void *fpregs)
   int regnum;
 
   for (regnum = M68K_FP0_REGNUM; regnum <= M68K_FPI_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum,
-			 regs + m68kbsd_fpreg_offset (gdbarch, regnum));
+    regcache->raw_supply (regnum,
+			  regs + m68kbsd_fpreg_offset (gdbarch, regnum));
 }
 
 /* Collect the general-purpose registers from REGCACHE and store them
@@ -209,15 +209,15 @@ m68kbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   for (regnum = M68K_D2_REGNUM; regnum <= M68K_D7_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, &pcb->pcb_regs[i++]);
+    regcache->raw_supply (regnum, &pcb->pcb_regs[i++]);
   for (regnum = M68K_A2_REGNUM; regnum <= M68K_SP_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, &pcb->pcb_regs[i++]);
+    regcache->raw_supply (regnum, &pcb->pcb_regs[i++]);
 
   tmp = pcb->pcb_ps & 0xffff;
-  regcache_raw_supply (regcache, M68K_PS_REGNUM, &tmp);
+  regcache->raw_supply (M68K_PS_REGNUM, &tmp);
 
   read_memory (pcb->pcb_regs[PCB_REGS_FP] + 4, (char *) &tmp, sizeof tmp);
-  regcache_raw_supply (regcache, M68K_PC_REGNUM, &tmp);
+  regcache->raw_supply (M68K_PC_REGNUM, &tmp);
 
   return 1;
 }
diff --git a/gdb/m68k-bsd-tdep.c b/gdb/m68k-bsd-tdep.c
index 99c4d743fa6..2f53870b98d 100644
--- a/gdb/m68k-bsd-tdep.c
+++ b/gdb/m68k-bsd-tdep.c
@@ -67,8 +67,7 @@ m68kbsd_supply_fpregset (const struct regset *regset,
   for (i = M68K_FP0_REGNUM; i <= M68K_PC_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i,
-			     regs + m68kbsd_fpreg_offset (gdbarch, i));
+	regcache->raw_supply (i, regs + m68kbsd_fpreg_offset (gdbarch, i));
     }
 }
 
@@ -89,7 +88,7 @@ m68kbsd_supply_gregset (const struct regset *regset,
   for (i = M68K_D0_REGNUM; i <= M68K_PC_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * 4);
+	regcache->raw_supply (i, regs + i * 4);
     }
 
   if (len >= M68KBSD_SIZEOF_GREGS + M68KBSD_SIZEOF_FPREGS)
diff --git a/gdb/m68k-linux-nat.c b/gdb/m68k-linux-nat.c
index 409a4fd09d3..2dbf85735ba 100644
--- a/gdb/m68k-linux-nat.c
+++ b/gdb/m68k-linux-nat.c
@@ -133,7 +133,7 @@ fetch_register (struct regcache *regcache, int regno)
 	       gdbarch_register_name (gdbarch, regno),
 	       regno, safe_strerror (errno));
     }
-  regcache_raw_supply (regcache, regno, buf);
+  regcache->raw_supply (regno, buf);
 }
 
 /* Fetch register values from the inferior.
@@ -224,11 +224,9 @@ supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
   for (regi = M68K_D0_REGNUM;
        regi <= gdbarch_sp_regnum (gdbarch);
        regi++)
-    regcache_raw_supply (regcache, regi, &regp[regmap[regi]]);
-  regcache_raw_supply (regcache, gdbarch_ps_regnum (gdbarch),
-		       &regp[PT_SR]);
-  regcache_raw_supply (regcache,
-		       gdbarch_pc_regnum (gdbarch), &regp[PT_PC]);
+    regcache->raw_supply (regi, &regp[regmap[regi]]);
+  regcache->raw_supply (gdbarch_ps_regnum (gdbarch), &regp[PT_SR]);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), &regp[PT_PC]);
 }
 
 /* Fill register REGNO (if it is a general-purpose register) in
@@ -318,12 +316,11 @@ supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 
   for (regi = gdbarch_fp0_regnum (gdbarch);
        regi < gdbarch_fp0_regnum (gdbarch) + 8; regi++)
-    regcache_raw_supply (regcache, regi,
-			 FPREG_ADDR (fpregsetp,
-				     regi - gdbarch_fp0_regnum (gdbarch)));
-  regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
-  regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
-  regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
+    regcache->raw_supply
+      (regi, FPREG_ADDR (fpregsetp, regi - gdbarch_fp0_regnum (gdbarch)));
+  regcache->raw_supply (M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
+  regcache->raw_supply (M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
+  regcache->raw_supply (M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
 }
 
 /* Fill register REGNO (if it is a floating-point register) in
diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c
index 84cc4058dac..1dd97647731 100644
--- a/gdb/mips-linux-tdep.c
+++ b/gdb/mips-linux-tdep.c
@@ -282,9 +282,9 @@ supply_64bit_reg (struct regcache *regcache, int regnum,
   struct gdbarch *gdbarch = regcache->arch ();
   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
       && register_size (gdbarch, regnum) == 4)
-    regcache_raw_supply (regcache, regnum, buf + 4);
+    regcache->raw_supply (regnum, buf + 4);
   else
-    regcache_raw_supply (regcache, regnum, buf);
+    regcache->raw_supply (regnum, buf);
 }
 
 /* Unpack a 64-bit elf_gregset_t into GDB's register cache.  */
@@ -422,15 +422,12 @@ mips64_supply_fpregset (struct regcache *regcache,
 	  = (const gdb_byte *) (*fpregsetp + (regi & ~1));
 	if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
 	  reg_ptr += 4;
-	regcache_raw_supply (regcache,
-			     gdbarch_fp0_regnum (gdbarch) + regi,
-			     reg_ptr);
+	regcache->raw_supply (gdbarch_fp0_regnum (gdbarch) + regi, reg_ptr);
       }
   else
     for (regi = 0; regi < 32; regi++)
-      regcache_raw_supply (regcache,
-			   gdbarch_fp0_regnum (gdbarch) + regi,
-			   (const char *) (*fpregsetp + regi));
+      regcache->raw_supply (gdbarch_fp0_regnum (gdbarch) + regi,
+			    (const char *) (*fpregsetp + regi));
 
   supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
 		    (const gdb_byte *) (*fpregsetp + 32));
diff --git a/gdb/mips-nbsd-tdep.c b/gdb/mips-nbsd-tdep.c
index d805f0d77fa..5a14b2f1ff5 100644
--- a/gdb/mips-nbsd-tdep.c
+++ b/gdb/mips-nbsd-tdep.c
@@ -64,8 +64,7 @@ mipsnbsd_supply_fpregset (const struct regset *regset,
   for (i = MIPS_FP0_REGNUM; i <= MIPS_FSR_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i,
-			     regs + (i - MIPS_FP0_REGNUM) * regsize);
+	regcache->raw_supply (i, regs + (i - MIPS_FP0_REGNUM) * regsize);
     }
 }
 
@@ -87,7 +86,7 @@ mipsnbsd_supply_gregset (const struct regset *regset,
   for (i = 0; i <= MIPS_PC_REGNUM; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * regsize);
+	regcache->raw_supply (i, regs + i * regsize);
     }
 
   if (len >= (MIPSNBSD_NUM_GREGS + MIPSNBSD_NUM_FPREGS) * regsize)
@@ -145,10 +144,10 @@ mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
       if (regno == i || regno == -1)
 	{
 	  if (gdbarch_cannot_fetch_register (gdbarch, i))
-	    regcache_raw_supply (regcache, i, NULL);
+	    regcache->raw_supply (i, NULL);
 	  else
-            regcache_raw_supply (regcache, i,
-				 regs + (i * mips_isa_regsize (gdbarch)));
+            regcache->raw_supply
+	      (i, regs + (i * mips_isa_regsize (gdbarch)));
         }
     }
 }
@@ -180,10 +179,10 @@ mipsnbsd_supply_fpreg (struct regcache *regcache,
       if (regno == i || regno == -1)
 	{
 	  if (gdbarch_cannot_fetch_register (gdbarch, i))
-	    regcache_raw_supply (regcache, i, NULL);
+	    regcache->raw_supply (i, NULL);
 	  else
-            regcache_raw_supply (regcache, i,
-				 fpregs 
+            regcache->raw_supply (i,
+				 fpregs
 				 + ((i - gdbarch_fp0_regnum (gdbarch))
 				    * mips_isa_regsize (gdbarch)));
 	}
diff --git a/gdb/mips64-obsd-nat.c b/gdb/mips64-obsd-nat.c
index 27e1ab6750a..9c306dda3d1 100644
--- a/gdb/mips64-obsd-nat.c
+++ b/gdb/mips64-obsd-nat.c
@@ -52,10 +52,10 @@ mips64obsd_supply_gregset (struct regcache *regcache, const void *gregs)
   int regnum;
 
   for (regnum = MIPS_ZERO_REGNUM; regnum <= MIPS_PC_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + regnum * 8);
+    regcache->raw_supply (regnum, regs + regnum * 8);
 
   for (regnum = MIPS_FP0_REGNUM; regnum <= MIPS_FSR_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + (regnum + 2) * 8);
+    regcache->raw_supply (regnum, regs + (regnum + 2) * 8);
 }
 
 /* Collect the general-purpose registers from REGCACHE and store them
diff --git a/gdb/mips64-obsd-tdep.c b/gdb/mips64-obsd-tdep.c
index ef706e3bbc7..ab910edfc4c 100644
--- a/gdb/mips64-obsd-tdep.c
+++ b/gdb/mips64-obsd-tdep.c
@@ -52,7 +52,7 @@ mips64obsd_supply_gregset (const struct regset *regset,
   for (i = 0; i < MIPS64OBSD_NUM_REGS; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * 8);
+	regcache->raw_supply (i, regs + i * 8);
     }
 }
 
diff --git a/gdb/mn10300-linux-tdep.c b/gdb/mn10300-linux-tdep.c
index 32f34cede6b..a79f1f2de61 100644
--- a/gdb/mn10300-linux-tdep.c
+++ b/gdb/mn10300-linux-tdep.c
@@ -93,96 +93,96 @@ am33_supply_gregset_method (const struct regset *regset,
 
   switch (regnum) {
   case E_D0_REGNUM:
-    regcache_raw_supply (regcache, E_D0_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
+    regcache->raw_supply (E_D0_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
     break;
   case E_D1_REGNUM:
-    regcache_raw_supply (regcache, E_D1_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
+    regcache->raw_supply (E_D1_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
     break;
   case E_D2_REGNUM:
-    regcache_raw_supply (regcache, E_D2_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
+    regcache->raw_supply (E_D2_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
     break;
   case E_D3_REGNUM:
-    regcache_raw_supply (regcache, E_D3_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
+    regcache->raw_supply (E_D3_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
     break;
   case E_A0_REGNUM:
-    regcache_raw_supply (regcache, E_A0_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
+    regcache->raw_supply (E_A0_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
     break;
   case E_A1_REGNUM:
-    regcache_raw_supply (regcache, E_A1_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
+    regcache->raw_supply (E_A1_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
     break;
   case E_A2_REGNUM:
-    regcache_raw_supply (regcache, E_A2_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
+    regcache->raw_supply (E_A2_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
     break;
   case E_A3_REGNUM:
-    regcache_raw_supply (regcache, E_A3_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
+    regcache->raw_supply (E_A3_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
     break;
   case E_SP_REGNUM:
-    regcache_raw_supply (regcache, E_SP_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
+    regcache->raw_supply (E_SP_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
     break;
   case E_PC_REGNUM:
-    regcache_raw_supply (regcache, E_PC_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
+    regcache->raw_supply (E_PC_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
     break;
   case E_MDR_REGNUM:
-    regcache_raw_supply (regcache, E_MDR_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
+    regcache->raw_supply (E_MDR_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
     break;
   case E_PSW_REGNUM:
-    regcache_raw_supply (regcache, E_PSW_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
+    regcache->raw_supply (E_PSW_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
     break;
   case E_LIR_REGNUM:
-    regcache_raw_supply (regcache, E_LIR_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
+    regcache->raw_supply (E_LIR_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
     break;
   case E_LAR_REGNUM:
-    regcache_raw_supply (regcache, E_LAR_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
+    regcache->raw_supply (E_LAR_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
     break;
   case E_MDRQ_REGNUM:
-    regcache_raw_supply (regcache, E_MDRQ_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
+    regcache->raw_supply (E_MDRQ_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
     break;
   case E_E0_REGNUM:
-    regcache_raw_supply (regcache, E_E0_REGNUM,   
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
+    regcache->raw_supply (E_E0_REGNUM,   
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
     break;
   case E_E1_REGNUM:
-    regcache_raw_supply (regcache, E_E1_REGNUM,
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
+    regcache->raw_supply (E_E1_REGNUM,
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
     break;
   case E_E2_REGNUM:
-    regcache_raw_supply (regcache, E_E2_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
+    regcache->raw_supply (E_E2_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
     break;
   case E_E3_REGNUM:
-    regcache_raw_supply (regcache, E_E3_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
+    regcache->raw_supply (E_E3_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
     break;
   case E_E4_REGNUM:
-    regcache_raw_supply (regcache, E_E4_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
+    regcache->raw_supply (E_E4_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
     break;
   case E_E5_REGNUM:
-    regcache_raw_supply (regcache, E_E5_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
+    regcache->raw_supply (E_E5_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
     break;
   case E_E6_REGNUM:
-    regcache_raw_supply (regcache, E_E6_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
+    regcache->raw_supply (E_E6_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
     break;
   case E_E7_REGNUM:
-    regcache_raw_supply (regcache, E_E7_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
+    regcache->raw_supply (E_E7_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
     break;
 
     /* ssp, msp, and usp are inaccessible.  */
@@ -196,16 +196,16 @@ am33_supply_gregset_method (const struct regset *regset,
     regcache->raw_supply_zeroed (E_E10_REGNUM);
     break;
   case E_MCRH_REGNUM:
-    regcache_raw_supply (regcache, E_MCRH_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
+    regcache->raw_supply (E_MCRH_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
     break;
   case E_MCRL_REGNUM:
-    regcache_raw_supply (regcache, E_MCRL_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
+    regcache->raw_supply (E_MCRL_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
     break;
   case E_MCVF_REGNUM:
-    regcache_raw_supply (regcache, E_MCVF_REGNUM, 
-			 (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
+    regcache->raw_supply (E_MCVF_REGNUM, 
+			  (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
     break;
   case E_FPCR_REGNUM:
     /* FPCR is numbered among the GP regs, but handled as an FP reg.
@@ -252,12 +252,10 @@ am33_supply_fpregset_method (const struct regset *regset,
 				   E_FPCR_REGNUM, fpregs, len);
     }
   else if (regnum == E_FPCR_REGNUM)
-    regcache_raw_supply (regcache, E_FPCR_REGNUM, 
-			 &fpregset->fpcr);
+    regcache->raw_supply (E_FPCR_REGNUM, &fpregset->fpcr);
   else if (E_FS0_REGNUM <= regnum
 	   && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
-    regcache_raw_supply (regcache, regnum, 
-			 &fpregset->fpregs[regnum - E_FS0_REGNUM]);
+    regcache->raw_supply (regnum, &fpregset->fpregs[regnum - E_FS0_REGNUM]);
 
   return;
 }
diff --git a/gdb/nios2-linux-tdep.c b/gdb/nios2-linux-tdep.c
index 005c82a4b37..7ee6f144f37 100644
--- a/gdb/nios2-linux-tdep.c
+++ b/gdb/nios2-linux-tdep.c
@@ -67,10 +67,9 @@ nios2_supply_gregset (const struct regset *regset,
     if (regnum == -1 || regnum == regno)
       {
 	if (reg_offsets[regno] != -1)
-	  regcache_raw_supply (regcache, regno,
-			       gregs + 4 * reg_offsets[regno]);
+	  regcache->raw_supply (regno, gregs + 4 * reg_offsets[regno]);
 	else
-	  regcache_raw_supply (regcache, regno, zero_buf);
+	  regcache->raw_supply (regno, zero_buf);
       }
 }
 
diff --git a/gdb/ppc-fbsd-nat.c b/gdb/ppc-fbsd-nat.c
index 89a7e6eb5c2..44661e9a248 100644
--- a/gdb/ppc-fbsd-nat.c
+++ b/gdb/ppc-fbsd-nat.c
@@ -192,11 +192,11 @@ ppcfbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
   if (pcb->pcb_sp == 0)
     return 0;
 
-  regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), &pcb->pcb_sp);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, &pcb->pcb_cr);
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, &pcb->pcb_lr);
+  regcache->raw_supply (gdbarch_sp_regnum (gdbarch), &pcb->pcb_sp);
+  regcache->raw_supply (tdep->ppc_cr_regnum, &pcb->pcb_cr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, &pcb->pcb_lr);
   for (i = 0, regnum = tdep->ppc_gp0_regnum + 14; i < 20; i++, regnum++)
-    regcache_raw_supply (regcache, regnum, &pcb->pcb_context[i]);
+    regcache->raw_supply (regnum, &pcb->pcb_context[i]);
 
   return 1;
 }
diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index 7606081f22a..7f209f4955f 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -512,22 +512,20 @@ fetch_spe_register (struct regcache *regcache, int tid, int regno)
       int i;
 
       for (i = 0; i < ppc_num_gprs; i++)
-        regcache_raw_supply (regcache, tdep->ppc_ev0_upper_regnum + i,
-                             &evrregs.evr[i]);
+        regcache->raw_supply (tdep->ppc_ev0_upper_regnum + i, &evrregs.evr[i]);
     }
   else if (tdep->ppc_ev0_upper_regnum <= regno
            && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
-    regcache_raw_supply (regcache, regno,
-                         &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
+    regcache->raw_supply (regno,
+			  &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
 
   if (regno == -1
       || regno == tdep->ppc_acc_regnum)
-    regcache_raw_supply (regcache, tdep->ppc_acc_regnum, &evrregs.acc);
+    regcache->raw_supply (tdep->ppc_acc_regnum, &evrregs.acc);
 
   if (regno == -1
       || regno == tdep->ppc_spefscr_regnum)
-    regcache_raw_supply (regcache, tdep->ppc_spefscr_regnum,
-                         &evrregs.spefscr);
+    regcache->raw_supply (tdep->ppc_spefscr_regnum, &evrregs.spefscr);
 }
 
 static void
@@ -573,7 +571,7 @@ fetch_register (struct regcache *regcache, int tid, int regno)
   if (regaddr == -1)
     {
       memset (buf, '\0', register_size (gdbarch, regno));   /* Supply zeroes */
-      regcache_raw_supply (regcache, regno, buf);
+      regcache->raw_supply (regno, buf);
       return;
     }
 
@@ -606,14 +604,14 @@ fetch_register (struct regcache *regcache, int tid, int regno)
     {
       /* Little-endian values are always found at the left end of the
          bytes transferred.  */
-      regcache_raw_supply (regcache, regno, buf);
+      regcache->raw_supply (regno, buf);
     }
   else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
     {
       /* Big-endian values are found at the right end of the bytes
          transferred.  */
       size_t padding = (bytes_transferred - register_size (gdbarch, regno));
-      regcache_raw_supply (regcache, regno, buf + padding);
+      regcache->raw_supply (regno, buf + padding);
     }
   else 
     internal_error (__FILE__, __LINE__,
diff --git a/gdb/ppc-nbsd-nat.c b/gdb/ppc-nbsd-nat.c
index 037b261331f..ea163f34d09 100644
--- a/gdb/ppc-nbsd-nat.c
+++ b/gdb/ppc-nbsd-nat.c
@@ -162,20 +162,19 @@ ppcnbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   read_memory (pcb->pcb_sp, (gdb_byte *)&sf, sizeof sf);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, &sf.cr);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 2, &sf.fixreg2);
+  regcache->raw_supply (tdep->ppc_cr_regnum, &sf.cr);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 2, &sf.fixreg2);
   for (i = 0 ; i < 19 ; i++)
-    regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 13 + i,
-			 &sf.fixreg[i]);
+    regcache->raw_supply (tdep->ppc_gp0_regnum + 13 + i, &sf.fixreg[i]);
 
   read_memory(sf.sp, (gdb_byte *)&cf, sizeof(cf));
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 30, &cf.r30);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 31, &cf.r31);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 1, &cf.sp);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 30, &cf.r30);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 31, &cf.r31);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 1, &cf.sp);
 
   read_memory(cf.sp, (gdb_byte *)&cf, sizeof(cf));
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, &cf.lr);
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), &cf.lr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, &cf.lr);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), &cf.lr);
 
   return 1;
 }
diff --git a/gdb/ppc-obsd-nat.c b/gdb/ppc-obsd-nat.c
index 88ba0c5c736..ee71b7421c2 100644
--- a/gdb/ppc-obsd-nat.c
+++ b/gdb/ppc-obsd-nat.c
@@ -173,16 +173,16 @@ ppcobsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   read_memory (pcb->pcb_sp, (gdb_byte *)&sf, sizeof sf);
-  regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), &sf.sp);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, &sf.cr);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 2, &sf.fixreg2);
+  regcache->raw_supply (gdbarch_sp_regnum (gdbarch), &sf.sp);
+  regcache->raw_supply (tdep->ppc_cr_regnum, &sf.cr);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 2, &sf.fixreg2);
   for (i = 0, regnum = tdep->ppc_gp0_regnum + 13; i < 19; i++, regnum++)
-    regcache_raw_supply (regcache, regnum, &sf.fixreg[i]);
+    regcache->raw_supply (regnum, &sf.fixreg[i]);
 
   read_memory (sf.sp, (gdb_byte *)&cf, sizeof cf);
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), &cf.lr);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 30, &cf.r30);
-  regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 31, &cf.r31);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), &cf.lr);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 30, &cf.r30);
+  regcache->raw_supply (tdep->ppc_gp0_regnum + 31, &cf.r31);
 
   return 1;
 }
diff --git a/gdb/ppc-ravenscar-thread.c b/gdb/ppc-ravenscar-thread.c
index 38f2667ba3f..ae5ad24579f 100644
--- a/gdb/ppc-ravenscar-thread.c
+++ b/gdb/ppc-ravenscar-thread.c
@@ -125,7 +125,7 @@ supply_register_at_address (struct regcache *regcache, int regnum,
 
   buf = (gdb_byte *) alloca (buf_size);
   read_memory (register_addr, buf, buf_size);
-  regcache_raw_supply (regcache, regnum, buf);
+  regcache->raw_supply (regnum, buf);
 }
 
 /* Return true if, for a non-running thread, REGNUM has been saved on the
diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index 35c8421525f..47a31b74ae7 100644
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -1558,7 +1558,7 @@ record_btrace_target::fetch_registers (struct regcache *regcache, int regno)
       insn = btrace_insn_get (replay);
       gdb_assert (insn != NULL);
 
-      regcache_raw_supply (regcache, regno, &insn->pc);
+      regcache->raw_supply (regno, &insn->pc);
     }
   else
     this->beneath->fetch_registers (regcache, regno);
diff --git a/gdb/regcache.c b/gdb/regcache.c
index 758f21c0898..8d47fdac532 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -879,15 +879,6 @@ regcache::cooked_write_part (int regnum, int offset, int len,
   write_part (regnum, offset, len, buf, false);
 }
 
-/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
-
-void
-regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
-{
-  gdb_assert (regcache != NULL);
-  regcache->raw_supply (regnum, buf);
-}
-
 void
 detached_regcache::raw_supply (int regnum, const void *buf)
 {
diff --git a/gdb/regcache.h b/gdb/regcache.h
index 064930c6394..b60f0316838 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -71,8 +71,6 @@ extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
    target.  These functions are called by the target in response to a
    target_fetch_registers() or target_store_registers().  */
 
-extern void regcache_raw_supply (struct regcache *regcache,
-				 int regnum, const void *buf);
 extern void regcache_raw_collect (const struct regcache *regcache,
 				  int regnum, void *buf);
 
@@ -243,6 +241,7 @@ public:
     : readable_regcache (gdbarch, has_pseudo)
   {}
 
+  /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
   void raw_supply (int regnum, const void *buf);
 
   void raw_supply (int regnum, const reg_buffer &src)
diff --git a/gdb/remote.c b/gdb/remote.c
index 3aca5fb2901..3f0b6783eb4 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -7786,7 +7786,7 @@ remote_target::process_stop_reply (struct stop_reply *stop_reply,
 	       VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg);
 	       ix++)
 	  {
-	    regcache_raw_supply (regcache, reg->num, reg->data);
+	    regcache->raw_supply (reg->num, reg->data);
 	    xfree (reg->data);
 	  }
 
@@ -8080,7 +8080,7 @@ remote_target::fetch_register_using_p (struct regcache *regcache,
   /* If this register is unfetchable, tell the regcache.  */
   if (buf[0] == 'x')
     {
-      regcache_raw_supply (regcache, reg->regnum, NULL);
+      regcache->raw_supply (reg->regnum, NULL);
       return 1;
     }
 
@@ -8095,7 +8095,7 @@ remote_target::fetch_register_using_p (struct regcache *regcache,
       regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
       p += 2;
     }
-  regcache_raw_supply (regcache, reg->regnum, regp);
+  regcache->raw_supply (reg->regnum, regp);
   return 1;
 }
 
@@ -8233,11 +8233,10 @@ remote_target::process_g_packet (struct regcache *regcache)
 	      gdb_assert (r->offset * 2 < strlen (rs->buf));
 	      /* The register isn't available, mark it as such (at
 		 the same time setting the value to zero).  */
-	      regcache_raw_supply (regcache, r->regnum, NULL);
+	      regcache->raw_supply (r->regnum, NULL);
 	    }
 	  else
-	    regcache_raw_supply (regcache, r->regnum,
-				 regs + r->offset);
+	    regcache->raw_supply (r->regnum, regs + r->offset);
 	}
     }
 }
@@ -8304,7 +8303,7 @@ remote_target::fetch_registers (struct regcache *regcache, int regnum)
 	return;
 
       /* This register is not available.  */
-      regcache_raw_supply (regcache, reg->regnum, NULL);
+      regcache->raw_supply (reg->regnum, NULL);
 
       return;
     }
@@ -8316,7 +8315,7 @@ remote_target::fetch_registers (struct regcache *regcache, int regnum)
       if (!fetch_register_using_p (regcache, &rsa->regs[i]))
 	{
 	  /* This register is not available.  */
-	  regcache_raw_supply (regcache, i, NULL);
+	  regcache->raw_supply (i, NULL);
 	}
 }
 
diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 689d8e815c6..7e39d57febf 100644
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -231,7 +231,7 @@ fetch_register (struct regcache *regcache, int regno)
     }
 
   if (!errno)
-    regcache_raw_supply (regcache, regno, (char *) addr);
+    regcache->raw_supply (regno, (char *) addr);
   else
     {
 #if 0
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 2523ff60761..e165d1b06e7 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -389,7 +389,7 @@ ppc_supply_reg (struct regcache *regcache, int regnum,
 	      && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	    offset += regsize - gdb_regsize;
 	}
-      regcache_raw_supply (regcache, regnum, regs + offset);
+      regcache->raw_supply (regnum, regs + offset);
     }
 }
 
diff --git a/gdb/s390-linux-nat.c b/gdb/s390-linux-nat.c
index abb06a9901b..303cbeeba89 100644
--- a/gdb/s390-linux-nat.c
+++ b/gdb/s390-linux-nat.c
@@ -170,10 +170,10 @@ supply_gregset (struct regcache *regcache, const gregset_t *regp)
       pswa = extract_unsigned_integer ((const gdb_byte *) regp
 				       + S390_PSWA_OFFSET, 8, byte_order);
       store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000);
-      regcache_raw_supply (regcache, S390_PSWM_REGNUM, buf);
+      regcache->raw_supply (S390_PSWM_REGNUM, buf);
       store_unsigned_integer (buf, 4, byte_order,
 			      (pswa & 0x7fffffff) | (pswm & 0x80000000));
-      regcache_raw_supply (regcache, S390_PSWA_REGNUM, buf);
+      regcache->raw_supply (S390_PSWA_REGNUM, buf);
       return;
     }
 #endif
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index a3a3cb6c6c8..e4e08c706a1 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -1074,10 +1074,10 @@ s390_guess_tracepoint_registers (struct gdbarch *gdbarch,
     }
 
   store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswa);
-  regcache_raw_supply (regcache, S390_PSWA_REGNUM, reg);
+  regcache->raw_supply (S390_PSWA_REGNUM, reg);
 
   store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswm);
-  regcache_raw_supply (regcache, S390_PSWM_REGNUM, reg);
+  regcache->raw_supply (S390_PSWM_REGNUM, reg);
 }
 
 /* Return the name of register REGNO.  Return the empty string for
diff --git a/gdb/score-tdep.c b/gdb/score-tdep.c
index e764c659f0d..16bf00ea024 100644
--- a/gdb/score-tdep.c
+++ b/gdb/score-tdep.c
@@ -1428,9 +1428,8 @@ score7_linux_supply_gregset(const struct regset *regset,
      collect function will store the PC in that slot.  */
   if ((regnum == -1 || regnum == SCORE_EPC_REGNUM)
       && size >= SCORE7_LINUX_EPC_OFFSET + 4)
-    regcache_raw_supply (regcache, SCORE_EPC_REGNUM,
-			 (const gdb_byte *) buf
-			 + SCORE7_LINUX_EPC_OFFSET);
+    regcache->raw_supply
+      (SCORE_EPC_REGNUM, (const gdb_byte *) buf + SCORE7_LINUX_EPC_OFFSET);
 }
 
 static const struct regset score7_linux_gregset =
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index 97e4a75ed70..5e9fd093649 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -2175,8 +2175,8 @@ sh_corefile_supply_regset (const struct regset *regset,
     {
       if ((regnum == -1 || regnum == regmap[i].regnum)
 	  && regmap[i].offset + 4 <= len)
-	regcache_raw_supply (regcache, regmap[i].regnum,
-			     (char *)regs + regmap[i].offset);
+	regcache->raw_supply
+	  (regmap[i].regnum, (char *) regs + regmap[i].offset);
     }
 }
 
diff --git a/gdb/sparc-nat.c b/gdb/sparc-nat.c
index 86a6b5a20a9..c133a3e82cf 100644
--- a/gdb/sparc-nat.c
+++ b/gdb/sparc-nat.c
@@ -158,7 +158,7 @@ sparc_fetch_inferior_registers (struct regcache *regcache, int regnum)
     {
       gdb_byte zero[8] = { 0 };
 
-      regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
+      regcache->raw_supply (SPARC_G0_REGNUM, &zero);
       return;
     }
 
diff --git a/gdb/sparc-nbsd-nat.c b/gdb/sparc-nbsd-nat.c
index e1ed44202cd..c8ed1298eb9 100644
--- a/gdb/sparc-nbsd-nat.c
+++ b/gdb/sparc-nbsd-nat.c
@@ -44,11 +44,11 @@ sparc32nbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
   if (pcb->pcb_sp == 0)
     return 0;
 
-  regcache_raw_supply (regcache, SPARC_SP_REGNUM, &pcb->pcb_sp);
-  regcache_raw_supply (regcache, SPARC_O7_REGNUM, &pcb->pcb_pc);
-  regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, &pcb->pcb_psr);
-  regcache_raw_supply (regcache, SPARC32_WIM_REGNUM, &pcb->pcb_wim);
-  regcache_raw_supply (regcache, SPARC32_PC_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC_SP_REGNUM, &pcb->pcb_sp);
+  regcache->raw_supply (SPARC_O7_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC32_PSR_REGNUM, &pcb->pcb_psr);
+  regcache->raw_supply (SPARC32_WIM_REGNUM, &pcb->pcb_wim);
+  regcache->raw_supply (SPARC32_PC_REGNUM, &pcb->pcb_pc);
 
   sparc_supply_rwindow (regcache, pcb->pcb_sp, -1);
 
diff --git a/gdb/sparc-obsd-tdep.c b/gdb/sparc-obsd-tdep.c
index 3ef2fb9a5fe..c8215623c03 100644
--- a/gdb/sparc-obsd-tdep.c
+++ b/gdb/sparc-obsd-tdep.c
@@ -163,7 +163,7 @@ sparc32obsd_supply_uthread (struct regcache *regcache,
   if (regnum == SPARC_SP_REGNUM || regnum == -1)
     {
       store_unsigned_integer (buf, 4, byte_order, fp);
-      regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
+      regcache->raw_supply (SPARC_SP_REGNUM, buf);
 
       if (regnum == SPARC_SP_REGNUM)
 	return;
@@ -178,12 +178,12 @@ sparc32obsd_supply_uthread (struct regcache *regcache,
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
 	{
 	  store_unsigned_integer (buf, 4, byte_order, i7 + 8);
-	  regcache_raw_supply (regcache, SPARC32_PC_REGNUM, buf);
+	  regcache->raw_supply (SPARC32_PC_REGNUM, buf);
 	}
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
 	{
 	  store_unsigned_integer (buf, 4, byte_order, i7 + 12);
-	  regcache_raw_supply (regcache, SPARC32_NPC_REGNUM, buf);
+	  regcache->raw_supply (SPARC32_NPC_REGNUM, buf);
 	}
 
       if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
diff --git a/gdb/sparc-ravenscar-thread.c b/gdb/sparc-ravenscar-thread.c
index 1cd1915a93c..129b4b61145 100644
--- a/gdb/sparc-ravenscar-thread.c
+++ b/gdb/sparc-ravenscar-thread.c
@@ -68,7 +68,7 @@ supply_register_at_address (struct regcache *regcache, int regnum,
 
   buf = (gdb_byte *) alloca (buf_size);
   read_memory (register_addr, buf, buf_size);
-  regcache_raw_supply (regcache, regnum, buf);
+  regcache->raw_supply (regnum, buf);
 }
 
 /* Return true if, for a non-running thread, REGNUM has been saved on the
diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 40d213f6d9d..ad0d2b49612 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -1970,7 +1970,7 @@ sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
 					  i7 ^ wcookie);
 		}
 
-	      regcache_raw_supply (regcache, i, buf);
+	      regcache->raw_supply (i, buf);
 	    }
 	}
     }
@@ -2006,7 +2006,7 @@ sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
 					  i7 ^ wcookie);
 		}
 
-	      regcache_raw_supply (regcache, i, buf);
+	      regcache->raw_supply (i, buf);
 	    }
 	}
     }
@@ -2093,23 +2093,19 @@ sparc32_supply_gregset (const struct sparc_gregmap *gregmap,
   int i;
 
   if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC32_PSR_REGNUM,
-			 regs + gregmap->r_psr_offset);
+    regcache->raw_supply (SPARC32_PSR_REGNUM, regs + gregmap->r_psr_offset);
 
   if (regnum == SPARC32_PC_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
-			 regs + gregmap->r_pc_offset);
+    regcache->raw_supply (SPARC32_PC_REGNUM, regs + gregmap->r_pc_offset);
 
   if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
-			 regs + gregmap->r_npc_offset);
+    regcache->raw_supply (SPARC32_NPC_REGNUM, regs + gregmap->r_npc_offset);
 
   if (regnum == SPARC32_Y_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC32_Y_REGNUM,
-			 regs + gregmap->r_y_offset);
+    regcache->raw_supply (SPARC32_Y_REGNUM, regs + gregmap->r_y_offset);
 
   if (regnum == SPARC_G0_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
+    regcache->raw_supply (SPARC_G0_REGNUM, &zero);
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
     {
@@ -2118,7 +2114,7 @@ sparc32_supply_gregset (const struct sparc_gregmap *gregmap,
       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
 	{
 	  if (regnum == i || regnum == -1)
-	    regcache_raw_supply (regcache, i, regs + offset);
+	    regcache->raw_supply (i, regs + offset);
 	  offset += 4;
 	}
     }
@@ -2141,7 +2137,7 @@ sparc32_supply_gregset (const struct sparc_gregmap *gregmap,
 	  for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
 	    {
 	      if (regnum == i || regnum == -1)
-		regcache_raw_supply (regcache, i, regs + offset);
+		regcache->raw_supply (i, regs + offset);
 	      offset += 4;
 	    }
 	}
@@ -2214,13 +2210,12 @@ sparc32_supply_fpregset (const struct sparc_fpregmap *fpregmap,
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
-	regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
-			     regs + fpregmap->r_f0_offset + (i * 4));
+	regcache->raw_supply (SPARC_F0_REGNUM + i,
+			      regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
-			 regs + fpregmap->r_fsr_offset);
+    regcache->raw_supply (SPARC32_FSR_REGNUM, regs + fpregmap->r_fsr_offset);
 }
 
 void
diff --git a/gdb/sparc64-fbsd-nat.c b/gdb/sparc64-fbsd-nat.c
index 20c6a28d18f..4be8cdefaa6 100644
--- a/gdb/sparc64-fbsd-nat.c
+++ b/gdb/sparc64-fbsd-nat.c
@@ -46,12 +46,12 @@ sparc64fbsd_kvm_supply_pcb (struct regcache *regcache, struct pcb *pcb)
   if (pcb->pcb_sp == 0)
     return 0;
 
-  regcache_raw_supply (regcache, SPARC_SP_REGNUM, &pcb->pcb_sp);
-  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC_SP_REGNUM, &pcb->pcb_sp);
+  regcache->raw_supply (SPARC64_PC_REGNUM, &pcb->pcb_pc);
 
   /* Synthesize %npc.  */
   pcb->pcb_pc += 4;
-  regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC64_NPC_REGNUM, &pcb->pcb_pc);
 
   /* Read `local' and `in' registers from the stack.  */
   sparc_supply_rwindow (regcache, pcb->pcb_sp, -1);
diff --git a/gdb/sparc64-nbsd-nat.c b/gdb/sparc64-nbsd-nat.c
index ac760b341d0..cb8643ae7da 100644
--- a/gdb/sparc64-nbsd-nat.c
+++ b/gdb/sparc64-nbsd-nat.c
@@ -156,11 +156,11 @@ sparc64nbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
       read_memory(pcb->pcb_sp + BIAS - 176 + (11 * 8), 
 		  (gdb_byte *)&pcb->pcb_pc, sizeof pcb->pcb_pc);
 
-  regcache_raw_supply (regcache, SPARC_SP_REGNUM, &pcb->pcb_sp);
-  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC_SP_REGNUM, &pcb->pcb_sp);
+  regcache->raw_supply (SPARC64_PC_REGNUM, &pcb->pcb_pc);
 
   state = pcb->pcb_pstate << 8 | pcb->pcb_cwp;
-  regcache_raw_supply (regcache, SPARC64_STATE_REGNUM, &state);
+  regcache->raw_supply (SPARC64_STATE_REGNUM, &state);
 
   sparc_supply_rwindow (regcache, pcb->pcb_sp, -1);
 
diff --git a/gdb/sparc64-obsd-nat.c b/gdb/sparc64-obsd-nat.c
index eeef3630363..593a7ac651b 100644
--- a/gdb/sparc64-obsd-nat.c
+++ b/gdb/sparc64-obsd-nat.c
@@ -95,11 +95,11 @@ sparc64obsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
       read_memory(pcb->pcb_sp + BIAS - 176 + (11 * 8), 
 		  (gdb_byte *)&pcb->pcb_pc, sizeof pcb->pcb_pc);
 
-  regcache_raw_supply (regcache, SPARC_SP_REGNUM, &pcb->pcb_sp);
-  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, &pcb->pcb_pc);
+  regcache->raw_supply (SPARC_SP_REGNUM, &pcb->pcb_sp);
+  regcache->raw_supply (SPARC64_PC_REGNUM, &pcb->pcb_pc);
 
   state = pcb->pcb_pstate << 8 | pcb->pcb_cwp;
-  regcache_raw_supply (regcache, SPARC64_STATE_REGNUM, &state);
+  regcache->raw_supply (SPARC64_STATE_REGNUM, &state);
 
   sparc_supply_rwindow (regcache, pcb->pcb_sp, -1);
 
diff --git a/gdb/sparc64-obsd-tdep.c b/gdb/sparc64-obsd-tdep.c
index f18b593c6d3..6af5f088fe2 100644
--- a/gdb/sparc64-obsd-tdep.c
+++ b/gdb/sparc64-obsd-tdep.c
@@ -334,7 +334,7 @@ sparc64obsd_supply_uthread (struct regcache *regcache,
   if (regnum == SPARC_SP_REGNUM || regnum == -1)
     {
       store_unsigned_integer (buf, 8, byte_order, fp);
-      regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
+      regcache->raw_supply (SPARC_SP_REGNUM, buf);
 
       if (regnum == SPARC_SP_REGNUM)
 	return;
@@ -349,12 +349,12 @@ sparc64obsd_supply_uthread (struct regcache *regcache,
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
 	{
 	  store_unsigned_integer (buf, 8, byte_order, i7 + 8);
-	  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
+	  regcache->raw_supply (SPARC64_PC_REGNUM, buf);
 	}
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
 	{
 	  store_unsigned_integer (buf, 8, byte_order, i7 + 12);
-	  regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf);
+	  regcache->raw_supply (SPARC64_NPC_REGNUM, buf);
 	}
 
       if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index dea8e4d4aeb..083ad72afd1 100644
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -1897,36 +1897,36 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 	  psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
 		 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
 	  store_unsigned_integer (buf, 4, byte_order, psr);
-	  regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
+	  regcache->raw_supply (SPARC32_PSR_REGNUM, buf);
 	}
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
-			     regs + gregmap->r_pc_offset + 4);
+	regcache->raw_supply (SPARC32_PC_REGNUM,
+			      regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
-			     regs + gregmap->r_npc_offset + 4);
+	regcache->raw_supply (SPARC32_NPC_REGNUM,
+			      regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
 	{
 	  int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
-	  regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
+	  regcache->raw_supply (SPARC32_Y_REGNUM, regs + offset);
 	}
     }
   else
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
-			     regs + gregmap->r_tstate_offset);
+	regcache->raw_supply (SPARC64_STATE_REGNUM,
+			      regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
-			     regs + gregmap->r_pc_offset);
+	regcache->raw_supply (SPARC64_PC_REGNUM,
+			      regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
-			     regs + gregmap->r_npc_offset);
+	regcache->raw_supply (SPARC64_NPC_REGNUM,
+			      regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
 	{
@@ -1935,17 +1935,17 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 	  memset (buf, 0, 8);
 	  memcpy (buf + 8 - gregmap->r_y_size,
 		  regs + gregmap->r_y_offset, gregmap->r_y_size);
-	  regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
+	  regcache->raw_supply (SPARC64_Y_REGNUM, buf);
 	}
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
 	  && gregmap->r_fprs_offset != -1)
-	regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
-			     regs + gregmap->r_fprs_offset);
+	regcache->raw_supply (SPARC64_FPRS_REGNUM,
+			      regs + gregmap->r_fprs_offset);
     }
 
   if (regnum == SPARC_G0_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
+    regcache->raw_supply (SPARC_G0_REGNUM, &zero);
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
     {
@@ -1957,7 +1957,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
 	{
 	  if (regnum == i || regnum == -1)
-	    regcache_raw_supply (regcache, i, regs + offset);
+	    regcache->raw_supply (i, regs + offset);
 	  offset += 8;
 	}
     }
@@ -1983,7 +1983,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 	  for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
 	    {
 	      if (regnum == i || regnum == -1)
-		regcache_raw_supply (regcache, i, regs + offset);
+		regcache->raw_supply (i, regs + offset);
 	      offset += 8;
 	    }
 	}
@@ -2112,14 +2112,14 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
-	regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
+	regcache->raw_supply (SPARC_F0_REGNUM + i,
 			     regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
+	regcache->raw_supply (SPARC32_FSR_REGNUM,
 			     regs + fpregmap->r_fsr_offset);
     }
   else
@@ -2127,14 +2127,14 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
       for (i = 0; i < 16; i++)
 	{
 	  if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
-	    regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
-				 (regs + fpregmap->r_f0_offset
-				  + (32 * 4) + (i * 8)));
+	    regcache->raw_supply
+	      (SPARC64_F32_REGNUM + i,
+	       regs + fpregmap->r_f0_offset + (32 * 4) + (i * 8));
 	}
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
-	regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
-			     regs + fpregmap->r_fsr_offset);
+	regcache->raw_supply (SPARC64_FSR_REGNUM,
+			      regs + fpregmap->r_fsr_offset);
     }
 }
 
diff --git a/gdb/spu-linux-nat.c b/gdb/spu-linux-nat.c
index 81bb5dd25f3..6a5be8bad71 100644
--- a/gdb/spu-linux-nat.c
+++ b/gdb/spu-linux-nat.c
@@ -529,7 +529,7 @@ spu_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
       gdb_byte buf[4];
       store_unsigned_integer (buf, 4, byte_order, fd);
-      regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
+      regcache->raw_supply (SPU_ID_REGNUM, buf);
     }
 
   /* The NPC register is found at ADDR.  */
@@ -537,7 +537,7 @@ spu_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
     {
       gdb_byte buf[4];
       if (fetch_ppc_memory (addr, buf, 4) == 0)
-	regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
+	regcache->raw_supply (SPU_PC_REGNUM, buf);
     }
 
   /* The GPRs are found in the "regs" spufs file.  */
@@ -553,7 +553,7 @@ spu_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
 	   == TARGET_XFER_OK)
 	  && len == sizeof buf)
 	for (i = 0; i < SPU_NUM_GPRS; i++)
-	  regcache_raw_supply (regcache, i, buf + i*16);
+	  regcache->raw_supply (i, buf + i*16);
     }
 }
 
diff --git a/gdb/spu-multiarch.c b/gdb/spu-multiarch.c
index 4a4d500b3bf..dc99f60fc43 100644
--- a/gdb/spu-multiarch.c
+++ b/gdb/spu-multiarch.c
@@ -207,7 +207,7 @@ spu_multiarch_target::fetch_registers (struct regcache *regcache, int regno)
     {
       gdb_byte buf[4];
       store_unsigned_integer (buf, 4, byte_order, spufs_fd);
-      regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
+      regcache->raw_supply (SPU_ID_REGNUM, buf);
     }
 
   /* The NPC register is found in PPC memory at SPUFS_ADDR.  */
@@ -217,7 +217,7 @@ spu_multiarch_target::fetch_registers (struct regcache *regcache, int regno)
 
       if (target_read (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
 		       buf, spufs_addr, sizeof buf) == sizeof buf)
-	regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
+	regcache->raw_supply (SPU_PC_REGNUM, buf);
     }
 
   /* The GPRs are found in the "regs" spufs file.  */
@@ -231,7 +231,7 @@ spu_multiarch_target::fetch_registers (struct regcache *regcache, int regno)
       if (target_read (ops_beneath, TARGET_OBJECT_SPU, annex,
 		       buf, 0, sizeof buf) == sizeof buf)
 	for (i = 0; i < SPU_NUM_GPRS; i++)
-	  regcache_raw_supply (regcache, i, buf + i*16);
+	  regcache->raw_supply (i, buf + i*16);
     }
 }
 
diff --git a/gdb/tilegx-linux-nat.c b/gdb/tilegx-linux-nat.c
index 9b596c03424..1ff64856751 100644
--- a/gdb/tilegx-linux-nat.c
+++ b/gdb/tilegx-linux-nat.c
@@ -88,7 +88,7 @@ supply_gregset (struct regcache* regcache,
 
   for (i = 0; i < sizeof (regmap) / sizeof (regmap[0]); i++)
     if (regmap[i] >= 0)
-      regcache_raw_supply (regcache, i, regp + regmap[i]);
+      regcache->raw_supply (i, regp + regmap[i]);
 }
 
 /* Fill registers in *GREGSETPS with the values in GDB's
diff --git a/gdb/tracefile-tfile.c b/gdb/tracefile-tfile.c
index 32f57220a0d..2327d9e47e3 100644
--- a/gdb/tracefile-tfile.c
+++ b/gdb/tracefile-tfile.c
@@ -898,12 +898,12 @@ tfile_target::fetch_registers (struct regcache *regcache, int regno)
 	    {
 	      if (regno == regn)
 		{
-		  regcache_raw_supply (regcache, regno, regs + offset);
+		  regcache->raw_supply (regno, regs + offset);
 		  break;
 		}
 	      else if (regno == -1)
 		{
-		  regcache_raw_supply (regcache, regn, regs + offset);
+		  regcache->raw_supply (regn, regs + offset);
 		}
 	    }
 	}
diff --git a/gdb/tracefile.c b/gdb/tracefile.c
index f7e69f2df6c..ab34ecfdf99 100644
--- a/gdb/tracefile.c
+++ b/gdb/tracefile.c
@@ -394,7 +394,7 @@ tracefile_fetch_registers (struct regcache *regcache, int regno)
   /* We get here if no register data has been found.  Mark registers
      as unavailable.  */
   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
-    regcache_raw_supply (regcache, regn, NULL);
+    regcache->raw_supply (regn, NULL);
 
   /* We can often usefully guess that the PC is going to be the same
      as the address of the tracepoint.  */
diff --git a/gdb/vax-bsd-nat.c b/gdb/vax-bsd-nat.c
index 5f67061e05a..527d718fc9f 100644
--- a/gdb/vax-bsd-nat.c
+++ b/gdb/vax-bsd-nat.c
@@ -46,7 +46,7 @@ vaxbsd_supply_gregset (struct regcache *regcache, const void *gregs)
   int regnum;
 
   for (regnum = 0; regnum < VAX_NUM_REGS; regnum++)
-    regcache_raw_supply (regcache, regnum, regs + regnum * 4);
+    regcache->raw_supply (regnum, regs + regnum * 4);
 }
 
 /* Collect the general-purpose registers from REGCACHE and store them
@@ -122,12 +122,12 @@ vaxbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
     return 0;
 
   for (regnum = VAX_R0_REGNUM; regnum < VAX_AP_REGNUM; regnum++)
-    regcache_raw_supply (regcache, regnum, &pcb->R[regnum - VAX_R0_REGNUM]);
-  regcache_raw_supply (regcache, VAX_AP_REGNUM, &pcb->AP);
-  regcache_raw_supply (regcache, VAX_FP_REGNUM, &pcb->FP);
-  regcache_raw_supply (regcache, VAX_SP_REGNUM, &pcb->KSP);
-  regcache_raw_supply (regcache, VAX_PC_REGNUM, &pcb->PC);
-  regcache_raw_supply (regcache, VAX_PS_REGNUM, &pcb->PSL);
+    regcache->raw_supply (regnum, &pcb->R[regnum - VAX_R0_REGNUM]);
+  regcache->raw_supply (VAX_AP_REGNUM, &pcb->AP);
+  regcache->raw_supply (VAX_FP_REGNUM, &pcb->FP);
+  regcache->raw_supply (VAX_SP_REGNUM, &pcb->KSP);
+  regcache->raw_supply (VAX_PC_REGNUM, &pcb->PC);
+  regcache->raw_supply (VAX_PS_REGNUM, &pcb->PSL);
 
   return 1;
 }
diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
index de07fdbb62e..d07a4779076 100644
--- a/gdb/vax-tdep.c
+++ b/gdb/vax-tdep.c
@@ -76,7 +76,7 @@ vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
   for (i = 0; i < VAX_NUM_REGS; i++)
     {
       if (regnum == i || regnum == -1)
-	regcache_raw_supply (regcache, i, regs + i * 4);
+	regcache->raw_supply (i, regs + i * 4);
     }
 }
 
diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 3fd8415bfcd..2d6ece08727 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -555,12 +555,12 @@ do_windows_fetch_inferior_registers (struct regcache *regcache,
   if (r == I387_FISEG_REGNUM (tdep))
     {
       l = *((long *) context_offset) & 0xffff;
-      regcache_raw_supply (regcache, r, (char *) &l);
+      regcache->raw_supply (r, (char *) &l);
     }
   else if (r == I387_FOP_REGNUM (tdep))
     {
       l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
-      regcache_raw_supply (regcache, r, (char *) &l);
+      regcache->raw_supply (r, (char *) &l);
     }
   else if (segment_register_p (r))
     {
@@ -568,10 +568,10 @@ do_windows_fetch_inferior_registers (struct regcache *regcache,
 	 in fact only 16 bits long.  Make sure we do not read extra
 	 bits from our source buffer.  */
       l = *((long *) context_offset) & 0xffff;
-      regcache_raw_supply (regcache, r, (char *) &l);
+      regcache->raw_supply (r, (char *) &l);
     }
   else if (r >= 0)
-    regcache_raw_supply (regcache, r, context_offset);
+    regcache->raw_supply (r, context_offset);
   else
     {
       for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
diff --git a/gdb/xtensa-linux-nat.c b/gdb/xtensa-linux-nat.c
index 57a44e30237..8737a9a4acf 100644
--- a/gdb/xtensa-linux-nat.c
+++ b/gdb/xtensa-linux-nat.c
@@ -134,63 +134,54 @@ supply_gregset_reg (struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
 
   if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
-    regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), &regs->pc);
+    regcache->raw_supply (gdbarch_pc_regnum (gdbarch), &regs->pc);
   if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
-    regcache_raw_supply (regcache, gdbarch_ps_regnum (gdbarch), &regs->ps);
+    regcache->raw_supply (gdbarch_ps_regnum (gdbarch), &regs->ps);
 
   if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->wb_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->wb_regnum,
 			  &regs->windowbase);
   if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->ws_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->ws_regnum,
 			  &regs->windowstart);
   if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->lbeg_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->lbeg_regnum,
 			  &regs->lbeg);
   if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->lend_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->lend_regnum,
 			  &regs->lend);
   if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->lcount_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->lcount_regnum,
 			  &regs->lcount);
   if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->sar_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->sar_regnum,
 			  &regs->sar);
   if (regnum == gdbarch_tdep (gdbarch)->threadptr_regnum || regnum == -1)
-    regcache_raw_supply (regcache,
-			  gdbarch_tdep (gdbarch)->threadptr_regnum,
+    regcache->raw_supply (gdbarch_tdep (gdbarch)->threadptr_regnum,
 			  &regs->threadptr);
   if (regnum >=gdbarch_tdep (gdbarch)->ar_base
       && regnum < gdbarch_tdep (gdbarch)->ar_base
 		    + gdbarch_tdep (gdbarch)->num_aregs)
-    regcache_raw_supply (regcache,regnum,
+    regcache->raw_supply (regnum,
 			  &regs->ar[regnum - gdbarch_tdep (gdbarch)->ar_base]);
   else if (regnum == -1)
     {
       for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
-	regcache_raw_supply (regcache,
-			      gdbarch_tdep (gdbarch)->ar_base + i,
+	regcache->raw_supply (gdbarch_tdep (gdbarch)->ar_base + i,
 			      &regs->ar[i]);
     }
   if (regnum >= gdbarch_tdep (gdbarch)->a0_base
       && regnum < gdbarch_tdep (gdbarch)->a0_base + C0_NREGS)
-    regcache_raw_supply (regcache, regnum,
-			 &regs->ar[(4 * regs->windowbase + regnum
-				    - gdbarch_tdep (gdbarch)->a0_base)
+    regcache->raw_supply (regnum,
+			  &regs->ar[(4 * regs->windowbase + regnum
+				     - gdbarch_tdep (gdbarch)->a0_base)
 			 % gdbarch_tdep (gdbarch)->num_aregs]);
   else if (regnum == -1)
     {
       for (i = 0; i < C0_NREGS; ++i)
-	regcache_raw_supply (regcache,
-			     gdbarch_tdep (gdbarch)->a0_base + i,
-			     &regs->ar[(4 * regs->windowbase + i)
-			     % gdbarch_tdep (gdbarch)->num_aregs]);
+	regcache->raw_supply (gdbarch_tdep (gdbarch)->a0_base + i,
+			      &regs->ar[(4 * regs->windowbase + i)
+					% gdbarch_tdep (gdbarch)->num_aregs]);
     }
 }
 
@@ -276,8 +267,7 @@ fetch_xtregs (struct regcache *regcache, int regnum)
 
   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
     if (regnum == ptr->gdb_regnum || regnum == -1)
-      regcache_raw_supply (regcache, ptr->gdb_regnum,
-			   xtregs + ptr->ptrace_offset);
+      regcache->raw_supply (ptr->gdb_regnum, xtregs + ptr->ptrace_offset);
 }
 
 static void
diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index 1f87b9ca3ff..60e34c3075b 100644
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -848,38 +848,37 @@ xtensa_supply_gregset (const struct regset *regset,
   DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...)\n", regnum);
 
   if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_pc_regnum (gdbarch), (char *) &regs->pc);
+    rc->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &regs->pc);
   if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_ps_regnum (gdbarch), (char *) &regs->ps);
+    rc->raw_supply (gdbarch_ps_regnum (gdbarch), (char *) &regs->ps);
   if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->wb_regnum,
-			 (char *) &regs->windowbase);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->wb_regnum,
+		    (char *) &regs->windowbase);
   if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ws_regnum,
-			 (char *) &regs->windowstart);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->ws_regnum,
+		    (char *) &regs->windowstart);
   if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lbeg_regnum,
-			 (char *) &regs->lbeg);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->lbeg_regnum,
+		    (char *) &regs->lbeg);
   if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lend_regnum,
-			 (char *) &regs->lend);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->lend_regnum,
+		    (char *) &regs->lend);
   if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lcount_regnum,
-			 (char *) &regs->lcount);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->lcount_regnum,
+		    (char *) &regs->lcount);
   if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
-    regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->sar_regnum,
-			 (char *) &regs->sar);
+    rc->raw_supply (gdbarch_tdep (gdbarch)->sar_regnum,
+		    (char *) &regs->sar);
   if (regnum >=gdbarch_tdep (gdbarch)->ar_base
       && regnum < gdbarch_tdep (gdbarch)->ar_base
 		    + gdbarch_tdep (gdbarch)->num_aregs)
-    regcache_raw_supply (rc, regnum,
-			 (char *) &regs->ar[regnum - gdbarch_tdep
-			   (gdbarch)->ar_base]);
+    rc->raw_supply
+      (regnum, (char *) &regs->ar[regnum - gdbarch_tdep (gdbarch)->ar_base]);
   else if (regnum == -1)
     {
       for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
-	regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ar_base + i,
-			     (char *) &regs->ar[i]);
+	rc->raw_supply (gdbarch_tdep (gdbarch)->ar_base + i,
+			(char *) &regs->ar[i]);
     }
 }