Rename regcache_cooked_read_ftype and make a function_view

regcache_cooked_read_ftype can be converted to a function_view, which
allows us to use lambda functions and therefore avoid having to pass an
opaque pointer parameter.

Adjusting the fallouts showed that the "const regcache &" passed to the
readonly_detached_regcache constructor is cast to non-const in
do_cooked_read.  I changed the constructor parameter to be non-const.

Finally, I renamed the typedef from regcache_cooked_read_ftype to
register_read_ftype, since there is nothing that forces us to use it
only for regcaches nor cooked registers.

gdb/ChangeLog:

	* regcache.h (regcache_cooked_read_ftype): Rename to...
	(register_read_ftype): ...this, change type to function_view.
	(class reg_buffer) <save>: Remove src parameter.
	(readonly_detached_regcache) <readonly_detached_regcache>: Make
	parameter non-const in first overload.  Remove src parameter in
	second overload.
	* regcache.c (do_cooked_read): Remove.
	(readonly_detached_regcache::readonly_detached_regcache): Make
	parameter non-const, adjust call to other constructor.
	(reg_buffer::save): Remove src parameter.
	* frame.c (do_frame_register_read): Remove.
	(frame_save_as_regcache): Use lambda function.
	* ppc-linux-tdep.c (ppu2spu_unwind_register): Change type of src
	parameter to ppu2spu_data *.
	(ppu2spu_sniffer): Use lambda function.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ff304feff521b6a3eae2f1f1f78f1abea6c25145..0e4705bd874859bca4043a61f4af52da04808a67 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,21 @@
+2018-06-20  Simon Marchi  <simon.marchi@polymtl.ca>
+
+       * regcache.h (regcache_cooked_read_ftype): Rename to...
+       (register_read_ftype): ...this, change type to function_view.
+       (class reg_buffer) <save>: Remove src parameter.
+       (readonly_detached_regcache) <readonly_detached_regcache>: Make
+       parameter non-const in first overload.  Remove src parameter in
+       second overload.
+       * regcache.c (do_cooked_read): Remove.
+       (readonly_detached_regcache::readonly_detached_regcache): Make
+       parameter non-const, adjust call to other constructor.
+       (reg_buffer::save): Remove src parameter.
+       * frame.c (do_frame_register_read): Remove.
+       (frame_save_as_regcache): Use lambda function.
+       * ppc-linux-tdep.c (ppu2spu_unwind_register): Change type of src
+       parameter to ppu2spu_data *.
+       (ppu2spu_sniffer): Use lambda function.
+
 2018-06-20  Simon Marchi  <simon.marchi@polymtl.ca>
 
        * record-full.c (record_full_target::insert_breakpoint): Remove

diff --git a/gdb/frame.c b/gdb/frame.c
index d8309e7407063b84fe057db2a0fdfd0d53f9c954..450bf3a105ea1c87717a994046ae2ae782b55caf 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -1024,21 +1024,19 @@ get_frame_func (struct frame_info *this_frame)
   return pc;
 }
 
-static enum register_status
-do_frame_register_read (void *src, int regnum, gdb_byte *buf)
-{
-  if (!deprecated_frame_register_read ((struct frame_info *) src, regnum, buf))
-    return REG_UNAVAILABLE;
-  else
-    return REG_VALID;
-}
-
 std::unique_ptr<readonly_detached_regcache>
 frame_save_as_regcache (struct frame_info *this_frame)
 {
+  auto cooked_read = [this_frame] (int regnum, gdb_byte *buf)
+    {
+      if (!deprecated_frame_register_read (this_frame, regnum, buf))
+       return REG_UNAVAILABLE;
+      else
+       return REG_VALID;
+    };
+
   std::unique_ptr<readonly_detached_regcache> regcache
-    (new readonly_detached_regcache (get_frame_arch (this_frame),
-                                    do_frame_register_read, this_frame));
+    (new readonly_detached_regcache (get_frame_arch (this_frame), cooked_read));
 
   return regcache;
 }

diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index f26882fe3c8300d7c3a30c7fdeb67f8eccff9e25..9f4c1fc891b75b8dd2c078a99ddf1a0a832999b3 100644 (file)
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -1371,9 +1371,8 @@ struct ppu2spu_data
 };
 
 static enum register_status
