[patch/rfc] Enforce 1:1 cooked->raw map for raw register range

[Andrew Cagney <ac131313 at ges dot redhat dot com>]

Hello,

This patch follows up the discussion thread:
http://sources.redhat.com/ml/gdb/2002-05/msg00202.html

Cooked registers in the range [0 .. NUM{RAW}REGS) are fetched direct 
from the raw register cache, the call to the gdbarch register read/write 
method being bypassed.

This patch only affects the sh5 target and the sh5 (I'm told) already 
behaves this way.

I'll commit this it in a few days.  I'll also need to adjust the draft 
doco so that this is clearly specified.

enjoy,
Andrew
2002-07-25  Andrew Cagney  <cagney@redhat.com>

	* regcache.c (struct regcache_descr): Rename nr_registers to
	nr_cooked_registers.  Revise comments describing the structure
	member fields.
	(init_regcache_descr): Update.
	(init_legacy_regcache_descr): Update.
	(read_register_gen, write_register_gen): When a cooked register in
	the raw register range, directly access the value from the raw
	register cache.

Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.42
diff -u -r1.42 regcache.c
--- regcache.c	24 Jul 2002 19:43:43 -0000	1.42
+++ regcache.c	25 Jul 2002 21:37:44 -0000
@@ -56,22 +56,25 @@
   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.  */
+  /* The cooked register space.  Each cooked register in the range
+     [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
+     register.  The remaining [NR_RAW_REGISTERS
+     .. NR_COOKED_REGISTERS) (a.k.a. pseudo regiters) are mapped onto
+     both raw registers and memory by the architecture methods
+     gdbarch_register_read and gdbarch_register_write.  */
+  int nr_cooked_registers;
+
+  /* Offset and size (in 8 bit bytes), of reach register in the
+     register cache.  All registers (including those in the range
+     [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
+     Assigning all registers an offset makes it possible to keep
+     legacy code, such as that found in read_register_bytes() and
+     write_register_bytes() working.  */
   long *register_offset;
-
-  /* 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;
 
+  /* Useful constant.  Largest of all the registers.  */
+  long max_register_size;
 };
 
 static void *
@@ -89,19 +92,19 @@
 
   /* 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->nr_raw_registers = descr->nr_registers;
-  descr->sizeof_raw_register_valid_p = descr->nr_registers;
+  descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
+  descr->nr_raw_registers = descr->nr_cooked_registers;
+  descr->sizeof_raw_register_valid_p = descr->nr_cooked_registers;
 
   /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
      code should compute the offets et.al. at runtime.  This currently
      isn't possible because some targets overlap register locations -
      see the mess in read_register_bytes() and write_register_bytes()
      registers.  */
-  descr->sizeof_register = XCALLOC (descr->nr_registers, long);
-  descr->register_offset = XCALLOC (descr->nr_registers, long);
+  descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
+  descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
   descr->max_register_size = 0;
-  for (i = 0; i < descr->nr_registers; i++)
+  for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       descr->register_offset[i] = REGISTER_BYTE (i);
       descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
@@ -111,7 +114,7 @@
 
   /* Come up with the real size of the registers buffer.  */
   descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use.  */
-  for (i = 0; i < descr->nr_registers; i++)
+  for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       long regend;
       /* Keep extending the buffer so that there is always enough
@@ -148,10 +151,10 @@
   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
+  /* Total size of the register space.  The raw registers are mapped
+     directly 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;
+  descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
 
   /* Construct a strictly RAW register cache.  Don't allow pseudo's
      into the register cache.  */
@@ -170,10 +173,10 @@
 
   {
     long offset = 0;
-    descr->sizeof_register = XCALLOC (descr->nr_registers, long);
-    descr->register_offset = XCALLOC (descr->nr_registers, long);
+    descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
+    descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
     descr->max_register_size = 0;
-    for (i = 0; i < descr->nr_registers; i++)
+    for (i = 0; i < descr->nr_cooked_registers; i++)
       {
 	descr->sizeof_register[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
 	descr->register_offset[i] = offset;
@@ -198,7 +201,7 @@
      don't go into infinite recursion trying to, again, create the
      regcache.  */
   set_gdbarch_data (gdbarch, regcache_descr_handle, descr);
-  for (i = 0; i < descr->nr_registers; i++)
+  for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
       gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
@@ -716,7 +719,12 @@
       legacy_read_register_gen (regnum, buf);
       return;
     }
-  gdbarch_register_read (current_gdbarch, regnum, buf);
+  gdb_assert (regnum >= 0);
+  gdb_assert (regnum < current_regcache->descr->nr_cooked_registers);
+  if (regnum < current_regcache->descr->nr_raw_registers)
+    regcache_raw_read (current_regcache, regnum, buf);
+  else
+    gdbarch_register_read (current_gdbarch, regnum, buf);
 }
 
 
@@ -825,7 +833,12 @@
       legacy_write_register_gen (regnum, buf);
       return;
     }
-  gdbarch_register_write (current_gdbarch, regnum, buf);
+  gdb_assert (regnum >= 0);
+  gdb_assert (regnum < current_regcache->descr->nr_cooked_registers);
+  if (regnum < current_regcache->descr->nr_raw_registers)
+    regcache_raw_write (current_regcache, regnum, buf);
+  else
+    gdbarch_register_write (current_gdbarch, regnum, buf);
 }
 
 /* Copy INLEN bytes of consecutive data from memory at MYADDR