Class-fy regcache

This patch moves regcache declaration to regcache.h, and converts
regcache apis to member functions, for example, regcache_invalidate
is changed to regcache::invalidate.

This patch also add "m_" prefix to these private fields.

gdb:

2017-04-28  Yao Qi  <yao.qi@linaro.org>

	* regcache.c (struct regcache): Move to regcache.h
	(regcache::arch): New method.
	(regcache_get_ptid): Update.
	(get_regcache_arch): Call arch method.
	(get_regcache_aspace): Call method aspace.
	(register_buffer): Change it to method.
	(regcache_save): Change it to regcache::save.
	(regcache_restore): Likewise.
	(regcache_cpy_no_passthrough): Remove the declaration.
	(regcache_cpy): Call methods restore and cpy_no_passthrough.
	(regcache_cpy_no_passthrough): Change it to method
	cpy_no_passthrough.
	(regcache_register_status): Change it to method
	get_register_status.
	(regcache_invalidate): Change it to method invalidate.
	(regcache_thread_ptid_changed): Use methods ptid and set_ptid.
	(regcache_raw_update): Change it to method raw_update.
	(regcache_raw_read): Likewise.
	(regcache_raw_read_signed): Likewise.
	(regcache_raw_read_unsigned): Likewise.
	(regcache_raw_write_signed): Likewise.
	(regcache_raw_write_unsigned): Likewise.
	(regcache_cooked_read): Likewise.
	(regcache_cooked_read_value): Likewise.
	(regcache_cooked_read_signed): Likewise.
	(regcache_cooked_read_unsigned): Likewise.
	(regcache_cooked_write_signed): Likewise.
	(regcache_cooked_write_unsigned): Likewise.
	(regcache_raw_set_cached_value): Likewise.
	(regcache_raw_write): Likewise.
	(regcache_cooked_write): Likewise.
	(regcache_xfer_part): Likewise.
	(regcache_raw_read_part): Likewise.
	(regcache_raw_write_part): Likewise.
	(regcache_cooked_read_part): Likewise.
	(regcache_cooked_write_part): Likewise.
	(regcache_raw_supply): Likewise.
	(regcache_raw_collect): Likewise.
	(regcache_transfer_regset): Likewise.
	(regcache_supply_regset): Likewise.
	(regcache_collect_regset): Likewise.
	(regcache_debug_print_register): Likewise.
	(enum regcache_dump_what): Move it to regcache.h.
	(regcache_dump): Change it to method dump.
	* regcache.h (enum regcache_dump_what): New.
	(class regcache): New.
	* target.c (target_fetch_registers): Call method
	debug_print_register.
	(target_store_registers): Likewise.

1 files changed, 151 insertions, 6 deletions

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 1d60fa7..e03a39f 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -224,6 +224,157 @@ extern void regcache_save (struct regcache *dst,
 			   regcache_cooked_read_ftype *cooked_read,
 			   void *cooked_read_context);
 
+enum regcache_dump_what
+{
+  regcache_dump_none, regcache_dump_raw,
+  regcache_dump_cooked, regcache_dump_groups,
+  regcache_dump_remote
+};
+
+/* The register cache for storing raw register values.  */
+
+class regcache
+{
+public:
+  regcache (gdbarch *gdbarch, address_space *aspace_)
+    : regcache (gdbarch, aspace_, true)
+  {}
+
+  ~regcache ()
+  {
+    xfree (m_registers);
+    xfree (m_register_status);
+  }
+
+  gdbarch *arch () const;
+
+  address_space *aspace () const
+  {
+    return m_aspace;
+  }
+
+  void save (regcache_cooked_read_ftype *cooked_read, void *src);
+
+  enum register_status cooked_read (int regnum, gdb_byte *buf);
+  void cooked_write (int regnum, const gdb_byte *buf);
+
+  enum register_status raw_read (int regnum, gdb_byte *buf);
+  void raw_write (int regnum, const gdb_byte *buf);
+
+  enum register_status raw_read_signed (int regnum, LONGEST *val);
+
+  void raw_write_signed (int regnum, LONGEST val);
+
+  enum register_status raw_read_unsigned (int regnum, ULONGEST *val);
+
+  void raw_write_unsigned (int regnum, ULONGEST val);
+
+  struct value *cooked_read_value (int regnum);
+
+  enum register_status cooked_read_signed (int regnum, LONGEST *val);
+
+  void cooked_write_signed (int regnum, LONGEST val);
+
+  enum register_status cooked_read_unsigned (int regnum, ULONGEST *val);
+
+  void cooked_write_unsigned (int regnum, ULONGEST val);
+
+  void raw_update (int regnum);
+
+  void raw_collect (int regnum, void *buf) const;
+
+  void raw_supply (int regnum, const void *buf);
+
+  enum register_status get_register_status (int regnum) const;
+
+  void raw_set_cached_value (int regnum, const gdb_byte *buf);
+
+  void invalidate (int regnum);
+
+  enum register_status raw_read_part (int regnum, int offset, int len,
+				      gdb_byte *buf);
+
+  void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
+
+  enum register_status cooked_read_part (int regnum, int offset, int len,
+					 gdb_byte *buf);
+
+  void cooked_write_part (int regnum, int offset, int len,
+			  const gdb_byte *buf);
+
+  void supply_regset (const struct regset *regset,
+		      int regnum, const void *buf, size_t size);
+
+
+  void collect_regset (const struct regset *regset, int regnum,
+		       void *buf, size_t size) const;
+
+  void dump (ui_file *file, enum regcache_dump_what what_to_dump);
+
+  ptid_t ptid () const
+  {
+    return m_ptid;
+  }
+
+  void set_ptid (const ptid_t ptid)
+  {
+    this->m_ptid = ptid;
+  }
+
+/* Dump the contents of a register from the register cache to the target
+   debug.  */
+  void debug_print_register (const char *func, int regno);
+
+private:
+  regcache (gdbarch *gdbarch, address_space *aspace_, bool readonly_p_);
+
+  gdb_byte *register_buffer (int regnum) const;
+
+  void restore (struct regcache *src);
+
+  void cpy_no_passthrough (struct regcache *src);
+
+  enum register_status xfer_part (int regnum, int offset, int len, void *in,
+				  const void *out,
+				  decltype (regcache_raw_read) read,
+				  decltype (regcache_raw_write) write);
+
+  void transfer_regset (const struct regset *regset,
+			struct regcache *out_regcache,
+			int regnum, const void *in_buf,
+			void *out_buf, size_t size) const;
+
+  struct regcache_descr *m_descr;
+
+  /* The address space of this register cache (for registers where it
+     makes sense, like PC or SP).  */
+  struct address_space *m_aspace;
+
+  /* The register buffers.  A read-only register cache can hold the
+     full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
+     register cache can only hold [0 .. gdbarch_num_regs).  */
+  gdb_byte *m_registers;
+  /* Register cache status.  */
+  signed char *m_register_status;
+  /* Is this a read-only cache?  A read-only cache is used for saving
+     the target's register state (e.g, across an inferior function
+     call or just before forcing a function return).  A read-only
+     cache can only be updated via the methods regcache_dup() and
+     regcache_cpy().  The actual contents are determined by the
+     reggroup_save and reggroup_restore methods.  */
+  bool m_readonly_p;
+  /* If this is a read-write cache, which thread's registers is
+     it connected to?  */
+  ptid_t m_ptid;
+
+  friend struct regcache *
+  get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
+				   struct address_space *aspace);
+
+  friend void
+  regcache_cpy (struct regcache *dst, struct regcache *src);
+};
+
 /* Copy/duplicate the contents of a register cache.  By default, the
    operation is pass-through.  Writes to DST and reads from SRC will
    go through to the target.  See also regcache_cpy_no_passthrough.
@@ -236,10 +387,4 @@ extern void regcache_cpy (struct regcache *dest, struct regcache *src);
 extern void registers_changed (void);
 extern void registers_changed_ptid (ptid_t);
 
-/* Dump the contents of a register from the register cache to the target
-   debug.  */
-extern void regcache_debug_print_register (const char *func,
-					   struct regcache *regcache,
-					   int regno);
-
 #endif /* REGCACHE_H */