[PATCH 7/7]: Regcache: Refactor raw_set_cached_value

diff --git a/gdb/gdbarch-selftests.c b/gdb/gdbarch-selftests.c
index a6251d2a9f87ccff310f90eb5c27bc4199844f22..dbb0f810f951a87a56115d7fb1c392fc7eb0f9c1 100644 (file)
--- a/gdb/gdbarch-selftests.c
+++ b/gdb/gdbarch-selftests.c
@@ -40,7 +40,8 @@ public:
 
   void raw_write (int regnum, const gdb_byte *buf) override
   {
-    raw_set_cached_value (regnum, buf);
+    /* Bypass writing to the target.  */
+    regcache::raw_write (regnum, buf);
   }
 };
 

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 9d04c7be904cfb17ac8fd871e9d7678df1694dfd..1fcb4d21332385ba094c23963a3b9db078a7ae3d 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -604,8 +604,7 @@ regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 enum register_status
 regcache::raw_read (int regnum, gdb_byte *buf)
 {
-  raw_collect (regnum, buf);
-  return (enum register_status) m_register_status[regnum];
+  return raw_get_cached_reg (regnum, buf);
 }
 
 enum register_status
@@ -616,13 +615,7 @@ target_regcache::raw_read (int regnum, gdb_byte *buf)
   /* Read register value from the target into the regcache.  */
   raw_update (regnum);
 
-  if (m_register_status[regnum] != REG_VALID)
-    memset (buf, 0, m_descr->sizeof_register[regnum]);
-  else
-    memcpy (buf, register_buffer (regnum),
-           m_descr->sizeof_register[regnum]);
-
-  return (enum register_status) m_register_status[regnum];
+  return raw_get_cached_reg (regnum, buf);
 }
 
 enum register_status
@@ -852,21 +845,42 @@ regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
   regcache->cooked_write (regnum, val);
 }
 
-/* See regcache.h.  */
-
 void
-regcache_raw_set_cached_value (struct regcache *regcache, int regnum,
-                              const gdb_byte *buf)
+regcache::raw_set_cached_reg (int regnum, const gdb_byte *buf)
 {
-  regcache->raw_set_cached_value (regnum, buf);
+  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
+  gdb_assert (!m_readonly_p);
+
+  if (buf)
+    {
+      memcpy (register_buffer (regnum), buf, m_descr->sizeof_register[regnum]);
+      m_register_status[regnum] = REG_VALID;
+    }
+  else
+    {
+      /* This memset not strictly necessary, but better than garbage
+        in case the register value manages to escape somewhere (due
+        to a bug, no less).  */
+      memset (register_buffer (regnum), 0, m_descr->sizeof_register[regnum]);
+      m_register_status[regnum] = REG_UNAVAILABLE;
+    }
+
+  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
 }
 
-void
-regcache::raw_set_cached_value (int regnum, const gdb_byte *buf)
+enum register_status
+regcache::raw_get_cached_reg (int regnum, gdb_byte *buf) const
 {
-  memcpy (register_buffer (regnum), buf,
-         m_descr->sizeof_register[regnum]);
-  m_register_status[regnum] = REG_VALID;
+  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
+  gdb_assert (buf != NULL);
+
+  if (m_register_status[regnum] != REG_VALID)
+    memset (buf, 0, m_descr->sizeof_register[regnum]);
+  else
+    memcpy (buf, register_buffer (regnum),
+           m_descr->sizeof_register[regnum]);
+
+  return (enum register_status) m_register_status[regnum];
 }
 
 void
@@ -880,16 +894,14 @@ regcache_raw_write (struct regcache *regcache, int regnum,
 void
 regcache::raw_write (int regnum, const gdb_byte *buf)
 {
-  gdb_assert (buf != NULL);
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  gdb_assert (!m_readonly_p);
 
   /* 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 (gdbarch_cannot_store_register (arch (), regnum))
     return;
 
-  raw_set_cached_value (regnum, buf);
+  raw_set_cached_reg (regnum, buf);
 }
 
 void
@@ -913,7 +925,7 @@ target_regcache::raw_write (int regnum, const gdb_byte *buf)
     return;
 
   target_prepare_to_store (this);
-  raw_set_cached_value (regnum, buf);
+  raw_set_cached_reg (regnum, buf);
 
   /* Register a cleanup function for invalidating the register after it is
      written, in case of a failure.  */
@@ -1072,28 +1084,7 @@ regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 void
 regcache::raw_supply (int regnum, const void *buf)
 {
-  void *regbuf;
-  size_t size;
-
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  gdb_assert (!m_readonly_p);
-
-  regbuf = register_buffer (regnum);
-  size = m_descr->sizeof_register[regnum];
-
-  if (buf)
-    {
-      memcpy (regbuf, buf, size);
-      m_register_status[regnum] = REG_VALID;
-    }
-  else
-    {
-      /* This memset not strictly necessary, but better than garbage
-        in case the register value manages to escape somewhere (due
-        to a bug, no less).  */
-      memset (regbuf, 0, size);
-      m_register_status[regnum] = REG_UNAVAILABLE;
-    }
+  raw_set_cached_reg (regnum, (const gdb_byte*) buf);
 }
 
 /* Supply register REGNUM to REGCACHE.  Value to supply is an integer stored at
@@ -1153,15 +1144,7 @@ regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 void
 regcache::raw_collect (int regnum, void *buf) const
 {
-  const void *regbuf;
-  size_t size;
-
-  gdb_assert (buf != NULL);
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-
-  regbuf = register_buffer (regnum);
-  size = m_descr->sizeof_register[regnum];
-  memcpy (buf, regbuf, size);
+  raw_get_cached_reg (regnum, (gdb_byte*) buf);
 }
 
 /* Transfer a single or all registers belonging to a certain register

diff --git a/gdb/regcache.h b/gdb/regcache.h
index f4408a562f84bb2d0dcd2792c646c0f98deee716..f45ab71d92018087e3fe94e3a7a69a87ecaf2e70 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -79,14 +79,6 @@ extern void regcache_raw_write_unsigned (struct regcache *regcache,
 extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
                                        int regnum);
 
-/* Set a raw register's value in the regcache's buffer.  Unlike
-   regcache_raw_write, this is not write-through.  The intention is
-   allowing to change the buffer contents of a read-only regcache
-   allocated with regcache_xmalloc.  */
-
-extern void regcache_raw_set_cached_value
-  (struct regcache *regcache, int regnum, const gdb_byte *buf);
-
 /* Partial transfer of raw registers.  These perform read, modify,
    write style operations.  The read variant returns the status of the
    register.  */
@@ -301,8 +293,6 @@ public:
 
   virtual enum register_status get_register_status (int regnum) const;
 
-  void raw_set_cached_value (int regnum, const gdb_byte *buf);
-
   void invalidate (int regnum);
 
   enum register_status raw_read_part (int regnum, int offset, int len,
@@ -339,6 +329,10 @@ protected:
 
   gdb_byte *register_buffer (int regnum) const;
 
+  /* Get/Set the cached contents of the regcache.  */
+  void raw_set_cached_reg (int regnum, const gdb_byte *buf);
+  enum register_status raw_get_cached_reg (int regnum, gdb_byte *buf) const;
+
   struct regcache_descr *m_descr;
 
   /* The address space of this register cache (for registers where it