diff mbox

[RFA,4/5] Remove make_cleanup_regcache_invalidate

Message ID 20170924024608.4346-5-tom@tromey.com
State New, archived
Headers

Commit Message

Tom Tromey Sept. 24, 2017, 2:46 a.m. UTC 
  This removes make_cleanup_regcache_invalidate in favor of a simple
RAII class that handles register invalidation.

ChangeLog
2017-09-23  Tom Tromey  <tom@tromey.com>

	* regcache.c (class regcache_invalidator): New.
	(struct register_to_invalidate): Remove.
	(make_cleanup_regcache_invalidate): Remove.
	(regcache::raw_write): Use regcache_invalidator.
---
 gdb/ChangeLog  |  7 +++++++
 gdb/regcache.c | 56 ++++++++++++++++++++++++++++++--------------------------
 2 files changed, 37 insertions(+), 26 deletions(-)

Comments

Yao Qi Sept. 25, 2017, 8:04 p.m. UTC | #1 
[I am in the travel, and fighting with jet-lag.  Forgive me if I make
any stupid mistakes.]

On 17-09-23 20:46:07, Tom Tromey wrote:
>  
> -  regcache_invalidate (reg->regcache, reg->regnum);
> -}
> +  ~regcache_invalidator ()
> +  {
> +    if (m_regcache != nullptr)
> +      regcache_invalidator (m_regcache, m_regnum);

m_regcache->invalidate (m_regnum)?

I don't see why we need to call ctor in dtor.
Tom Tromey Sept. 26, 2017, 1:36 a.m. UTC | #2 
>>>>> "Yao" == Yao Qi <qiyaoltc@gmail.com> writes:

>> +      regcache_invalidator (m_regcache, m_regnum);

m_regcache-> invalidate (m_regnum)?

Yao> I don't see why we need to call ctor in dtor.

Ouch, yeah.
I'll fix.

Tom
Tom Tromey Sept. 26, 2017, 1:56 a.m. UTC | #3 
>> m_regcache->invalidate (m_regnum)?

For the record, it was supposed to call regcache_invalidate here.

Tom
diff mbox

Patch

diff --git a/gdb/regcache.c b/gdb/regcache.c
index ab6a651..46d8cfb 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -241,31 +241,36 @@  regcache_get_ptid (const struct regcache *regcache)
   return regcache->ptid ();
 }
 
-/* Cleanup routines for invalidating a register.  */
+/* Cleanup class for invalidating a register.  */
 
-struct register_to_invalidate
+class regcache_invalidator
 {
-  struct regcache *regcache;
-  int regnum;
-};
+public:
 
-static void
-do_regcache_invalidate (void *data)
-{
-  struct register_to_invalidate *reg = (struct register_to_invalidate *) data;
+  regcache_invalidator (struct regcache *regcache, int regnum)
+    : m_regcache (regcache),
+      m_regnum (regnum)
+  {
+  }
 
-  regcache_invalidate (reg->regcache, reg->regnum);
-}
+  ~regcache_invalidator ()
+  {
+    if (m_regcache != nullptr)
+      regcache_invalidator (m_regcache, m_regnum);
+  }
 
-static struct cleanup *
-make_cleanup_regcache_invalidate (struct regcache *regcache, int regnum)
-{
-  struct register_to_invalidate* reg = XNEW (struct register_to_invalidate);
+  DISABLE_COPY_AND_ASSIGN (regcache_invalidator);
 
-  reg->regcache = regcache;
-  reg->regnum = regnum;
-  return make_cleanup_dtor (do_regcache_invalidate, (void *) reg, xfree);
-}
+  void release ()
+  {
+    m_regcache = nullptr;
+  }
+
+private:
+
+  struct regcache *m_regcache;
+  int m_regnum;
+};
 
 /* Return REGCACHE's architecture.  */
 
@@ -860,7 +865,6 @@  regcache_raw_write (struct regcache *regcache, int regnum,
 void
 regcache::raw_write (int regnum, const gdb_byte *buf)
 {
-  struct cleanup *old_chain;
 
   gdb_assert (buf != NULL);
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
@@ -881,15 +885,15 @@  regcache::raw_write (int regnum, const gdb_byte *buf)
   target_prepare_to_store (this);
   raw_set_cached_value (regnum, buf);
 
-  /* Register a cleanup function for invalidating the register after it is
-     written, in case of a failure.  */
-  old_chain = make_cleanup_regcache_invalidate (this, regnum);
+  /* Invalidate the register after it is written, in case of a
+     failure.  */
+  regcache_invalidator invalidator (this, regnum);
 
   target_store_registers (this, regnum);
 
-  /* The target did not throw an error so we can discard invalidating the
-     register and restore the cleanup chain to what it was.  */
-  discard_cleanups (old_chain);
+  /* The target did not throw an error so we can discard invalidating
+     the register.  */
+  invalidator.release ();
 }
 
 void