* regcache.c (register_buffer): Add regcache parameter. Update

callers.
(struct regcache_descr): Add nr_raw_registers and
max_register_size.  Add legacy_p.  Change registers to
raw_registers, register_valid_p to raw_register_valid_p.  Update
all callers.
(legacy_regcache_descr): New function handle legacy case.
(regcache_descr): Use legacy function.  For non-legacy case,
restrict the register cache to just NUM_REGS.
(regcache_read, regcache_write): When non-legacy case, implement
regcache read and write directly.
(regcache_write): Use regcache_valid_p.

* regcache.h (deprecated_grub_regcache_for_registers): Rename
grub_around_regcache_for_registers
(deprecated_grub_regcache_for_register_valid): Rename
grub_around_regcache_for_register_valid.
* regcache.c (deprecated_grub_around_regcache_for_registers)
(deprecated_grub_regcache_for_register_valid): Rename.
* rs6000-tdep.c (rs6000_extract_return_value): Update.
* regcache.c (build_regcache): Update.

4 files changed, 265 insertions, 85 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 742d060137a..a5e0502b82e 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,6 +1,28 @@
-2002-05-17  Andrew Cagney  <ac131313@redhat.com>
+2002-05-23  Andrew Cagney  <ac131313@redhat.com>
+
+	* regcache.c (register_buffer): Add regcache parameter.  Update
+	callers.
+	(struct regcache_descr): Add nr_raw_registers and
+	max_register_size.  Add legacy_p.  Change registers to
+	raw_registers, register_valid_p to raw_register_valid_p.  Update
+	all callers.
+	(legacy_regcache_descr): New function handle legacy case.
+	(regcache_descr): Use legacy function.  For non-legacy case,
+	restrict the register cache to just NUM_REGS.
+	(regcache_read, regcache_write): When non-legacy case, implement
+	regcache read and write directly.
+	(regcache_write): Use regcache_valid_p.
+
+	* regcache.h (deprecated_grub_regcache_for_registers): Rename
+	grub_around_regcache_for_registers
+	(deprecated_grub_regcache_for_register_valid): Rename
+	grub_around_regcache_for_register_valid.
+	* regcache.c (deprecated_grub_around_regcache_for_registers)
+	(deprecated_grub_regcache_for_register_valid): Rename.
+	* rs6000-tdep.c (rs6000_extract_return_value): Update.
+	* regcache.c (build_regcache): Update.
 
-*** FIXME: the regcache_desc should contain max_register_size.
+2002-05-17  Andrew Cagney  <ac131313@redhat.com>
 
 	* regcache.c (regcache_move): New function.
 	(regcache_save): Rewrite, handle pre and post
diff --git a/gdb/regcache.c b/gdb/regcache.c
index f1a658a5067..f2d5b54966c 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -43,26 +43,39 @@ struct regcache_descr
 {
   /* The architecture this descriptor belongs to.  */
   struct gdbarch *gdbarch;
-  /* Total number of registers in the buffer.  */
-  int nr_registers;
-  /* Size of the register buffer, over-allocate making room for both
-     real and pseudo-registers.  */
-  /* FIXME: cagney/2002-05-11: This over-allocation shouldn't be
-     necessary.  Unfortunatly, some targets store real values in
-     pseudo-registers and we want to be sure those targets don't crash
-     GDB.  Once that code has been trashed this can be pruned down to
-     just raw registers.  */
-  long sizeof_registers;
-  /* Offset into the register buffer for each register.  */
+
+  /* Is this a ``legacy'' register cache?  Such caches reserve space
+     for raw and pseudo registers and allow access to both.  */
+  int legacy_p;
+
+  /* The raw register cache.  This should contain just [0
+     .. NUM_RAW_REGISTERS).  However, for older targets, it contains
+     space for the full [0 .. NUM_RAW_REGISTERS +
+     NUM_PSEUDO_REGISTERS).  */
+  int nr_raw_registers;
+  long sizeof_raw_registers;
+  long sizeof_raw_register_valid_p;
+
+  /* Offset, in bytes, of reach register in the raw register cache.
+     Pseudo registers have an offset even though they don't
+     (shouldn't) have a correspoinding space in the register cache.
+     It is to keep existing code, that relies on
+     write/write_register_bytes working.  */
   long *register_offset;
-  /* Size, in bytes of the register valid array.  */
-  long sizeof_register_valid_p;
-  /* Size, in ``bytes'', of a register.  */
+
+  /* The cooked / frame / virtual register space.  The registers in
+     the range [0..NR_RAW_REGISTERS) should be mapped directly onto
+     the corresponding raw register.  The next [NR_RAW_REGISTERS
+     .. NR_REGISTERS) should have been mapped, via
+     gdbarch_register_read/write onto either raw registers or memory.  */
+  int nr_registers;
   long *sizeof_register;
+  long max_register_size;
+
 };
 
 static struct regcache_descr *
