GDB, gdbserver: Convert regcache_register_size function to method

The regcache_register_size function has one implementation in GDB, and
one in gdbserver.  Both of them have a gdb::checked_static_cast to their
corresponding regcache class.  This can be avoided by defining a
pure virtual register_size method in the
reg_buffer_common class, which is then implemented by the reg_buffer
class in GDB, and by the regcache class in gdbserver.

Calls to the register_size () function from methods of classes in the
reg_buffer_common hierarchy need to be changed to calls to the newly
defined method, otherwise the compiler complains that a matching method
cannot be found.

Co-Authored-By: Simon Marchi <simon.marchi@efficios.com>
Approved-By: Simon Marchi <simon.marchi@efficios.com>
Reviewed-By: Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Change-Id: I7f4f74a51e96c42604374e87321ca0e569bc07a3

diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index e3e815e1123a97e20dd47b88d1b4bc6144fe668c..9e255bb2d433568bd9afe6dddfc3a753012590bb 100644 (file)
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -211,7 +211,7 @@ amd64_windows_store_arg_in_reg (struct regcache *regcache,
 
   gdb_assert (valbuf.size () <= 8);
   std::copy (valbuf.begin (), valbuf.end (), buf.begin ());
-  size_t reg_size = regcache_register_size (regcache, regno);
+  size_t reg_size = regcache->register_size (regno);
   gdb_assert (reg_size <= buf.size ());
   gdb::array_view<gdb_byte> view (buf);
   regcache->cooked_write (regno, view.slice (0, reg_size));

diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index 96869613d1031799baea0ba678e43b5ed437673c..35a039ed659ba2b75716cc137aaf88a0d064c986 100644 (file)
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -1564,7 +1564,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
                                        byte_order, I387_FCTRL_INIT_VAL);
              else
                memset (FXSAVE_ADDR (tdep, regs, i), 0,
-                       regcache_register_size (regcache, i));
+                       regcache->register_size (i));
            }
        }
     }
@@ -1887,7 +1887,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
            int regsize;
 
            regcache->raw_collect (i, raw);
