diff options
author | Alan Hayward <alan.hayward@arm.com> | 2017-08-15 16:41:00 +0100 |
---|---|---|
committer | Alan Hayward <alan.hayward@arm.com> | 2017-08-15 16:41:00 +0100 |
commit | 8cc29a6ace049443f969cd189058ad7e0e21a4ba (patch) | |
tree | b93d8df3b1011365f2eff49d5a0993d66f01232a | |
parent | a20c2452a4eaa98024ef6982318945dbbf2d4ca7 (diff) | |
download | fsf-binutils-gdb-8cc29a6ace049443f969cd189058ad7e0e21a4ba.zip fsf-binutils-gdb-8cc29a6ace049443f969cd189058ad7e0e21a4ba.tar.gz fsf-binutils-gdb-8cc29a6ace049443f969cd189058ad7e0e21a4ba.tar.bz2 |
[PATCH 7/7]: Regcache: Refactor raw_set_cached_valueusers/alahay01/targetregcache
-rw-r--r-- | gdb/gdbarch-selftests.c | 3 | ||||
-rw-r--r-- | gdb/regcache.c | 91 | ||||
-rw-r--r-- | gdb/regcache.h | 14 |
3 files changed, 43 insertions, 65 deletions
diff --git a/gdb/gdbarch-selftests.c b/gdb/gdbarch-selftests.c index a6251d2..dbb0f81 100644 --- 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 9d04c7b..1fcb4d2 100644 --- 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 f4408a5..f45ab71 100644 --- 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 |