-regcache_descr (struct gdbarch *gdbarch)
+legacy_regcache_descr (struct gdbarch *gdbarch)
 {
   int i;
   struct regcache_descr *descr;
@@ -76,11 +89,13 @@ regcache_descr (struct gdbarch *gdbarch)
   
   descr = XMALLOC (struct regcache_descr);
   descr->gdbarch = gdbarch;
+  descr->legacy_p = 1;
 
   /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
      in the register buffer.  Unfortunatly some architectures do.  */
   descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
-  descr->sizeof_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
+  descr->nr_raw_registers = descr->nr_registers;
+  descr->sizeof_raw_register_valid_p = descr->nr_registers;
 
   /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
      code should compute the offets et.al. at runtime.  This currently
@@ -89,14 +104,17 @@ regcache_descr (struct gdbarch *gdbarch)
      registers.  */
   descr->sizeof_register = XCALLOC (descr->nr_registers, long);
   descr->register_offset = XCALLOC (descr->nr_registers, long);
+  descr->max_register_size = 0;
   for (i = 0; i < descr->nr_registers; i++)
     {
       descr->register_offset[i] = REGISTER_BYTE (i);
       descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
+      if (descr->max_register_size < REGISTER_RAW_SIZE (i))
+	descr->max_register_size = REGISTER_RAW_SIZE (i);
     }
 
   /* Come up with the real size of the registers buffer.  */
-  descr->sizeof_registers = REGISTER_BYTES; /* OK use.  */
+  descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use.  */
   for (i = 0; i < descr->nr_registers; i++)
     {
       long regend;
@@ -111,13 +129,94 @@ regcache_descr (struct gdbarch *gdbarch)
          Ulgh!  New targets use gdbarch's register read/write and
          entirely avoid this uglyness.  */
       regend = descr->register_offset[i] + descr->sizeof_register[i];
-      if (descr->sizeof_registers < regend)
-	descr->sizeof_registers = regend;
+      if (descr->sizeof_raw_registers < regend)
+	descr->sizeof_raw_registers = regend;
     }
   set_gdbarch_data (gdbarch, regcache_data_handle, descr);
   return descr;
 }
 
