diff mbox series

[v2,04/11] gdbserver: convert init_register_cache and new_register_cache into constructors

Message ID 20241230-upstream-gdbserver-regcache-v2-4-020a9514fcf0@intel.com
State New
Headers
Series gdbserver: refactor regcache |

Commit Message

Aktemur, Tankut Baris Dec. 30, 2024, 10:49 a.m. UTC 
  This is a refactoring that converts

  init_register_cache (struct regcache *regcache,
                       const struct target_desc *tdesc,
                       unsigned char *regbuf)

into the constructor

  regcache (const target_desc *tdesc, unsigned char *regbuf)

and converts

  new_register_cache (const struct target_desc *tdesc)

into the constructor

  regcache (const target_desc *tdesc)

Also use DISABLE_COPY_AND_ASSIGN for additional compile-time safety.

Tested by rebuilding gdbserver with '--enable-inprocess-agent=no' and
with '--enable-inprocess-agent=yes'.
---
 gdbserver/regcache.cc   | 63 ++++++++++++++++++-------------------------------
 gdbserver/regcache.h    | 14 +++++------
 gdbserver/server.cc     |  2 +-
 gdbserver/tracepoint.cc | 35 ++++++++++++---------------
 4 files changed, 45 insertions(+), 69 deletions(-)

Comments