-ppu2spu_unwind_register (void *src, int regnum, gdb_byte *buf)
+ppu2spu_unwind_register (ppu2spu_data *data, int regnum, gdb_byte *buf)
 {
-  struct ppu2spu_data *data = (struct ppu2spu_data *) src;
   enum bfd_endian byte_order = gdbarch_byte_order (data->gdbarch);
 
   if (regnum >= 0 && regnum < SPU_NUM_GPRS)
@@ -1435,12 +1434,14 @@ ppu2spu_sniffer (const struct frame_unwind *self,
                       data.gprs, 0, sizeof data.gprs)
          == sizeof data.gprs)
        {
+         auto cooked_read = [&data] (int regnum, gdb_byte *buf)
+           {
+             return ppu2spu_unwind_register (&data, regnum, buf);
+           };
          struct ppu2spu_cache *cache
            = FRAME_OBSTACK_CALLOC (1, struct ppu2spu_cache);
          std::unique_ptr<readonly_detached_regcache> regcache
-           (new readonly_detached_regcache (data.gdbarch,
-                                            ppu2spu_unwind_register,
-                                            &data));
+           (new readonly_detached_regcache (data.gdbarch, cooked_read));
 
          cache->frame_id = frame_id_build (base, func);
          cache->regcache = regcache.release ();

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 750ea2ad30f60b03dd76fc30cb72f87d5a531406..25436bb456ee0f3b3f748afc29737c4732f9f4c9 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -205,16 +205,12 @@ regcache::regcache (gdbarch *gdbarch, const address_space *aspace_)
   m_ptid = minus_one_ptid;
 }
 
-static enum register_status
-do_cooked_read (void *src, int regnum, gdb_byte *buf)
-{
-  struct regcache *regcache = (struct regcache *) src;
-
-  return regcache->cooked_read (regnum, buf);
-}
-
-readonly_detached_regcache::readonly_detached_regcache (const regcache &src)
-  : readonly_detached_regcache (src.arch (), do_cooked_read, (void *) &src)
+readonly_detached_regcache::readonly_detached_regcache (regcache &src)
+  : readonly_detached_regcache (src.arch (),
+                               [&src] (int regnum, gdb_byte *buf)
+                                 {
+                                   return src.cooked_read (regnum, buf);
+                                 })
 {
 }
 
@@ -264,8 +260,7 @@ reg_buffer::register_buffer (int regnum) const
 }
 
 void
-reg_buffer::save (regcache_cooked_read_ftype *cooked_read,
-                 void *src)
+reg_buffer::save (register_read_ftype cooked_read)
 {
   struct gdbarch *gdbarch = m_descr->gdbarch;
   int regnum;
@@ -284,7 +279,7 @@ reg_buffer::save (regcache_cooked_read_ftype *cooked_read,
       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
        {
          gdb_byte *dst_buf = register_buffer (regnum);
-         enum register_status status = cooked_read (src, regnum, dst_buf);
+         enum register_status status = cooked_read (regnum, dst_buf);
 
          gdb_assert (status != REG_UNKNOWN);
 

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 41465fb20d0dcdddaf39e47c1fc79f1e8eadc260..74ac8583bc91d9dbe90144b4cdd405b7d6789140 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -125,9 +125,8 @@ extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
    
 extern int register_size (struct gdbarch *gdbarch, int regnum);
 
-typedef enum register_status (regcache_cooked_read_ftype) (void *src,
-                                                          int regnum,
-                                                          gdb_byte *buf);
+typedef gdb::function_view<register_status (int regnum, gdb_byte *buf)>
+  register_read_ftype;
 
 /* A (register_number, register_value) pair.  */
 
@@ -202,7 +201,7 @@ protected:
   /* Save a register cache.  The set of registers saved into the
      regcache determined by the save_reggroup.  COOKED_READ returns
      zero iff the register's value can't be returned.  */
-  void save (regcache_cooked_read_ftype *cooked_read, void *src);
+  void save (register_read_ftype cooked_read);
 
   struct regcache_descr *m_descr;
 
@@ -379,16 +378,14 @@ private:
 class readonly_detached_regcache : public readable_regcache
 {
 public:
-  readonly_detached_regcache (const regcache &src);
+  readonly_detached_regcache (regcache &src);
 
   /* Create a readonly regcache by getting contents from COOKED_READ.  */
 
-  readonly_detached_regcache (gdbarch *gdbarch,
-                             regcache_cooked_read_ftype *cooked_read,
-                             void *src)
+  readonly_detached_regcache (gdbarch *gdbarch, register_read_ftype cooked_read)
     : readable_regcache (gdbarch, true)
   {
-    save (cooked_read, src);
+    save (cooked_read);
   }
 
   DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache);