From: Simon Marchi Date: Wed, 20 Jun 2018 16:49:03 +0000 (-0400) Subject: Rename regcache_cooked_read_ftype and make a function_view X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=302abd6e9facdfec3473e19ff65a5479f850ad62;p=binutils-gdb.git 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) : Remove src parameter. (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 ff304feff52..0e4705bd874 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,21 @@ +2018-06-20 Simon Marchi + + * regcache.h (regcache_cooked_read_ftype): Rename to... + (register_read_ftype): ...this, change type to function_view. + (class reg_buffer) : Remove src parameter. + (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 * record-full.c (record_full_target::insert_breakpoint): Remove diff --git a/gdb/frame.c b/gdb/frame.c index d8309e74070..450bf3a105e 100644 --- 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 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 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 f26882fe3c8..9f4c1fc891b 100644 --- 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 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 750ea2ad30f..25436bb456e 100644 --- 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 41465fb20d0..74ac8583bc9 100644 --- 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_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);