Simon Marchi Jan. 7, 2025, 4:51 a.m. UTC | #1 
> @@ -112,55 +112,38 @@ regcache_invalidate (void)
>  
>  #endif
>  
> -struct regcache *
> -init_register_cache (struct regcache *regcache,
> -		     const struct target_desc *tdesc,
> -		     unsigned char *regbuf)
> +regcache::regcache (const target_desc *tdesc,
> +		    unsigned char *regbuf)
>  {
> -  if (regbuf == NULL)
> -    {
> -#ifndef IN_PROCESS_AGENT
> -      /* Make sure to zero-initialize the register cache when it is
> -	 created, in case there are registers the target never
> -	 fetches.  This way they'll read as zero instead of
> -	 garbage.  */
> -      regcache->tdesc = tdesc;
> -      regcache->registers
> -	= (unsigned char *) xcalloc (1, tdesc->registers_size);
> -      regcache->registers_owned = true;
> -      regcache->register_status
> -	= (unsigned char *) xmalloc (tdesc->reg_defs.size ());
> -      memset ((void *) regcache->register_status, REG_UNAVAILABLE,
> -	      tdesc->reg_defs.size ());
> -#else
> -      gdb_assert_not_reached ("can't allocate memory from the heap");
> -#endif
> -    }
> -  else
> -    {
> -      regcache->tdesc = tdesc;
> -      regcache->registers = regbuf;
> -      regcache->registers_owned = false;
> +  gdb_assert (regbuf != nullptr);
> +
> +  this->tdesc = tdesc;
> +  this->registers = regbuf;
> +  this->registers_owned = false;
>  #ifndef IN_PROCESS_AGENT
> -      regcache->register_status = NULL;
> +  this->register_status = nullptr;
>  #endif

These could be initialized in an initialization list.

> -    }
> -
> -  regcache->registers_fetched = false;
> -
> -  return regcache;
> +  this->registers_fetched = false;
>  }
>  
>  #ifndef IN_PROCESS_AGENT
>  
> -struct regcache *
> -new_register_cache (const struct target_desc *tdesc)
> +regcache::regcache (const target_desc *tdesc)
>  {
> -  struct regcache *regcache = new struct regcache;
> -
>    gdb_assert (tdesc->registers_size != 0);
>  
> -  return init_register_cache (regcache, tdesc, NULL);
> +  /* Make sure to zero-initialize the register cache when it is
> +     created, in case there are registers the target never
> +     fetches.  This way they'll read as zero instead of
> +     garbage.  */
> +  this->tdesc = tdesc;
> +  this->registers
> +    = (unsigned char *) xcalloc (1, tdesc->registers_size);
> +  this->registers_owned = true;
> +  this->register_status
> +    = (unsigned char *) xmalloc (tdesc->reg_defs.size ());

Same here.

> diff --git a/gdbserver/regcache.h b/gdbserver/regcache.h
> index 12345a3439cd7dedc70cd06f13450dde58214124..ea6c26a37a07bf6d336d6bdf327d543fae0b6370 100644
> --- a/gdbserver/regcache.h
> +++ b/gdbserver/regcache.h
> @@ -45,7 +45,13 @@ struct regcache : public reg_buffer_common
>  #ifndef IN_PROCESS_AGENT
>    /* One of REG_UNAVAILABLE or REG_VALID.  */
>    unsigned char *register_status = nullptr;
> +
> +  /* Constructors.  */
> +  regcache (const target_desc *tdesc);
>  #endif
> +  regcache (const target_desc *tdesc, unsigned char *regbuf);

I don't think the "Constructors" is that helpful.  On the other hand, I
would appreciate a comment saying what the constructor with `regbuf`
does differently from the other one (I guess use that buffer to store
register data instead of dynamically allocating?).

> diff --git a/gdbserver/tracepoint.cc b/gdbserver/tracepoint.cc
> index 1b6e9d05273ea7a709f1880473c070c59169ddd5..9a00d1f272f905cadbc87265ed0be3d87f7b54df 100644
> --- a/gdbserver/tracepoint.cc
> +++ b/gdbserver/tracepoint.cc
> @@ -1288,7 +1288,7 @@ struct tracepoint_hit_ctx
>  struct fast_tracepoint_ctx : public tracepoint_hit_ctx
>  {
>    fast_tracepoint_ctx (unsigned char *_regs)
> -    : regcache_initted (0), regs (_regs)
> +    : regcache (), regs (_regs)

`regcache ()` becomes unnecessary.

Simon
diff mbox series

Patch

diff --git a/gdbserver/regcache.cc b/gdbserver/regcache.cc
index b5c3b7e9cbaf6c267bf1b4a3d3a5ecf4f8788135..11957af351d476d47eb4b9eacb810ac2f6aded40 100644
--- a/gdbserver/regcache.cc
+++ b/gdbserver/regcache.cc
@@ -42,7 +42,7 @@  get_thread_regcache (thread_info *thread, bool fetch)
 
       gdb_assert (proc->tdesc != NULL);
 
-      regcache = new_register_cache (proc->tdesc);
+      regcache = new struct regcache (proc->tdesc);
       thread->set_regcache (regcache);
     }
 
@@ -112,55 +112,38 @@  regcache_invalidate (void)
 
 #endif
 
-struct regcache *
-init_register_cache (struct regcache *regcache,
-		     const struct target_desc *tdesc,
-		     unsigned char *regbuf)
+regcache::regcache (const target_desc *tdesc,
+		    unsigned char *regbuf)
 {
-  if (regbuf == NULL)
-    {
-#ifndef IN_PROCESS_AGENT
-      /* Make sure to zero-initialize the register cache when it is
-	 created, in case there are registers the target never
-	 fetches.  This way they'll read as zero instead of
-	 garbage.  */
-      regcache->tdesc = tdesc;
-      regcache->registers
-	= (unsigned char *) xcalloc (1, tdesc->registers_size);
-      regcache->registers_owned = true;
-      regcache->register_status
-	= (unsigned char *) xmalloc (tdesc->reg_defs.size ());
-      memset ((void *) regcache->register_status, REG_UNAVAILABLE,
-	      tdesc->reg_defs.size ());
-#else
-      gdb_assert_not_reached ("can't allocate memory from the heap");
-#endif
-    }
-  else
-    {
-      regcache->tdesc = tdesc;
-      regcache->registers = regbuf;
-      regcache->registers_owned = false;
+  gdb_assert (regbuf != nullptr);
+
+  this->tdesc = tdesc;
+  this->registers = regbuf;
+  this->registers_owned = false;
 #ifndef IN_PROCESS_AGENT
-      regcache->register_status = NULL;
+  this->register_status = nullptr;
 #endif
-    }
-
-  regcache->registers_fetched = false;
-
-  return regcache;
+  this->registers_fetched = false;
 }
 
 #ifndef IN_PROCESS_AGENT
 
-struct regcache *
-new_register_cache (const struct target_desc *tdesc)
+regcache::regcache (const target_desc *tdesc)
 {
-  struct regcache *regcache = new struct regcache;
-
   gdb_assert (tdesc->registers_size != 0);
 
-  return init_register_cache (regcache, tdesc, NULL);
+  /* Make sure to zero-initialize the register cache when it is
+     created, in case there are registers the target never
+     fetches.  This way they'll read as zero instead of
+     garbage.  */
+  this->tdesc = tdesc;
+  this->registers
+    = (unsigned char *) xcalloc (1, tdesc->registers_size);
+  this->registers_owned = true;
+  this->register_status
+    = (unsigned char *) xmalloc (tdesc->reg_defs.size ());
+  memset ((void *) this->register_status, REG_UNAVAILABLE,
+	  tdesc->reg_defs.size ());
 }
 
 void
diff --git a/gdbserver/regcache.h b/gdbserver/regcache.h
index 12345a3439cd7dedc70cd06f13450dde58214124..ea6c26a37a07bf6d336d6bdf327d543fae0b6370 100644
--- a/gdbserver/regcache.h
+++ b/gdbserver/regcache.h
@@ -45,7 +45,13 @@  struct regcache : public reg_buffer_common
 #ifndef IN_PROCESS_AGENT
   /* One of REG_UNAVAILABLE or REG_VALID.  */
   unsigned char *register_status = nullptr;
+
+  /* Constructors.  */
+  regcache (const target_desc *tdesc);
 #endif
+  regcache (const target_desc *tdesc, unsigned char *regbuf);
+
+  DISABLE_COPY_AND_ASSIGN (regcache);
 
   /* See gdbsupport/common-regcache.h.  */
   enum register_status get_register_status (int regnum) const override;
@@ -66,14 +72,6 @@  struct regcache : public reg_buffer_common
   void copy_from (regcache *src);
 };
 
