Re: [patch/rfc] Overhaul regcache for {save,restore}_reggroup

[Andrew Cagney <ac131313@redhat.com>]

[-- Attachment #1: Type: text/plain, Size: 2353 bytes --]

> Hello,
> 
> This patch brings in the last big change sitting on the reggroups branch.
> 
> It adds regcache save/restore functions to to the regcache.
> These functions save/restore a subset of registers determined by the save/restore reggroups (by default REGNUMs in the range [0 .. NUM_REGS) are in both the save_reggroup and restore_reggroup, and hence are saved/restored).
> 
> As part of this, a saved read-only regcache is expanded so that it can hold the saved value of any register in the full [0 .. NUM_REGS+NUM_PSEUDO_REGS) range.  This is so that architectures with memory-mapped registers (which fall into the range [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) have somewhere to save them.
> 
> I'll look to commit it in a few days,
> 
> (Oh, and it deletes the last remaining core reference to read_register_bytes() or write_register_bytes()).

No comment :-)  I found while re-re-merging this that it was a little to 
chumpy for my liking so I've broken it down further.  So far I've 
committed the attached.  It contains strictly mechanical changes.

Andrew


> 2002-11-07  Andrew Cagney  <ac131313@redhat.com>
> 
> 	* regcache.h (regcache_save, regcache_restore): Declare.
> 	
> 	* regcache.c (struct regcache_descr): Add fields
> 	sizeof_cooked_registers and sizeof_cooked_register_valid_p.
> 	(init_legacy_regcache_descr): Compute sizeof_cooked_registers.
> 	Update comments.
> 	(init_regcache_descr): Compute sizeof_cooked_register_valid_p and
> 	sizeof_cooked_registers.  Update comments.
> 	(struct regcache): Replace passthrough_p with readonly_p.  Replace
> 	raw_registers and raw_register_valid_p with registers and
> 	register_valid_p.
> 	(regcache_cooked_read): Check for cached cooked values.
> 	(regcache_xmalloc): Update.
> 	(regcache_save): New function.
> 	(regcache_restore): New function.
> 	(regcache_cpy): Rewrite using regcache_save, regcache_restore and
> 	regcache_cpy_no_passthrough.
> 	(regcache_raw_read): Update.
> 	(regcache_raw_write): Update.
> 	(build_regcache): Update.
> 	(regcache_xfree): Update.
> 	(regcache_cpy_no_passthrough): Update.
> 	(regcache_valid_p): Update.
> 	(deprecated_grub_regcache_for_registers): Update.
> 	(deprecated_grub_regcache_for_register_valid): Update.
> 	(register_buffer): Move declaration to start.  Update.
> 	(regcache_raw_read): Update.
> 	(regcache_raw_write): Update.
> 


[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 5827 bytes --]

2002-11-13  Andrew Cagney  <cagney@redhat.com>

	* regcache.c (register_buffer): Move to near start of file, update
	description.
	(regcache_raw_read): Use.
	(regcache_raw_write): Use.
	(struct regcache): Rename raw_registers to registers and
	raw_register_valid_p to register_valid_p.
	(regcache_xmalloc): Update.
	(regcache_xfree): Update.
	(register_buffer): Update.
	(regcache_cpy): Update.
	(regcache_cpy_no_passthrough): Update.
	(regcache_valid_p): Update.
	(deprecated_grub_regcache_for_registers): Update.
	(deprecated_grub_regcache_for_register_valid): Update.
	(set_register_cached): Update.
	(regcache_raw_write): Update.

Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.63
diff -u -r1.63 regcache.c
--- regcache.c	7 Nov 2002 21:43:23 -0000	1.63
+++ regcache.c	13 Nov 2002 15:53:32 -0000
@@ -277,8 +277,11 @@
 struct regcache
 {
   struct regcache_descr *descr;
-  char *raw_registers;
-  char *raw_register_valid_p;
+  /* The register buffers.  A read-only register cache can hold the
+     full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
+     register cache can only hold [0 .. NUM_REGS).  */
+  char *registers;
+  char *register_valid_p;
   /* If a value isn't in the cache should the corresponding target be
      queried for a value.  */
   int passthrough_p;
@@ -293,9 +296,9 @@
   descr = regcache_descr (gdbarch);
   regcache = XMALLOC (struct regcache);
   regcache->descr = descr;
-  regcache->raw_registers
+  regcache->registers
     = XCALLOC (descr->sizeof_raw_registers, char);
-  regcache->raw_register_valid_p
+  regcache->register_valid_p
     = XCALLOC (descr->sizeof_raw_register_valid_p, char);
   regcache->passthrough_p = 0;
   return regcache;
@@ -306,8 +309,8 @@
 {
   if (regcache == NULL)
     return;
-  xfree (regcache->raw_registers);
-  xfree (regcache->raw_register_valid_p);
+  xfree (regcache->registers);
+  xfree (regcache->register_valid_p);
   xfree (regcache);
 }
 
@@ -323,6 +326,14 @@
   return make_cleanup (do_regcache_xfree, regcache);
 }
 
+/* Return  a pointer to register REGNUM's buffer cache.  */
+
+static char *
+register_buffer (struct regcache *regcache, int regnum)
+{
+  return regcache->registers + regcache->descr->register_offset[regnum];
+}
+
 void
 regcache_cpy (struct regcache *dst, struct regcache *src)
 {
@@ -338,7 +349,7 @@
     {
       /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
 	 untangle fetch.  */
-      read_register_bytes (0, dst->raw_registers, REGISTER_BYTES);
+      read_register_bytes (0, dst->registers, REGISTER_BYTES);
       return;
     }
   /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
@@ -348,7 +359,7 @@
     {
       /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
 	 untangle fetch.  */
-      write_register_bytes (0, src->raw_registers, REGISTER_BYTES);
+      write_register_bytes (0, src->registers, REGISTER_BYTES);
       return;
     }
   buf = alloca (src->descr->max_register_size);
@@ -370,9 +381,8 @@
      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->raw_registers, src->raw_registers,
-	  dst->descr->sizeof_raw_registers);
-  memcpy (dst->raw_register_valid_p, src->raw_register_valid_p,
+  memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
+  memcpy (dst->register_valid_p, src->register_valid_p,
 	  dst->descr->sizeof_raw_register_valid_p);
 }
 
@@ -401,19 +411,19 @@
 {
   gdb_assert (regcache != NULL);
   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
-  return regcache->raw_register_valid_p[regnum];
+  return regcache->register_valid_p[regnum];
 }
 
 char *
 deprecated_grub_regcache_for_registers (struct regcache *regcache)
 {
-  return regcache->raw_registers;
+  return regcache->registers;
 }
 
 char *
 deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
 {
-  return regcache->raw_register_valid_p;
+  return regcache->register_valid_p;
 }
 
 /* Global structure containing the current regcache.  */
@@ -471,16 +481,7 @@
 {
   gdb_assert (regnum >= 0);
   gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
-  current_regcache->raw_register_valid_p[regnum] = state;
-}
-
-/* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
-   else return a pointer to the start of the cache buffer.  */
-
-static char *
-register_buffer (struct regcache *regcache, int regnum)
-{
-  return regcache->raw_registers + regcache->descr->register_offset[regnum];
+  current_regcache->register_valid_p[regnum] = state;
 }
 
 /* Return whether register REGNUM is a real register.  */
@@ -686,8 +687,7 @@
 	target_fetch_registers (regnum);
     }
   /* Copy the value directly into the register cache.  */
-  memcpy (buf, (regcache->raw_registers
-		+ regcache->descr->register_offset[regnum]),
+  memcpy (buf, register_buffer (regcache, regnum),
 	  regcache->descr->sizeof_register[regnum]);
 }
 
@@ -856,10 +856,9 @@
      value in cache.  */
   if (!regcache->passthrough_p)
     {
-      memcpy ((regcache->raw_registers
-	       + regcache->descr->register_offset[regnum]), buf,
+      memcpy (register_buffer (regcache, regnum), buf,
 	      regcache->descr->sizeof_register[regnum]);
-      regcache->raw_register_valid_p[regnum] = 1;
+      regcache->register_valid_p[regnum] = 1;
       return;
     }
 
@@ -881,7 +880,7 @@
   target_prepare_to_store ();
   memcpy (register_buffer (regcache, regnum), buf,
 	  regcache->descr->sizeof_register[regnum]);
-  regcache->raw_register_valid_p[regnum] = 1;
+  regcache->register_valid_p[regnum] = 1;
   target_store_registers (regnum);
 }