Fix for PR gdb/209, PR gdb/156:

[deliverable/binutils-gdb.git] / gdb / regcache.c

diff --git a/gdb/regcache.c b/gdb/regcache.c
index bbc83e029997b8625b96326b7feeecac9bafe07a..ae893454312e4e8cb4ad92d39881cb3fcba4a888 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -90,7 +90,7 @@ register_changed (int regnum)
 /* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
    else return a pointer to the start of the cache buffer.  */
 
-char *
+static char *
 register_buffer (int regnum)
 {
   if (regnum < 0)
@@ -230,9 +230,6 @@ read_register_bytes (int in_start, char *in_buf, int in_len)
       int end;
       int byte;
 
-      if (REGISTER_NAME (regnum) == NULL || *REGISTER_NAME (regnum) == '\0')
-       continue;
-
       reg_start = REGISTER_BYTE (regnum);
       reg_len = REGISTER_RAW_SIZE (regnum);
       reg_end = reg_start + reg_len;
@@ -241,8 +238,18 @@ read_register_bytes (int in_start, char *in_buf, int in_len)
        /* The range the user wants to read doesn't overlap with regnum.  */
        continue;
 
-      /* Force the cache to fetch the entire register. */
-      read_register_gen (regnum, reg_buf);
+      if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
+       /* Force the cache to fetch the entire register.  */
+       read_register_gen (regnum, reg_buf);
+      else
+       /* Legacy note: even though this register is ``invalid'' we
+           still need to return something.  It would appear that some
+           code relies on apparent gaps in the register array also
+           being returned.  */
+       /* FIXME: cagney/2001-08-18: This is just silly.  It defeats
+           the entire register read/write flow of control.  Must
+           resist temptation to return 0xdeadbeef.  */
+       memcpy (reg_buf, registers + reg_start, reg_len);
 
       /* Legacy note: This function, for some reason, allows a NULL
          input buffer.  If the buffer is NULL, the registers are still
@@ -315,11 +322,6 @@ read_register_gen (int regnum, char *buf)
 /* Write register REGNUM at MYADDR to the target.  MYADDR points at
    REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order.  */
 
-/* Registers we shouldn't try to store.  */
-#if !defined (CANNOT_STORE_REGISTER)
-#define CANNOT_STORE_REGISTER(regnum) 0
-#endif
-
 static void
 legacy_write_register_gen (int regnum, char *myaddr)
 {
@@ -339,15 +341,16 @@ legacy_write_register_gen (int regnum, char *myaddr)
 
   size = REGISTER_RAW_SIZE (regnum);
 
-  /* 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)
-    return;
-
   if (real_register (regnum))
-    target_prepare_to_store ();
+    {
+      /* 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)
+       return;
+      else
+       target_prepare_to_store ();
+    }
 
   memcpy (register_buffer (regnum), myaddr, size);
 
@@ -565,6 +568,13 @@ supply_register (int regnum, char *val)
 #endif
 }
 
+void
+regcache_collect (int regnum, void *buf)
+{
+  memcpy (buf, register_buffer (regnum), REGISTER_RAW_SIZE (regnum));
+}
+
+
 /* read_pc, write_pc, read_sp, write_sp, read_fp, write_fp, etc.
    Special handling for registers PC, SP, and FP.  */