-struct regcache *init_register_cache (struct regcache *regcache,
-				      const struct target_desc *tdesc,
-				      unsigned char *regbuf);
-
-/* Create a new register cache for INFERIOR.  */
-
-struct regcache *new_register_cache (const struct target_desc *tdesc);
-
 regcache *get_thread_regcache (thread_info *thread, bool fetch = true);
 
 /* Release all memory associated with the register cache for INFERIOR.  */
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 55898f59556b2d16bebe319e48321cdfb0cc9f89..a4d654de00adf014e28b0ce022ba8a5886ee77ce 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -4704,7 +4704,7 @@  process_serial_event (void)
       if (cs.current_traceframe >= 0)
 	{
 	  struct regcache *regcache
-	    = new_register_cache (current_target_desc ());
+	    = new struct regcache (current_target_desc ());
 
 	  if (fetch_traceframe_registers (cs.current_traceframe,
 					  regcache, -1) == 0)
diff --git a/gdbserver/tracepoint.cc b/gdbserver/tracepoint.cc
index 1b6e9d05273ea7a709f1880473c070c59169ddd5..9a00d1f272f905cadbc87265ed0be3d87f7b54df 100644
--- a/gdbserver/tracepoint.cc
+++ b/gdbserver/tracepoint.cc
@@ -1288,7 +1288,7 @@  struct tracepoint_hit_ctx
 struct fast_tracepoint_ctx : public tracepoint_hit_ctx
 {
   fast_tracepoint_ctx (unsigned char *_regs)
-    : regcache_initted (0), regs (_regs)
+    : regcache (), regs (_regs)
   {
   }
 
@@ -1296,8 +1296,7 @@  struct fast_tracepoint_ctx : public tracepoint_hit_ctx
 
   /* The regcache corresponding to the registers state at the time of
      the tracepoint hit.  Initialized lazily, from REGS.  */
-  struct regcache regcache;
-  int regcache_initted;
+  std::optional<struct regcache> regcache;
 
   /* The buffer space REGCACHE above uses.  We use a separate buffer
      instead of letting the regcache malloc for both signal safety and
@@ -4695,15 +4694,15 @@  fast_tracepoint_ctx::get_regcache ()
 {
   const struct target_desc *ipa_tdesc = get_ipa_tdesc (ipa_tdesc_idx);
 
-  if (!this->regcache_initted)
+  if (!this->regcache.has_value ())
     {
-      this->regcache_initted = 1;
-      init_register_cache (&this->regcache, ipa_tdesc, this->regspace);
-      supply_regblock (&this->regcache, nullptr);
-      supply_fast_tracepoint_registers (&this->regcache, this->regs);
+      this->regcache.emplace (ipa_tdesc, this->regspace);
+      supply_regblock (&this->regcache.value (), nullptr);
+      supply_fast_tracepoint_registers (&this->regcache.value (),
+					this->regs);
     }
 
-  return &this->regcache;
+  return &this->regcache.value ();
 }
 
 struct regcache *
@@ -4712,20 +4711,19 @@  static_tracepoint_ctx::get_regcache ()
 #ifdef HAVE_UST
   const struct target_desc *ipa_tdesc = get_ipa_tdesc (ipa_tdesc_idx);
 
-  if (!this->regcache_initted)
+  if (!this->regcache.has_value ())
     {
-      this->regcache_initted = 1;
-      init_register_cache (&this->regcache, ipa_tdesc, this->regspace);
-      supply_regblock (&this->regcache, nullptr);
+      this->regcache.emplace (ipa_tdesc, this->regspace);
+      supply_regblock (&this->regcache.value (), nullptr);
       /* Pass down the tracepoint address, because REGS doesn't
 	 include the PC, but we know what it must have been.  */
-      supply_static_tracepoint_registers (&this->regcache,
+      supply_static_tracepoint_registers (&this->regcache.value (),
 					  (const unsigned char *)
 					  this->regs,
 					  this->tpoint->address);
     }
 
-  return &this->regcache;
+  return &this->regcache.value ();
 #else
   gdb_assert_not_reached ("static tracepoint feature requires UST");
 #endif
@@ -4773,7 +4771,6 @@  do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx,
     case 'R':
       {
 	unsigned char *regspace;
-	struct regcache tregcache;
 	int regcache_size;
 
 	trace_debug ("Want to collect registers");
@@ -4793,8 +4790,7 @@  do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx,
 
 	/* Wrap the regblock in a register cache (in the stack, we
 	   don't want to malloc here).  */
-	init_register_cache (&tregcache, context_regcache->tdesc,
-			     regspace + 1);
+	regcache tregcache (context_regcache->tdesc, regspace + 1);
 
 	/* Copy the register data to the regblock.  */
 	tregcache.copy_from (context_regcache);
@@ -5190,7 +5186,6 @@  fetch_traceframe_registers (int tfnum, struct regcache *regcache, int regnum)
 static CORE_ADDR
 traceframe_get_pc (struct traceframe *tframe)
 {
-  struct regcache regcache;
   unsigned char *dataptr;
   const struct target_desc *tdesc = current_target_desc ();
 
@@ -5198,7 +5193,7 @@  traceframe_get_pc (struct traceframe *tframe)
   if (dataptr == NULL)
     return 0;
 
-  init_register_cache (&regcache, tdesc, dataptr);
+  regcache regcache (tdesc, dataptr);
   return regcache_read_pc (&regcache);
 }