[binutils-gdb] regcache: Add collect/supply_regset variants that accept a register base.

[binutils-gdb] regcache: Add collect/supply_regset variants that accept a register base.

[John Baldwin]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=0ee9f16cf9ff849fda1555033ae0ce78d028bf86

commit 0ee9f16cf9ff849fda1555033ae0ce78d028bf86
Author: John Baldwin <jhb@FreeBSD.org>
Date:   Tue Nov 22 14:21:13 2022 -0800

    regcache: Add collect/supply_regset variants that accept a register base.
    
    Some register sets described by an array of regcache_map_entry
    structures do not have fixed register numbers in their associated
    architecture but do describe a block of registers whose numbers are at
    fixed offsets relative to some base register value.  An example of
    this are the TLS register sets for the ARM and AArch64 architectures.
    
    Currently OS-specific architectures create register maps and register
    sets dynamically using the register base number.  However, this
    requires duplicating the code to create the register map and register
    set.  To reduce duplication, add variants of the collect_regset and
    supply_regset regcache methods which accept a base register number.
    For valid register map entries (i.e. not REGCACHE_MAP_SKIP), add this
    base register number to the value from the map entry to determine the
    final register number.
    
    Approved-By: Simon Marchi <simon.marchi@efficios.com>

Diff:
---
 gdb/regcache.c | 21 ++++++++++++++-------
 gdb/regcache.h | 26 +++++++++++++++++++++++---
 2 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 650e5bbe955..02d6bdc271c 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -1185,7 +1185,7 @@ regcache::transfer_regset_register (struct regcache *out_regcache, int regnum,
 /* See regcache.h.  */
 
 void
-regcache::transfer_regset (const struct regset *regset,
+regcache::transfer_regset (const struct regset *regset, int regbase,
 			   struct regcache *out_regcache,
 			   int regnum, const gdb_byte *in_buf,
 			   gdb_byte *out_buf, size_t size) const
@@ -1200,6 +1200,9 @@ regcache::transfer_regset (const struct regset *regset,
       int regno = map->regno;
       int slot_size = map->size;
 
+      if (regno != REGCACHE_MAP_SKIP)
+	regno += regbase;
+
       if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
 	slot_size = m_descr->sizeof_register[regno];
 
@@ -1243,11 +1246,14 @@ regcache_supply_regset (const struct regset *regset,
   regcache->supply_regset (regset, regnum, (const gdb_byte *) buf, size);
 }
 
+/* See regcache.h.  */
+
 void
-regcache::supply_regset (const struct regset *regset,
+regcache::supply_regset (const struct regset *regset, int regbase,
 			 int regnum, const void *buf, size_t size)
 {
-  transfer_regset (regset, this, regnum, (const gdb_byte *) buf, nullptr, size);
+  transfer_regset (regset, regbase, this, regnum, (const gdb_byte *) buf,
+		   nullptr, size);
 }
 
 /* Collect register REGNUM from REGCACHE to BUF, using the register
@@ -1262,15 +1268,16 @@ regcache_collect_regset (const struct regset *regset,
   regcache->collect_regset (regset, regnum, (gdb_byte *) buf, size);
 }
 
+/* See regcache.h  */
+
 void
-regcache::collect_regset (const struct regset *regset,
+regcache::collect_regset (const struct regset *regset, int regbase,
 			 int regnum, void *buf, size_t size) const
 {
-  transfer_regset (regset, nullptr, regnum, nullptr, (gdb_byte *) buf, size);
+  transfer_regset (regset, regbase, nullptr, regnum, nullptr, (gdb_byte *) buf,
+		   size);
 }
 
-/* See regcache.h  */
-
 bool
 regcache_map_supplies (const struct regcache_map_entry *map, int regnum,
 		       struct gdbarch *gdbarch, size_t size)
diff --git a/gdb/regcache.h b/gdb/regcache.h
index 1dbba5ce9af..2b2717fa2d4 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -375,12 +375,32 @@ public:
   void cooked_write_part (int regnum, int offset, int len,
 			  const gdb_byte *buf);
 
-  void supply_regset (const struct regset *regset,
+  /* Transfer a set of registers (as described by REGSET) between
+     REGCACHE and BUF.  If REGNUM == -1, transfer all registers
+     belonging to the regset, otherwise just the register numbered
+     REGNUM.  The REGSET's 'regmap' field must point to an array of
+     'struct regcache_map_entry'.  The valid register numbers in each
+     entry in 'struct regcache_map_entry' are offset by REGBASE.  */
+
+  void supply_regset (const struct regset *regset, int regbase,
 		      int regnum, const void *buf, size_t size);
 
+  void collect_regset (const struct regset *regset, int regbase, int regnum,
+		       void *buf, size_t size) const;
+
+  /* Same as the above, but with REGBASE == 0.  */
+
+  void supply_regset (const struct regset *regset,
+		      int regnum, const void *buf, size_t size)
+  {
+    supply_regset (regset, 0, regnum, buf, size);
+  }
 
   void collect_regset (const struct regset *regset, int regnum,
-		       void *buf, size_t size) const;
+		       void *buf, size_t size) const
+  {
+    collect_regset (regset, 0, regnum, buf, size);
+  }
 
   /* Return REGCACHE's ptid.  */
 
@@ -419,7 +439,7 @@ private:
   /* Transfer a single or all registers belonging to a certain register
      set to or from a buffer.  This is the main worker function for
      regcache_supply_regset and regcache_collect_regset.  */
-  void transfer_regset (const struct regset *regset,
+  void transfer_regset (const struct regset *regset, int regbase,
 			struct regcache *out_regcache,
 			int regnum, const gdb_byte *in_buf,
 			gdb_byte *out_buf, size_t size) const;