+static struct regcache_descr *
+regcache_descr (struct gdbarch *gdbarch)
+{
+  int i;
+  struct regcache_descr *descr;
+  gdb_assert (gdbarch != NULL);
+
+  /* If the value has previously been computed, just return that.  */
+  descr = gdbarch_data (gdbarch, regcache_data_handle);
+  if (descr != NULL)
+    return descr;
+  
+  /* If an old style architecture, construct the register cache
+     description using all the register macros.  */
+  if (!gdbarch_register_read_p (gdbarch)
+      && !gdbarch_register_write_p (gdbarch))
+    return legacy_regcache_descr (gdbarch);
+
+  descr = XMALLOC (struct regcache_descr);
+  descr->gdbarch = gdbarch;
+  descr->legacy_p = 0;
+
+  /* Total size of the register space.  The raw registers should
+     directly map onto the raw register cache while the pseudo's are
+     either mapped onto raw-registers or memory.  */
+  descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
+
+  /* Construct a strictly RAW register cache.  Don't allow pseudo's
+     into the register cache.  */
+  descr->nr_raw_registers = NUM_REGS;
+  descr->sizeof_raw_register_valid_p = NUM_REGS;
+
+  /* Lay out the register cache.  The pseud-registers are included in
+     the layout even though their value isn't stored in the register
+     cache.  Some code, via read_register_bytes() access a register
+     using an offset/length rather than a register number.
+
+     NOTE: cagney/2002-05-22: Only REGISTER_VIRTUAL_TYPE() needs to be
+     used when constructing the register cache.  It is assumed that
+     register raw size, virtual size and type length of the type are
+     all the same.  */
+
+  {
+    long offset = 0;
+    descr->sizeof_register = XCALLOC (descr->nr_registers, long);
+    descr->register_offset = XCALLOC (descr->nr_registers, long);
+    descr->max_register_size = 0;
+    for (i = 0; i < descr->nr_registers; i++)
+      {
+	descr->sizeof_register[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
+	descr->register_offset[i] = offset;
+	offset += descr->sizeof_register[i];
+	if (descr->max_register_size < descr->sizeof_register[i])
+	  descr->max_register_size = descr->sizeof_register[i];
+      }
+    /* Set the real size of the register cache buffer.  */
+    /* FIXME: cagney/2002-05-22: Should only need to allocate space
+       for the raw registers.  Unfortunatly some code still accesses
+       the register array directly using the global registers[].
+       Until that code has been purged, play safe and over allocating
+       the register buffer.  Ulgh!  */
+    descr->sizeof_raw_registers = offset;
+    /* = descr->register_offset[descr->nr_raw_registers]; */
+  }
+
+  set_gdbarch_data (gdbarch, regcache_data_handle, descr);
+
+  /* Sanity check.  Confirm that the assumptions about gdbarch are
+     true.  The REGCACHE_DATA_HANDLE is set before doing the checks so
+     that targets using the generic methods supplied by regcache don't
+     go into infinite recursion trying to, again, create the regcache.  */
+  for (i = 0; i < descr->nr_registers; i++)
+    {
+      gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
+      gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
+      gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
+    }
+  /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i));  */
+  return descr;
+}
+
 static void
 xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
 {
@@ -131,13 +230,13 @@ xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
   xfree (descr);
 }
 
-/* For moment, ``struct regcache'' is just a character buffer.  */
+/* The register cache for storing raw register values.  */
 
 struct regcache
 {
   struct regcache_descr *descr;
-  char *registers;
-  char *register_valid_p;
+  char *raw_registers;
+  char *raw_register_valid_p;
   /* If a value isn't in the cache should the corresponding target be
      queried for a value.  */
   int passthrough_p;
@@ -152,8 +251,10 @@ regcache_xmalloc (struct gdbarch *gdbarch)
   descr = regcache_descr (gdbarch);
   regcache = XMALLOC (struct regcache);
   regcache->descr = descr;
-  regcache->registers = XCALLOC (descr->sizeof_registers, char);
-  regcache->register_valid_p = XCALLOC (descr->sizeof_register_valid_p, char);
+  regcache->raw_registers
+    = XCALLOC (descr->sizeof_raw_registers, char);
+  regcache->raw_register_valid_p
+    = XCALLOC (descr->sizeof_raw_register_valid_p, char);
   regcache->passthrough_p = 0;
   return regcache;
 }
@@ -163,8 +264,8 @@ regcache_xfree (struct regcache *regcache)
 {
   if (regcache == NULL)
     return;
-  xfree (regcache->registers);
-  xfree (regcache->register_valid_p);
+  xfree (regcache->raw_registers);
+  xfree (regcache->raw_register_valid_p);
   xfree (regcache);
 }
 
@@ -186,33 +287,32 @@ void
 regcache_cpy (struct regcache *dst, struct regcache *src)
 {
   int i;
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char *buf;
   gdb_assert (src != NULL && dst != NULL);
   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
   gdb_assert (src != dst);
   /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
      It keeps the existing code working where things rely on going
-     through the register cache.  */
-  if (src == current_regcache
-      && !gdbarch_register_read_p (src->descr->gdbarch))
+     through to the register cache.  */
+  if (src == current_regcache && src->descr->legacy_p)
     {
       /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
 	 untangle fetch.  */
-      read_register_bytes (0, dst->registers, REGISTER_BYTES);
+      read_register_bytes (0, dst->raw_registers, REGISTER_BYTES);
       return;
     }
   /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
      It keeps the existing code working where things rely on going
-     through the register cache.  */
-  if (dst == current_regcache
-      && !gdbarch_register_read_p (dst->descr->gdbarch))
+     through to the register cache.  */
+  if (dst == current_regcache && dst->descr->legacy_p)
     {
       /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
 	 untangle fetch.  */
-      write_register_bytes (0, src->registers, REGISTER_BYTES);
+      write_register_bytes (0, src->raw_registers, REGISTER_BYTES);
       return;
     }
-  for (i = 0; i < current_regcache->descr->nr_registers; i++)
+  buf = alloca (src->descr->max_register_size);
+  for (i = 0; i < src->descr->nr_raw_registers; i++)
     {
       /* Should we worry about the valid bit here?  */
       regcache_read (src, i, buf);
@@ -230,10 +330,10 @@ regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
      move of data into the current_regcache().  Doing this would be
      silly - it would mean that valid_p would be completly invalid.  */
   gdb_assert (dst != current_regcache);
-  memcpy (dst->registers, src->registers,
-	  dst->descr->sizeof_registers);
-  memcpy (dst->register_valid_p, src->register_valid_p,
-	  dst->descr->sizeof_register_valid_p);
+  memcpy (dst->raw_registers, src->raw_registers,
+	  dst->descr->sizeof_raw_registers);
+  memcpy (dst->raw_register_valid_p, src->raw_register_valid_p,
+	  dst->descr->sizeof_raw_register_valid_p);
 }
 
 struct regcache *
@@ -260,8 +360,8 @@ int
 regcache_valid_p (struct regcache *regcache, int regnum)
 {
   gdb_assert (regcache != NULL);
-  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
-  return regcache->register_valid_p[regnum];
+  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+  return regcache->raw_register_valid_p[regnum];
 }
 
 CORE_ADDR
@@ -269,22 +369,22 @@ regcache_read_as_address (struct regcache *regcache, int regnum)
 {
   char *buf;
   gdb_assert (regcache != NULL);
-  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
   buf = alloca (regcache->descr->sizeof_register[regnum]);
   regcache_read (regcache, regnum, buf);
   return extract_address (buf, regcache->descr->sizeof_register[regnum]);
 }
 
 char *
-grub_around_regcache_for_registers (struct regcache *regcache)
+deprecated_grub_regcache_for_registers (struct regcache *regcache)
 {
-  return regcache->registers;
+  return regcache->raw_registers;
 }
 
 char *
-grub_around_regcache_for_register_valid (struct regcache *regcache)
+deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
 {
-  return regcache->register_valid_p;
+  return regcache->raw_register_valid_p;
 }
 
 /* Global structure containing the current regcache.  */
@@ -356,10 +456,9 @@ register_changed (int regnum)
    else return a pointer to the start of the cache buffer.  */
 
 static char *
-register_buffer (int regnum)
+register_buffer (struct regcache *regcache, int regnum)
 {
-  gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
-  return &registers[REGISTER_BYTE (regnum)];
+  return regcache->raw_registers + regcache->descr->register_offset[regnum];
 }
 
 /* Return whether register REGNUM is a real register.  */
@@ -570,7 +669,7 @@ legacy_read_register_gen (int regnum, char *myaddr)
   if (!register_cached (regnum))
     fetch_register (regnum);
 
-  memcpy (myaddr, register_buffer (regnum),
+  memcpy (myaddr, register_buffer (current_regcache, regnum),
 	  REGISTER_RAW_SIZE (regnum));
 }
 
@@ -578,24 +677,44 @@ void
 regcache_read (struct regcache *regcache, int regnum, char *buf)
 {
   gdb_assert (regcache != NULL && buf != NULL);
-  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+  if (regcache->descr->legacy_p
+      && regcache->passthrough_p)
+    {
+      gdb_assert (regcache == current_regcache);
+      /* For moment, just use underlying legacy code.  Ulgh!!! This
+	 silently and very indirectly updates the regcache's regcache
+	 via the global register_valid[].  */
+      legacy_read_register_gen (regnum, buf);
+      return;
+    }
+  /* Make certain that the register cache is up-to-date with respect
+     to the current thread.  This switching shouldn't be necessary
+     only there is still only one target side register cache.  Sigh!
+     On the bright side, at least there is a regcache object.  */
   if (regcache->passthrough_p)
-    /* For moment, just use underlying legacy code. Ulgh!!! This
-       silently and very indirectly updates the regcache's regcache via
-       the global register_valid[].  */
-    legacy_read_register_gen (regnum, buf);
-  else
     {
-      memcpy (buf, (regcache->registers
-		    + regcache->descr->register_offset[regnum]),
-	      regcache->descr->sizeof_register[regnum]);
+      gdb_assert (regcache == current_regcache);
+      if (! ptid_equal (registers_ptid, inferior_ptid))
+	{
+	  registers_changed ();
+	  registers_ptid = inferior_ptid;
+	}
+      if (!register_cached (regnum))
+	fetch_register (regnum);
     }
+  /* Copy the value directly into the register cache.  */
+  memcpy (buf, (regcache->raw_registers
+		+ regcache->descr->register_offset[regnum]),
+	  regcache->descr->sizeof_register[regnum]);
 }
 
 void
 read_register_gen (int regnum, char *buf)
 {
-  if (! gdbarch_register_read_p (current_gdbarch))
+  gdb_assert (current_regcache != NULL);
+  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
+  if (current_regcache->descr->legacy_p)
     {
       legacy_read_register_gen (regnum, buf);
       return;
@@ -631,13 +750,14 @@ legacy_write_register_gen (int regnum, char *myaddr)
       /* If we have a valid copy of the register, and new value == old
 	 value, then don't bother doing the actual store. */
       if (register_cached (regnum)
-	  && memcmp (register_buffer (regnum), myaddr, size) == 0)
+	  && (memcmp (register_buffer (current_regcache, regnum), myaddr, size)
+	      == 0))
 	return;
       else
 	target_prepare_to_store ();
     }
 
-  memcpy (register_buffer (regnum), myaddr, size);
+  memcpy (register_buffer (current_regcache, regnum), myaddr, size);
 
   set_register_cached (regnum, 1);
   store_register (regnum);
@@ -647,24 +767,63 @@ void
 regcache_write (struct regcache *regcache, int regnum, char *buf)
 {
   gdb_assert (regcache != NULL && buf != NULL);
-  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
-  if (regcache->passthrough_p)
-    /* For moment, just use underlying legacy code. Ulgh!!! This
-       silently and very indirectly updates the regcache's regcache via
-       the global register_valid[].  */
-    legacy_write_register_gen (regnum, buf);
-  else
+  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+
+  if (regcache->passthrough_p
+      && regcache->descr->legacy_p)
     {
-      memcpy (regcache->registers + regcache->descr->register_offset[regnum], buf,
+      /* For moment, just use underlying legacy code.  Ulgh!!! This
+	 silently and very indirectly updates the regcache's buffers
+	 via the globals register_valid[] and registers[].  */
+      gdb_assert (regcache == current_regcache);
+      legacy_write_register_gen (regnum, buf);
+      return;
+    }
+
+  /* On the sparc, writing %g0 is a no-op, so we don't even want to
+     change the registers array if something writes to this register.  */
+  if (CANNOT_STORE_REGISTER (regnum))
+    return;
+
+  /* Handle the simple case first -> not write through so just store
+     value in cache.  */
+  if (!regcache->passthrough_p)
+    {
+      memcpy ((regcache->raw_registers
+	       + regcache->descr->register_offset[regnum]), buf,
 	      regcache->descr->sizeof_register[regnum]);
-      regcache->register_valid_p[regnum] = 1;
+      regcache->raw_register_valid_p[regnum] = 1;
+      return;
     }
+
+  /* Make certain that the correct cache is selected.  */
+  gdb_assert (regcache == current_regcache);
+  if (! ptid_equal (registers_ptid, inferior_ptid))
+    {
+      registers_changed ();
+      registers_ptid = inferior_ptid;
+    }
+
+  /* If we have a valid copy of the register, and new value == old
+     value, then don't bother doing the actual store. */
+  if (regcache_valid_p (regcache, regnum)
+      && (memcmp (register_buffer (regcache, regnum), buf,
+		  regcache->descr->sizeof_register[regnum]) == 0))
+    return;
+
+  target_prepare_to_store ();
+  memcpy (register_buffer (regcache, regnum), buf,
+	  regcache->descr->sizeof_register[regnum]);
+  regcache->raw_register_valid_p[regnum] = 1;
+  store_register (regnum);
 }
 
 void
 write_register_gen (int regnum, char *buf)
 {
-  if (! gdbarch_register_write_p (current_gdbarch))
+  gdb_assert (current_regcache != NULL);
+  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
+  if (current_regcache->descr->legacy_p)
     {
       legacy_write_register_gen (regnum, buf);
       return;
@@ -843,10 +1002,10 @@ supply_register (int regnum, char *val)
 
   set_register_cached (regnum, 1);
   if (val)
-    memcpy (register_buffer (regnum), val, 
+    memcpy (register_buffer (current_regcache, regnum), val, 
 	    REGISTER_RAW_SIZE (regnum));
   else
-    memset (register_buffer (regnum), '\000', 
+    memset (register_buffer (current_regcache, regnum), '\000', 
 	    REGISTER_RAW_SIZE (regnum));
 
   /* On some architectures, e.g. HPPA, there are a few stray bits in
@@ -866,7 +1025,8 @@ supply_register (int regnum, char *val)
 void
 regcache_collect (int regnum, void *buf)
 {
-  memcpy (buf, register_buffer (regnum), REGISTER_RAW_SIZE (regnum));
+  memcpy (buf, register_buffer (current_regcache, regnum),
+	  REGISTER_RAW_SIZE (regnum));
 }
 
 
@@ -1036,15 +1196,14 @@ build_regcache (void)
 {
   current_regcache = regcache_xmalloc (current_gdbarch);
   current_regcache->passthrough_p = 1;
-  registers = grub_around_regcache_for_registers (current_regcache);
-  register_valid = grub_around_regcache_for_register_valid (current_regcache);
+  registers = deprecated_grub_regcache_for_registers (current_regcache);
+  register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
 }
 
 void
 regcache_save (struct regcache *regcache)
 {
   int i;
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
   gdb_assert (current_regcache != NULL && regcache != NULL);
   gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
   regcache_cpy (regcache, current_regcache);
@@ -1062,7 +1221,6 @@ void
 regcache_restore (struct regcache *regcache)
 {
   int i;
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
   gdb_assert (current_regcache != NULL && regcache != NULL);
   gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
   regcache_cpy (current_regcache, regcache);
diff --git a/gdb/regcache.h b/gdb/regcache.h
index 5fb0ac6b8a3..17e01386fe8 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -73,8 +73,8 @@ extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
 extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
 
-extern char *grub_around_regcache_for_registers (struct regcache *);
-extern char *grub_around_regcache_for_register_valid (struct regcache *);
+extern char *deprecated_grub_regcache_for_registers (struct regcache *);
+extern char *deprecated_grub_regcache_for_register_valid (struct regcache *);
 
 extern int register_cached (int regnum);
 
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index bd15da84700..37794725bf0 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -1150,7 +1150,7 @@ rs6000_extract_return_value (struct type *valtype, struct regcache *regs,
 {
   int offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-  char *regbuf = grub_around_regcache_for_registers (regs);
+  char *regbuf = deprecated_grub_regcache_for_registers (regs);
 
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
     {