-           regsize = regcache_register_size (regcache, i);
+           regsize = regcache->register_size (i);
            p = FXSAVE_ADDR (tdep, regs, i);
            if (memcmp (raw, p, regsize))
              {

diff --git a/gdb/nat/aarch64-hw-point.c b/gdb/nat/aarch64-hw-point.c
index 6acee0fb814c48ac43e127254f811397802f0682..8ab91fe85142e7c34770fb8d8ee609b2870b22f9 100644 (file)
--- a/gdb/nat/aarch64-hw-point.c
+++ b/gdb/nat/aarch64-hw-point.c
@@ -166,7 +166,7 @@ aarch64_point_is_aligned (ptid_t ptid, int is_watchpoint, CORE_ADDR addr,
       /* Set alignment to 2 only if the current process is 32-bit,
         since thumb instruction can be 2-byte aligned.  Otherwise, set
         alignment to AARCH64_HBP_ALIGNMENT.  */
-      if (regcache_register_size (regcache, 0) == 8)
+      if (regcache->register_size (0) == 8)
        alignment = AARCH64_HBP_ALIGNMENT;
       else
        alignment = 2;

diff --git a/gdb/regcache-dump.c b/gdb/regcache-dump.c
index 037a232189c751576bcd09728858195aac9d64e8..2719c924ba63d4ef89b1c9715f05878ead436a8c 100644 (file)
--- a/gdb/regcache-dump.c
+++ b/gdb/regcache-dump.c
@@ -113,7 +113,7 @@ protected:
   {
     if (regnum < gdbarch_num_regs (m_gdbarch) || m_has_pseudo)
       {
-       auto size = register_size (m_gdbarch, regnum);
+       auto size = register_size (regnum);
 
        if (size == 0)
          return;

diff --git a/gdb/regcache.c b/gdb/regcache.c
index f2c403b88d0c58352d0e11d3e2c2c92ce2b0c40d..c980b6feb34a0f3b299fdc78722de205008266e7 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -179,10 +179,9 @@ register_size (struct gdbarch *gdbarch, int regnum)
 /* See gdbsupport/common-regcache.h.  */
 
 int
-regcache_register_size (const reg_buffer_common *regcache, int n)
+reg_buffer::register_size (int regnum) const
 {
-  return register_size
-    (gdb::checked_static_cast<const struct regcache *> (regcache)->arch (), n);
+  return ::register_size (this->arch (), regnum);
 }
 
 reg_buffer::reg_buffer (gdbarch *gdbarch, bool has_pseudo)
@@ -939,7 +938,7 @@ register_status
 readable_regcache::read_part (int regnum, int offset,
                              gdb::array_view<gdb_byte> dst, bool is_raw)
 {
-  int reg_size = register_size (arch (), regnum);
+  int reg_size = register_size (regnum);
 
   gdb_assert (offset >= 0);
   gdb_assert (offset + dst.size () <= reg_size);
@@ -983,7 +982,7 @@ void
 reg_buffer::raw_collect_part (int regnum, int offset,
                              gdb::array_view<gdb_byte> dst) const
 {
-  int reg_size = register_size (arch (), regnum);
+  int reg_size = register_size (regnum);
 
   gdb_assert (offset >= 0);
   gdb_assert (offset + dst.size () <= reg_size);
@@ -1013,7 +1012,7 @@ register_status
 regcache::write_part (int regnum, int offset,
                      gdb::array_view<const gdb_byte> src, bool is_raw)
 {
-  int reg_size = register_size (arch (), regnum);
+  int reg_size = register_size (regnum);
 
   gdb_assert (offset >= 0);
   gdb_assert (offset + src.size () <= reg_size);
@@ -1065,7 +1064,7 @@ void
 reg_buffer::raw_supply_part (int regnum, int offset,
                             gdb::array_view<const gdb_byte> src)
 {
-  int reg_size = register_size (arch (), regnum);
+  int reg_size = register_size (regnum);
 
   gdb_assert (offset >= 0);
   gdb_assert (offset + src.size () <= reg_size);
@@ -1236,8 +1235,7 @@ regcache::transfer_regset_register (struct regcache *out_regcache, int regnum,
                                    const gdb_byte *in_buf, gdb_byte *out_buf,
                                    int slot_size, int offs) const
 {
-  struct gdbarch *gdbarch = arch ();
-  int reg_size = std::min (register_size (gdbarch, regnum), slot_size);
+  int reg_size = std::min (register_size (regnum), slot_size);
 
   /* Use part versions and reg_size to prevent possible buffer overflows when
      accessing the regcache.  */
@@ -1254,7 +1252,7 @@ regcache::transfer_regset_register (struct regcache *out_regcache, int regnum,
   else if (in_buf != nullptr)
     {
       /* Zero-extend the register value if the slot is smaller than the register.  */
-      if (slot_size < register_size (gdbarch, regnum))
+      if (slot_size < register_size (regnum))
        out_regcache->raw_supply_zeroed (regnum);
       out_regcache->raw_supply_part (regnum, 0,
                                     gdb::make_array_view (in_buf + offs,

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 71f17b349c9dcb1149cd8d4802dfd0b6a3c21915..347c2b8ce9fbd5eea28961907c3a6d4e896ef7a2 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -260,6 +260,9 @@ public:
   /* See gdbsupport/common-regcache.h.  */
   bool raw_compare (int regnum, const void *buf, int offset) const override;
 
+  /* See gdbsupport/common-regcache.h.  */
+  int register_size (int regnum) const override;
+
 protected:
   /* Assert on the range of REGNUM.  */
   void assert_regnum (int regnum) const;

diff --git a/gdbserver/regcache.cc b/gdbserver/regcache.cc
index 5b064ae04d1e954144a76a06e92325bced5b62c2..0be9c5b7fa81619fbfcba997dd07a84e18b9a37d 100644 (file)
--- a/gdbserver/regcache.cc
+++ b/gdbserver/regcache.cc
@@ -306,10 +306,9 @@ register_size (const struct target_desc *tdesc, int n)
 /* See gdbsupport/common-regcache.h.  */
 
 int
-regcache_register_size (const reg_buffer_common *regcache, int n)
+regcache::register_size (int regnum) const
 {
-  return register_size
-    (gdb::checked_static_cast<const struct regcache *> (regcache)->tdesc, n);
+  return ::register_size (tdesc, regnum);
 }
 
 static gdb::array_view<gdb_byte>

diff --git a/gdbserver/regcache.h b/gdbserver/regcache.h
index 12345a3439cd7dedc70cd06f13450dde58214124..190a06e0a4ad2e12a1357cac383251553d57e31b 100644 (file)
--- a/gdbserver/regcache.h
+++ b/gdbserver/regcache.h
@@ -50,6 +50,9 @@ struct regcache : public reg_buffer_common
   /* See gdbsupport/common-regcache.h.  */
   enum register_status get_register_status (int regnum) const override;
 
+  /* See gdbsupport/common-regcache.h.  */
+  int register_size (int regnum) const override;
+
   /* See gdbsupport/common-regcache.h.  */
   void raw_supply (int regnum, gdb::array_view<const gdb_byte> src) override;
 

diff --git a/gdbsupport/common-regcache.h b/gdbsupport/common-regcache.h
index cd30ae949cad24da287882292c04ff723d59b547..c637163b6248870bc8c29ed60ee52ced2c84e0a7 100644 (file)
--- a/gdbsupport/common-regcache.h
+++ b/gdbsupport/common-regcache.h
@@ -48,11 +48,6 @@ enum register_status : signed char
 
 extern reg_buffer_common *get_thread_regcache_for_ptid (ptid_t ptid);
 
-/* Return the size of register numbered N in REGCACHE.  This function
-   must be provided by the client.  */
-
-extern int regcache_register_size (const reg_buffer_common *regcache, int n);
-
 /* Read the PC register.  This function must be provided by the
    client.  */
 
@@ -78,6 +73,9 @@ struct reg_buffer_common
      buffer.  */
   virtual register_status get_register_status (int regnum) const = 0;
 
+  /* Return the size of register numbered REGNUM in this buffer.  */
+  virtual int register_size (int regnum) const = 0;
+
   /* Supply register REGNUM, whose contents are stored in SRC, to this register
      buffer.  */
   virtual void raw_supply (int regnum, gdb::array_view<const gdb_byte> src)
@@ -90,11 +88,7 @@ struct reg_buffer_common
   }
 
   void raw_supply (int regnum, const gdb_byte *src)
-  {
-    raw_supply (regnum,
-               gdb::make_array_view (src,
-                                     regcache_register_size (this, regnum)));
-  }
+  { raw_supply (regnum, gdb::make_array_view (src, register_size (regnum))); }
 
   /* Supply part of register REGNUM with zeroed value.  Start at OFFSET in
      the register, with size SIZE.  The rest of the register is left
@@ -114,11 +108,7 @@ struct reg_buffer_common
   };
 
   void raw_collect (int regnum, gdb_byte *dst)
-  {
-    raw_collect (regnum,
-                gdb::make_array_view (dst,
-                                      regcache_register_size (this, regnum)));
-  }
+  { raw_collect (regnum, gdb::make_array_view (dst, register_size (regnum))); }
 
   /* Compare the contents of the register stored in the regcache (ignoring the
      first OFFSET bytes) to the contents of BUF (without any offset).  Returns