regcache_raw and use it in to_{fetch,store}_registers

This patch adds a new class regcache_raw, between reg_buffer and regcache
in the class hierarchy.  Also use it in target_ops
to_{fetch,store}_registers methods, because target_ops accesses raw
registers.  (pseudo registers are abstracted by gdbarch).

gdb:

2017-10-03  Yao Qi  <yao.qi@linaro.org>
:
	* aarch32-linux-nat.c (aarch32_gp_regcache_supply): -
	(aarch32_gp_regcache_supply): +
	(aarch32_gp_regcache_supply):
	(aarch32_gp_regcache_collect): -
	(aarch32_gp_regcache_collect): +
	(aarch32_gp_regcache_collect):
	(aarch32_vfp_regcache_supply): -
	(aarch32_vfp_regcache_supply): +
	(aarch32_vfp_regcache_supply):
	(aarch32_vfp_regcache_collect): -
	(aarch32_vfp_regcache_collect): +
	* aarch32-linux-nat.h:
	* aarch64-linux-nat.c (aarch64_get_debug_reg_state):
	(fetch_gregs_from_thread): -
	(fetch_gregs_from_thread): +
	(fetch_gregs_from_thread):
	(store_gregs_to_thread): -
	(store_gregs_to_thread): +
	(store_gregs_to_thread):
	(fetch_fpregs_from_thread): -
	(fetch_fpregs_from_thread): +
	(fetch_fpregs_from_thread):
	(store_fpregs_to_thread): -
	(store_fpregs_to_thread): +
	(store_fpregs_to_thread):
	(aarch64_linux_fetch_inferior_registers):
	* arch-utils.c (default_addressable_memory_unit_size):
	* arch-utils.h (extern const char *default_gnu_triplet_regexp):
	* arm-linux-tdep.c (static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {):
	(arm_linux_supply_gregset):
	(arm_linux_collect_gregset):
	(supply_nwfpe_register): -
	(supply_nwfpe_register): +
	(supply_nwfpe_register):
	(collect_nwfpe_register): -
	(collect_nwfpe_register): +
	(collect_nwfpe_register):
	(arm_linux_supply_nwfpe):
	(arm_linux_collect_nwfpe):
	(arm_linux_supply_vfp):
	* arm-linux-tdep.h (void arm_linux_collect_gregset):
	* corelow.c (core_detach):
	(get_core_register_section): -
	(get_core_register_section): +
	(get_core_registers_cb):
	* gdbarch.c (set_gdbarch_fast_tracepoint_valid_at):
	(gdbarch_guess_tracepoint_registers): -
	(gdbarch_guess_tracepoint_registers): +
	* gdbarch.h (extern void set_gdbarch_fast_tracepoint_valid_at):
	* gdbarch.sh (m;int;fast_tracepoint_valid_at;CORE_ADDR addr, char **msg;addr, msg;;default_fas):
	* gdbcore.h (struct core_fns):
	* inf-child.c (store_waitstatus):
	(inf_child_fetch_inferior_registers):
	(inf_child_post_attach):
	* inf-ptrace.c (static CORE_ADDR):
	(inf_ptrace_fetch_register): -
	(inf_ptrace_fetch_register): +
	(inf_ptrace_fetch_register):
	(inf_ptrace_fetch_registers):
	(inf_ptrace_store_register): -
	(inf_ptrace_store_register): +
	(inf_ptrace_store_register):
	* record-btrace.c (record_btrace_remove_breakpoint):
	(record_btrace_fetch_registers):
	(record_btrace_store_registers):
	* record-full.c (static void record_full_save):
	(record_full_reg_alloc): -
	(record_full_reg_alloc): +
	(record_full_get_loc):
	(record_full_arch_list_add_reg): -
	(record_full_arch_list_add_reg): +
	(record_full_supports_stopped_by_hw_breakpoint):
	(record_full_registers_change): -
	(record_full_registers_change): +
	(record_full_registers_change):
	(record_full_core_kill):
	(record_full_core_fetch_registers):
	(record_full_core_prepare_to_store):
	* record-full.h:
	* regcache.c (regcache_register_size):
	(regcache::regcache):
	(regcache::arch):
	(regcache_get_ptid): -
	(regcache_get_ptid): +
	(class regcache_invalidator):
	(public:):
	(public:):
	(get_regcache_arch): -
	(get_regcache_arch): +
	(regcache_dup):
	(regcache_register_status): -
	(regcache_register_status): +
	(reg_buffer::set_register_status):
	(regcache_invalidate): -
	(regcache_invalidate): +
	(registers_changed):
	(regcache_raw_update): -
	(regcache_raw_update): +
	(regcache_raw_update):
	(regcache::raw_update):
	(regcache_raw_read): -
	(regcache_raw_read): +
	(regcache_raw_read_signed):
	(regcache_raw_write_signed):
	(regcache_raw_write):
	(reg_buffer::raw_supply_zeroed):
	(regcache_raw_collect): -
	(regcache_raw_collect): +
	(reg_buffer::transfer_regset):
	(reg_buffer::supply_regset):
	(regcache_write_pc):
	* regcache.h (struct regcache;):
	(extern struct regcache *get_thread_arch_aspace_regcache):
	(extern enum register_status):
	(extern void regcache_write_pc):
	(enum):
	(private:):
	(public:):
	(public:):
	(public:):
	(public:):
	(private:):
	* regset.h (struct regcache;):
	* remote.c (static int getpkt_or_notif_sane):
	(remote_wait):
	(fetch_register_using_p): -
	(fetch_register_using_p): +
	(send_g_packet):
	(process_g_packet): -
	(process_g_packet): +
	(process_g_packet):
	(fetch_registers_using_g): -
	(fetch_registers_using_g): +
	(set_remote_traceframe):
	(remote_fetch_registers):
	(remote_prepare_to_store): -
	(remote_prepare_to_store): +
	(remote_prepare_to_store):
	(store_register_using_P): -
	(store_register_using_P): +
	(store_register_using_P):
	(store_registers_using_G): -
	(store_registers_using_G): +
	(store_registers_using_G):
	* s390-linux-tdep.c (s390_write_pc):
	* target-debug.h:
	* target-delegates.c (debug_wait):
	(delegate_fetch_registers): -
	(delegate_fetch_registers): +
	(tdefault_fetch_registers): -
	(tdefault_fetch_registers): +
	(debug_fetch_registers): -
	(debug_fetch_registers): +
	(delegate_store_registers): -
	(delegate_store_registers): +
	(tdefault_store_registers): -
	(tdefault_store_registers): +
	(debug_store_registers): -
	(debug_store_registers): +
	(delegate_prepare_to_store): -
	(delegate_prepare_to_store): +
	(tdefault_prepare_to_store): -
	(tdefault_prepare_to_store): +
	(debug_prepare_to_store): -
	(debug_prepare_to_store): +
	* target.c (target_options_to_string):
	(target_fetch_registers): -
	(target_fetch_registers): +
	(target_fetch_registers):
	(target_store_registers): -
	(target_store_registers): +
	* target.h (struct target_ops):
	(extern ptid_t default_target_wait):
	* tracefile-tfile.c (traceframe_find_block_type):
	* tracefile.c (trace_save_ctf):
	(tracefile_fetch_registers): -
	(tracefile_fetch_registers): +
	* tracefile.h (extern struct trace_file_writer *tfile_trace_file_writer_new):

gdb/aarch32-linux-nat.c

@@ -28,7 +28,7 @@
    is true if the 32-bit mode is in use, otherwise, it is false.  */
 
 void
-aarch32_gp_regcache_supply (struct regcache *regcache, uint32_t *regs,
+aarch32_gp_regcache_supply (regcache_raw *regcache, uint32_t *regs,
 			    int arm_apcs_32)
 {
   int regno;
@@ -54,7 +54,7 @@ aarch32_gp_regcache_supply (struct regcache *regcache, uint32_t *regs,
    true if the 32-bit mode is in use, otherwise, it is false.  */
 
 void
-aarch32_gp_regcache_collect (const struct regcache *regcache, uint32_t *regs,
+aarch32_gp_regcache_collect (const regcache_raw *regcache, uint32_t *regs,
 			     int arm_apcs_32)
 {
   int regno;
@@ -82,7 +82,7 @@ aarch32_gp_regcache_collect (const struct regcache *regcache, uint32_t *regs,
    VFP_REGISTER_COUNT is the number of VFP registers.  */
 
 void
-aarch32_vfp_regcache_supply (struct regcache *regcache, gdb_byte *regs,
+aarch32_vfp_regcache_supply (regcache_raw *regcache, gdb_byte *regs,
 			     const int vfp_register_count)
 {
   int regno;
@@ -99,7 +99,7 @@ aarch32_vfp_regcache_supply (struct regcache *regcache, gdb_byte *regs,
    VFP_REGISTER_COUNT is the number VFP registers.  */
 
 void
-aarch32_vfp_regcache_collect (const struct regcache *regcache, gdb_byte *regs,
+aarch32_vfp_regcache_collect (const regcache_raw *regcache, gdb_byte *regs,
 			      const int vfp_register_count)
 {
   int regno;

gdb/aarch32-linux-nat.h

@@ -20,15 +20,15 @@
    VFPv3D16 target.  */
 #define VFP_REGS_SIZE (32 * 8 + 4)
 
-void aarch32_gp_regcache_supply (struct regcache *regcache, uint32_t *regs,
+void aarch32_gp_regcache_supply (regcache_raw *regcache, uint32_t *regs,
 				 int arm_apcs_32);
 
-void aarch32_gp_regcache_collect (const struct regcache *regcache,
+void aarch32_gp_regcache_collect (const regcache_raw *regcache,
 				  uint32_t *regs, int arm_apcs_32);
 
-void aarch32_vfp_regcache_supply (struct regcache *regcache, gdb_byte *regs,
+void aarch32_vfp_regcache_supply (regcache_raw *regcache, gdb_byte *regs,
 				  const int vfp_register_count);
 
-void aarch32_vfp_regcache_collect (const struct regcache *regcache,
+void aarch32_vfp_regcache_collect (const regcache_raw *regcache,
 				   gdb_byte *regs,
 				   const int vfp_register_count);

gdb/aarch64-linux-nat.c

@@ -152,7 +152,7 @@ aarch64_get_debug_reg_state (pid_t pid)
    from the current thread.  */
 
 static void
-fetch_gregs_from_thread (struct regcache *regcache)
+fetch_gregs_from_thread (regcache_raw *regcache)
 {
   int ret, tid;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -190,7 +190,7 @@ fetch_gregs_from_thread (struct regcache *regcache)
    values in the GDB's register array.  */
 
 static void
-store_gregs_to_thread (const struct regcache *regcache)
+store_gregs_to_thread (const regcache_raw *regcache)
 {
   int ret, tid;
   elf_gregset_t regs;
@@ -233,7 +233,7 @@ store_gregs_to_thread (const struct regcache *regcache)
    from the current thread.  */
 
 static void
-fetch_fpregs_from_thread (struct regcache *regcache)
+fetch_fpregs_from_thread (regcache_raw *regcache)
 {
   int ret, tid;
   elf_fpregset_t regs;
@@ -281,7 +281,7 @@ fetch_fpregs_from_thread (struct regcache *regcache)
    values in the GDB's register array.  */
 
 static void
-store_fpregs_to_thread (const struct regcache *regcache)
+store_fpregs_to_thread (const regcache_raw *regcache)
 {
   int ret, tid;
   elf_fpregset_t regs;
@@ -346,7 +346,7 @@ store_fpregs_to_thread (const struct regcache *regcache)
 
 static void
 aarch64_linux_fetch_inferior_registers (struct target_ops *ops,
-					struct regcache *regcache,
+					regcache_raw *regcache,
 					int regno)
 {
   if (regno == -1)
@@ -364,7 +364,7 @@ aarch64_linux_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 aarch64_linux_store_inferior_registers (struct target_ops *ops,
-					struct regcache *regcache,
+					regcache_raw *regcache,
 					int regno)
 {
   if (regno == -1)
@@ -383,23 +383,23 @@ aarch64_linux_store_inferior_registers (struct target_ops *ops,
    do this for all registers.  */
 
 void
-fill_gregset (const struct regcache *regcache,
+fill_gregset (const reg_buffer *regcache,
 	      gdb_gregset_t *gregsetp, int regno)
 {
-  regcache_collect_regset (&aarch64_linux_gregset, regcache,
-			   regno, (gdb_byte *) gregsetp,
-			   AARCH64_LINUX_SIZEOF_GREGSET);
+  regcache->collect_regset (&aarch64_linux_gregset, regno,
+			    (gdb_byte *) gregsetp,
+			    AARCH64_LINUX_SIZEOF_GREGSET);
 }
 
 /* Fill GDB's register array with the general-purpose register values
    in *GREGSETP.  */
 
 void
-supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
+supply_gregset (reg_buffer *regcache, const gdb_gregset_t *gregsetp)
 {
-  regcache_supply_regset (&aarch64_linux_gregset, regcache, -1,
-			  (const gdb_byte *) gregsetp,
-			  AARCH64_LINUX_SIZEOF_GREGSET);
+  regcache->supply_regset (&aarch64_linux_gregset, -1,
+			   (const gdb_byte *) gregsetp,
+			   AARCH64_LINUX_SIZEOF_GREGSET);
 }
 
 /* Fill register REGNO (if it is a floating-point register) in
@@ -407,23 +407,23 @@ supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
    do this for all registers.  */
 
 void
-fill_fpregset (const struct regcache *regcache,
+fill_fpregset (const reg_buffer *regcache,
 	       gdb_fpregset_t *fpregsetp, int regno)
 {
-  regcache_collect_regset (&aarch64_linux_fpregset, regcache,
-			   regno, (gdb_byte *) fpregsetp,
-			   AARCH64_LINUX_SIZEOF_FPREGSET);
+  regcache->collect_regset (&aarch64_linux_fpregset, regno,
+			    (gdb_byte *) fpregsetp,
+			    AARCH64_LINUX_SIZEOF_FPREGSET);
 }
 
 /* Fill GDB's register array with the floating-point register values
    in *FPREGSETP.  */
 
 void
-supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
+supply_fpregset (reg_buffer *regcache, const gdb_fpregset_t *fpregsetp)
 {
-  regcache_supply_regset (&aarch64_linux_fpregset, regcache, -1,
-			  (const gdb_byte *) fpregsetp,
-			  AARCH64_LINUX_SIZEOF_FPREGSET);
+  regcache->supply_regset (&aarch64_linux_fpregset, -1,
+			   (const gdb_byte *) fpregsetp,
+			   AARCH64_LINUX_SIZEOF_FPREGSET);
 }
 
 /* linux_nat_new_fork hook.   */

gdb/arch-utils.c

@@ -945,7 +945,7 @@ default_addressable_memory_unit_size (struct gdbarch *gdbarch)
 
 void
 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
-				    struct regcache *regcache,
+				    regcache_raw *regcache,
 				    CORE_ADDR addr)
 {
   int pc_regno = gdbarch_pc_regnum (gdbarch);

gdb/arch-utils.h

@@ -263,7 +263,7 @@ extern const char *default_gnu_triplet_regexp (struct gdbarch *gdbarch);
 extern int default_addressable_memory_unit_size (struct gdbarch *gdbarch);
 
 extern void default_guess_tracepoint_registers (struct gdbarch *gdbarch,
-						struct regcache *regcache,
+						regcache_raw *regcache,
 						CORE_ADDR addr);
 
 extern int default_print_insn (bfd_vma memaddr, disassemble_info *info);

gdb/arm-linux-tdep.c

@@ -475,7 +475,7 @@ static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
 
 void
 arm_linux_supply_gregset (const struct regset *regset,
-			  struct regcache *regcache,
+			  regcache_raw *regcache,
 			  int regnum, const void *gregs_buf, size_t len)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -513,7 +513,7 @@ arm_linux_supply_gregset (const struct regset *regset,
 
 void
 arm_linux_collect_gregset (const struct regset *regset,
-			   const struct regcache *regcache,
+			   const regcache_raw *regcache,
 			   int regnum, void *gregs_buf, size_t len)
 {
   gdb_byte *gregs = (gdb_byte *) gregs_buf;
@@ -547,7 +547,7 @@ arm_linux_collect_gregset (const struct regset *regset,
 #define typeExtended		0x03
 
 void
-supply_nwfpe_register (struct regcache *regcache, int regno,
+supply_nwfpe_register (regcache_raw *regcache, int regno,
 		       const gdb_byte *regs)
 {
   const gdb_byte *reg_data;
@@ -582,7 +582,7 @@ supply_nwfpe_register (struct regcache *regcache, int regno,
 }
 
 void
-collect_nwfpe_register (const struct regcache *regcache, int regno,
+collect_nwfpe_register (const regcache_raw *regcache, int regno,
 			gdb_byte *regs)
 {
   gdb_byte *reg_data;
@@ -620,7 +620,7 @@ collect_nwfpe_register (const struct regcache *regcache, int regno,
 
 void
 arm_linux_supply_nwfpe (const struct regset *regset,
-			struct regcache *regcache,
+			regcache_raw *regcache,
 			int regnum, const void *regs_buf, size_t len)
 {
   const gdb_byte *regs = (const gdb_byte *) regs_buf;
@@ -637,7 +637,7 @@ arm_linux_supply_nwfpe (const struct regset *regset,
 
 void
 arm_linux_collect_nwfpe (const struct regset *regset,
-			 const struct regcache *regcache,
+			 const regcache_raw *regcache,
 			 int regnum, void *regs_buf, size_t len)
 {
   gdb_byte *regs = (gdb_byte *) regs_buf;
@@ -658,7 +658,7 @@ arm_linux_collect_nwfpe (const struct regset *regset,
 
 static void
 arm_linux_supply_vfp (const struct regset *regset,
-		      struct regcache *regcache,
+		      regcache_raw *regcache,
 		      int regnum, const void *regs_buf, size_t len)
 {
   const gdb_byte *regs = (const gdb_byte *) regs_buf;
@@ -675,7 +675,7 @@ arm_linux_supply_vfp (const struct regset *regset,
 
 static void
 arm_linux_collect_vfp (const struct regset *regset,
-			 const struct regcache *regcache,
+		       const regcache_raw *regcache,
 			 int regnum, void *regs_buf, size_t len)
 {
   gdb_byte *regs = (gdb_byte *) regs_buf;

gdb/arm-linux-tdep.h

@@ -44,9 +44,9 @@ void arm_linux_collect_gregset (const struct regset *regset,
 				const struct regcache *regcache,
 				int regnum, void *gregs_buf, size_t len);
 
-void supply_nwfpe_register (struct regcache *regcache, int regno,
+void supply_nwfpe_register (regcache_raw *regcache, int regno,
 			    const gdb_byte *regs);
-void collect_nwfpe_register (const struct regcache *regcache, int regno,
+void collect_nwfpe_register (const regcache_raw *regcache, int regno,
 			     gdb_byte *regs);
 
 void arm_linux_supply_nwfpe (const struct regset *regset,

gdb/corelow.c

@@ -493,7 +493,7 @@ core_detach (struct target_ops *ops, const char *args, int from_tty)
    nothing.  */
 
 static void
-get_core_register_section (struct regcache *regcache,
+get_core_register_section (regcache_raw *regcache,
 			   const struct regset *regset,
 			   const char *name,
 			   int min_size,
@@ -590,7 +590,7 @@ get_core_registers_cb (const char *sect_name, int size,
 
 static void
 get_core_registers (struct target_ops *ops,
-		    struct regcache *regcache, int regno)
+		    regcache_raw *regcache, int regno)
 {
   int i;
   struct gdbarch *gdbarch;

gdb/gdbarch-selftests.c

@@ -49,12 +49,12 @@ test_target_has_memory (target_ops *self)
 }
 
 static void
-test_target_prepare_to_store (target_ops *self, regcache *regs)
+test_target_prepare_to_store (target_ops *self, regcache_raw *regs)
 {
 }
 
 static void
-test_target_store_registers (target_ops *self, regcache *regs, int regno)
+test_target_store_registers (target_ops *self, regcache_raw *regs, int regno)
 {
 }
 

gdb/gdbarch.c

@@ -4677,7 +4677,7 @@ set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
 }
 
 void
-gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
+gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, regcache_raw *regcache, CORE_ADDR addr)
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->guess_tracepoint_registers != NULL);

gdb/gdbarch.h

@@ -1384,8 +1384,8 @@ extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbar
    allowing us to guess the PC value, and perhaps some other registers.
    On entry, regcache has all registers marked as unavailable. */
 
-typedef void (gdbarch_guess_tracepoint_registers_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
-extern void gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
+typedef void (gdbarch_guess_tracepoint_registers_ftype) (struct gdbarch *gdbarch, regcache_raw *regcache, CORE_ADDR addr);
+extern void gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, regcache_raw *regcache, CORE_ADDR addr);
 extern void set_gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, gdbarch_guess_tracepoint_registers_ftype *guess_tracepoint_registers);
 
 /* Return the "auto" target charset. */

gdb/gdbarch.sh

@@ -1056,7 +1056,7 @@ m;int;fast_tracepoint_valid_at;CORE_ADDR addr, char **msg;addr, msg;;default_fas
 # where no registers have been collected, but there's only one location,
 # allowing us to guess the PC value, and perhaps some other registers.
 # On entry, regcache has all registers marked as unavailable.
-m;void;guess_tracepoint_registers;struct regcache *regcache, CORE_ADDR addr;regcache, addr;;default_guess_tracepoint_registers;;0
+m;void;guess_tracepoint_registers;regcache_raw *regcache, CORE_ADDR addr;regcache, addr;;default_guess_tracepoint_registers;;0
 
 # Return the "auto" target charset.
 f;const char *;auto_charset;void;;default_auto_charset;default_auto_charset;;0

gdb/gdbcore.h

@@ -212,7 +212,7 @@ struct core_fns
        registers in a large upage-plus-stack ".reg" section.  Original upage
        address X is at location core_reg_sect+x+reg_addr.  */
 
-    void (*core_read_registers) (struct regcache *regcache,
+    void (*core_read_registers) (regcache_raw *regcache,
 				 char *core_reg_sect,
 				 unsigned core_reg_size,
 				 int which, CORE_ADDR reg_addr);

gdb/gregset.h

@@ -34,7 +34,7 @@
 typedef GDB_GREGSET_T gdb_gregset_t;
 typedef GDB_FPREGSET_T gdb_fpregset_t;
 
-struct regcache;
+class reg_buffer;
 
 /* A gregset is a data structure supplied by the native OS containing
    the general register values of the debugged process.  Usually this
@@ -46,18 +46,18 @@ struct regcache;
 /* Copy register values from the native target gregset/fpregset
    into GDB's internal register cache.  */
 
-extern void supply_gregset (struct regcache *regcache,
+extern void supply_gregset (reg_buffer *regcache,
 			    const gdb_gregset_t *gregs);
-extern void supply_fpregset (struct regcache *regcache,
+extern void supply_fpregset (reg_buffer *regcache,
 			     const gdb_fpregset_t *fpregs);
 
 /* Copy register values from GDB's register cache into
    the native target gregset/fpregset.  If regno is -1, 
    copy all the registers.  */
 
-extern void fill_gregset (const struct regcache *regcache,
+extern void fill_gregset (const reg_buffer *regcache,
 			  gdb_gregset_t *gregs, int regno);
-extern void fill_fpregset (const struct regcache *regcache,
+extern void fill_fpregset (const reg_buffer *regcache,
 			   gdb_fpregset_t *fpregs, int regno);
 
 #endif

gdb/inf-child.c

@@ -72,7 +72,7 @@ store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
 
 static void
 inf_child_fetch_inferior_registers (struct target_ops *ops,
-				    struct regcache *regcache, int regnum)
+				    regcache_raw *regcache, int regnum)
 {
   if (regnum == -1)
     {
@@ -90,7 +90,7 @@ inf_child_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 inf_child_store_inferior_registers (struct target_ops *ops,
-				    struct regcache *regcache, int regnum)
+				    regcache_raw *regcache, int regnum)
 {
 }
 
@@ -109,7 +109,7 @@ inf_child_post_attach (struct target_ops *self, int pid)
 
 static void
 inf_child_prepare_to_store (struct target_ops *self,
-			    struct regcache *regcache)
+			    regcache_raw *regcache)
 {
 }
 

gdb/inf-ptrace.c

@@ -711,9 +711,9 @@ static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
 /* Fetch register REGNUM from the inferior.  */
 
 static void
-inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
+inf_ptrace_fetch_register (regcache_raw *regcache, int regnum)
 {
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch *gdbarch = regcache->arch ();
   CORE_ADDR addr;
   size_t size;
   PTRACE_TYPE_RET *buf;
@@ -755,11 +755,11 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
 
 static void
 inf_ptrace_fetch_registers (struct target_ops *ops,
-			    struct regcache *regcache, int regnum)
+			    regcache_raw *regcache, int regnum)
 {
   if (regnum == -1)
     for (regnum = 0;
-	 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
+	 regnum < gdbarch_num_regs (regcache->arch ());
 	 regnum++)
       inf_ptrace_fetch_register (regcache, regnum);
   else
@@ -769,7 +769,7 @@ inf_ptrace_fetch_registers (struct target_ops *ops,
 /* Store register REGNUM into the inferior.  */
 
 static void
-inf_ptrace_store_register (const struct regcache *regcache, int regnum)
+inf_ptrace_store_register (const regcache_raw *regcache, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR addr;
@@ -810,7 +810,7 @@ inf_ptrace_store_register (const struct regcache *regcache, int regnum)
 
 static void
 inf_ptrace_store_registers (struct target_ops *ops,
-			    struct regcache *regcache, int regnum)
+			    regcache_raw *regcache, int regnum)
 {
   if (regnum == -1)
     for (regnum = 0;

gdb/record-btrace.c

@@ -1408,7 +1408,7 @@ record_btrace_remove_breakpoint (struct target_ops *ops,
 
 static void
 record_btrace_fetch_registers (struct target_ops *ops,
-			       struct regcache *regcache, int regno)
+			       regcache_raw *regcache, int regno)
 {
   struct btrace_insn_iterator *replay;
   struct thread_info *tp;
@@ -1449,7 +1449,7 @@ record_btrace_fetch_registers (struct target_ops *ops,
 
 static void
 record_btrace_store_registers (struct target_ops *ops,
-			       struct regcache *regcache, int regno)
+			       regcache_raw *regcache, int regno)
 {
   struct target_ops *t;
 
@@ -1467,7 +1467,7 @@ record_btrace_store_registers (struct target_ops *ops,
 
 static void
 record_btrace_prepare_to_store (struct target_ops *ops,
-				struct regcache *regcache)
+				regcache_raw *regcache)
 {
   struct target_ops *t;
 

gdb/record-full.c

@@ -168,7 +168,7 @@ struct record_full_core_buf_entry
 };
 
 /* Record buf with core target.  */
-static gdb_byte *record_full_core_regbuf = NULL;
+static reg_buffer *record_full_core_regbuf = NULL;
 static struct target_section *record_full_core_start;
 static struct target_section *record_full_core_end;
 static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
@@ -241,7 +241,7 @@ static void record_full_save (struct target_ops *self,
 /* Alloc a record_full_reg record entry.  */
 
 static inline struct record_full_entry *
-record_full_reg_alloc (struct regcache *regcache, int regnum)
+record_full_reg_alloc (regcache_raw *regcache, int regnum)
 {
   struct record_full_entry *rec;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -465,7 +465,7 @@ record_full_get_loc (struct record_full_entry *rec)
 /* Record the value of a register NUM to record_full_arch_list.  */
 
 int
-record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
+record_full_arch_list_add_reg (regcache_raw *regcache, int regnum)
 {
   struct record_full_entry *rec;
 
@@ -780,16 +780,16 @@ record_full_core_open_1 (const char *name, int from_tty)
 
   /* Get record_full_core_regbuf.  */
   target_fetch_registers (regcache, -1);
-  record_full_core_regbuf = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE * regnum);
+  record_full_core_regbuf = new reg_buffer (get_regcache_arch (regcache),
+					    false);
   for (i = 0; i < regnum; i ++)
-    regcache_raw_collect (regcache, i,
-			  record_full_core_regbuf + MAX_REGISTER_SIZE * i);
+    record_full_core_regbuf->raw_supply (i, regcache->register_buffer (i));
 
   /* Get record_full_core_start and record_full_core_end.  */
   if (build_section_table (core_bfd, &record_full_core_start,
 			   &record_full_core_end))
     {
-      xfree (record_full_core_regbuf);
+      delete record_full_core_regbuf;
       record_full_core_regbuf = NULL;
       error (_("\"%s\": Can't find sections: %s"),
 	     bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
@@ -871,7 +871,7 @@ record_full_close (struct target_ops *self)
   /* Release record_full_core_regbuf.  */
   if (record_full_core_regbuf)
     {
-      xfree (record_full_core_regbuf);
+      delete record_full_core_regbuf;
       record_full_core_regbuf = NULL;
     }
 
@@ -1393,7 +1393,7 @@ record_full_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
 /* Record registers change (by user or by GDB) to list as an instruction.  */
 
 static void
-record_full_registers_change (struct regcache *regcache, int regnum)
+record_full_registers_change (regcache_raw *regcache, int regnum)
 {
   /* Check record_full_insn_num.  */
   record_full_check_insn_num ();
@@ -1441,7 +1441,7 @@ record_full_registers_change (struct regcache *regcache, int regnum)
 
 static void
 record_full_store_registers (struct target_ops *ops,
-			     struct regcache *regcache,
+			     regcache_raw *regcache,
 			     int regno)
 {
   if (!record_full_gdb_operation_disable)
@@ -2024,7 +2024,7 @@ record_full_core_kill (struct target_ops *ops)
 
 static void
 record_full_core_fetch_registers (struct target_ops *ops,
-				  struct regcache *regcache,
+				  regcache_raw *regcache,
 				  int regno)
 {
   if (regno < 0)
@@ -2034,18 +2034,18 @@ record_full_core_fetch_registers (struct target_ops *ops,
 
       for (i = 0; i < num; i ++)
         regcache_raw_supply (regcache, i,
-                             record_full_core_regbuf + MAX_REGISTER_SIZE * i);
+			     record_full_core_regbuf->register_buffer (i));
     }
   else
     regcache_raw_supply (regcache, regno,
-                         record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
+			 record_full_core_regbuf->register_buffer (regno));
 }
 
 /* "to_prepare_to_store" method for prec over corefile.  */
 
 static void
 record_full_core_prepare_to_store (struct target_ops *self,
-				   struct regcache *regcache)
+				   regcache_raw *regcache)
 {
 }
 
@@ -2053,12 +2053,12 @@ record_full_core_prepare_to_store (struct target_ops *self,
 
 static void
 record_full_core_store_registers (struct target_ops *ops,
-                             struct regcache *regcache,
-                             int regno)
+				  regcache_raw *regcache,
+				  int regno)
 {
   if (record_full_gdb_operation_disable)
-    regcache_raw_collect (regcache, regno,
-                          record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
+    record_full_core_regbuf->raw_supply (regno,
+					 regcache->register_buffer (regno));
   else
     error (_("You can't do that without a process to debug."));
 }

gdb/record-full.h

@@ -22,7 +22,7 @@
 
 extern int record_full_memory_query;
 
-extern int record_full_arch_list_add_reg (struct regcache *regcache, int num);
+extern int record_full_arch_list_add_reg (regcache_raw *regcache, int num);
 extern int record_full_arch_list_add_mem (CORE_ADDR addr, int len);
 extern int record_full_arch_list_add_end (void);
 

gdb/regcache.c

@@ -152,6 +152,50 @@ regcache_descr (struct gdbarch *gdbarch)
 						 regcache_descr_handle);
 }
 
+reg_buffer::reg_buffer (gdbarch *gdbarch, bool has_pseudo)
+  : m_has_pseudo (has_pseudo)
+{
+  gdb_assert (gdbarch != NULL);
+  m_descr = regcache_descr (gdbarch);
+
+  if (has_pseudo)
+    {
+      m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_cooked_registers);
+      m_register_status = XCNEWVEC (signed char,
+				    m_descr->sizeof_cooked_register_status);
+    }
+  else
+    {
+      m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_raw_registers);
+      m_register_status = XCNEWVEC (signed char,
+				    m_descr->sizeof_raw_register_status);
+    }
+}
+
+void reg_buffer::validate (int regnum) const
+{
+  gdb_assert (regnum >= 0);
+  if (m_has_pseudo)
+    gdb_assert (regnum < m_descr->nr_cooked_registers);
+  else
+    gdb_assert (regnum < m_descr->nr_raw_registers);
+}
+
+void
+reg_buffer::clear ()
+{
+  if (m_has_pseudo)
+    {
+      memset (m_registers, 0, m_descr->sizeof_cooked_registers);
+      memset (m_register_status, 0, m_descr->sizeof_cooked_register_status);
+    }
+  else
+    {
+      memset (m_registers, 0, m_descr->sizeof_raw_registers);
+      memset (m_register_status, 0, m_descr->sizeof_raw_register_status);
+    }
+}
+
 /* Utility functions returning useful register attributes stored in
    the regcache descr.  */
 
@@ -188,28 +232,20 @@ regcache_register_size (const struct regcache *regcache, int n)
   return register_size (get_regcache_arch (regcache), n);
 }
 
-regcache::regcache (gdbarch *gdbarch, address_space *aspace_,
-		    bool readonly_p_)
-  : m_aspace (aspace_), m_readonly_p (readonly_p_)
+regcache_raw::regcache_raw (gdbarch *gdbarch, bool readonly_p_)
+  /* 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).  */
+  : reg_buffer (gdbarch, readonly_p_), m_readonly_p (readonly_p_)
 {
-  gdb_assert (gdbarch != NULL);
-  m_descr = regcache_descr (gdbarch);
-
-  if (m_readonly_p)
-    {
-      m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_cooked_registers);
-      m_register_status = XCNEWVEC (signed char,
-				    m_descr->sizeof_cooked_register_status);
-    }
-  else
-    {
-      m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_raw_registers);
-      m_register_status = XCNEWVEC (signed char,
-				    m_descr->sizeof_raw_register_status);
-    }
   m_ptid = minus_one_ptid;
 }
 
+regcache::regcache (gdbarch *gdbarch, address_space *aspace_,
+		    bool readonly_p_)
+  : regcache_raw (gdbarch, readonly_p_), m_aspace (aspace_)
+{}
+
 static enum register_status
 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 {
@@ -226,7 +262,7 @@ regcache::regcache (readonly_t, const regcache &src)
 }
 
 gdbarch *
-regcache::arch () const
+regcache_raw::arch () const
 {
   return m_descr->gdbarch;
 }
@@ -234,7 +270,7 @@ regcache::arch () const
 /* See regcache.h.  */
 
 ptid_t
-regcache_get_ptid (const struct regcache *regcache)
+regcache_get_ptid (const regcache_raw *regcache)
 {
   gdb_assert (!ptid_equal (regcache->ptid (), minus_one_ptid));
 
@@ -247,7 +283,7 @@ class regcache_invalidator
 {
 public:
 
-  regcache_invalidator (struct regcache *regcache, int regnum)
+  regcache_invalidator (regcache_raw *regcache, int regnum)
     : m_regcache (regcache),
       m_regnum (regnum)
   {
@@ -256,7 +292,7 @@ public:
   ~regcache_invalidator ()
   {
     if (m_regcache != nullptr)
-      regcache_invalidate (m_regcache, m_regnum);
+      m_regcache->invalidate (m_regnum);
   }
 
   DISABLE_COPY_AND_ASSIGN (regcache_invalidator);
@@ -268,14 +304,14 @@ public:
 
 private:
 
-  struct regcache *m_regcache;
+  regcache_raw *m_regcache;
   int m_regnum;
 };
 
 /* Return REGCACHE's architecture.  */
 
 struct gdbarch *
-get_regcache_arch (const struct regcache *regcache)
+get_regcache_arch (const regcache_raw *regcache)
 {
   return regcache->arch ();
 }
@@ -289,8 +325,9 @@ get_regcache_aspace (const struct regcache *regcache)
 /* Return  a pointer to register REGNUM's buffer cache.  */
 
 gdb_byte *
-regcache::register_buffer (int regnum) const
+reg_buffer::register_buffer (int regnum) const
 {
+  validate (regnum);
   return m_registers + m_descr->register_offset[regnum];
 }
 
@@ -313,8 +350,7 @@ regcache::save (regcache_cooked_read_ftype *cooked_read,
      target.  */
   gdb_assert (m_readonly_p);
   /* Clear the dest.  */
-  memset (m_registers, 0, m_descr->sizeof_cooked_registers);
-  memset (m_register_status, 0, m_descr->sizeof_cooked_register_status);
+  clear ();
   /* Copy over any registers (identified by their membership in the
      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
      gdbarch_num_pseudo_regs) range is checked since some architectures need
@@ -331,7 +367,7 @@ regcache::save (regcache_cooked_read_ftype *cooked_read,
 	  if (status != REG_VALID)
 	    memset (dst_buf, 0, register_size (gdbarch, regnum));
 
-	  m_register_status[regnum] = status;
+	  set_register_status (regnum, status);
 	}
     }
 }
@@ -354,7 +390,7 @@ regcache::restore (struct regcache *src)
     {
       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 	{
-	  if (src->m_register_status[regnum] == REG_VALID)
+	  if (src->get_register_status (regnum) == REG_VALID)
 	    cooked_write (regnum, src->register_buffer (regnum));
 	}
     }
@@ -378,38 +414,40 @@ regcache_dup (struct regcache *src)
 }
 
 enum register_status
-regcache_register_status (const struct regcache *regcache, int regnum)
+regcache_register_status (const reg_buffer *regcache, int regnum)
 {
   gdb_assert (regcache != NULL);
   return regcache->get_register_status (regnum);
 }
 
 enum register_status
-regcache::get_register_status (int regnum) const
+reg_buffer::get_register_status (int regnum) const
 {
-  gdb_assert (regnum >= 0);
-  if (m_readonly_p)
-    gdb_assert (regnum < m_descr->nr_cooked_registers);
-  else
-    gdb_assert (regnum < m_descr->nr_raw_registers);
-
+  validate (regnum);
   return (enum register_status) m_register_status[regnum];
 }
 
 void
-regcache_invalidate (struct regcache *regcache, int regnum)
+reg_buffer::set_register_status (int regnum, enum register_status status)
+{
+  validate (regnum);
+  m_register_status[regnum] = status;
+}
+
+void
+regcache_invalidate (regcache_raw *regcache, int regnum)
 {
   gdb_assert (regcache != NULL);
   regcache->invalidate (regnum);
 }
 
 void
-regcache::invalidate (int regnum)
+regcache_raw::invalidate (int regnum)
 {
   gdb_assert (regnum >= 0);
   gdb_assert (!m_readonly_p);
   gdb_assert (regnum < m_descr->nr_raw_registers);
-  m_register_status[regnum] = REG_UNKNOWN;
+  set_register_status (regnum, REG_UNKNOWN);
 }
 
 /* Global structure containing the current regcache.  */
@@ -549,7 +587,7 @@ registers_changed (void)
 }
 
 void
-regcache_raw_update (struct regcache *regcache, int regnum)
+regcache_raw_update (regcache_raw *regcache, int regnum)
 {
   gdb_assert (regcache != NULL);
 
@@ -557,7 +595,7 @@ regcache_raw_update (struct regcache *regcache, int regnum)
 }
 
 void
-regcache::raw_update (int regnum)
+regcache_raw::raw_update (int regnum)
 {
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
 
@@ -573,30 +611,30 @@ regcache::raw_update (int regnum)
       /* A number of targets can't access the whole set of raw
 	 registers (because the debug API provides no means to get at
 	 them).  */
-      if (m_register_status[regnum] == REG_UNKNOWN)
-	m_register_status[regnum] = REG_UNAVAILABLE;
+      if (get_register_status (regnum) == REG_UNKNOWN)
+	set_register_status (regnum, REG_UNAVAILABLE);
     }
 }
 
 enum register_status
-regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
+regcache_raw_read (regcache_raw *regcache, int regnum, gdb_byte *buf)
 {
   return regcache->raw_read (regnum, buf);
 }
 
 enum register_status
-regcache::raw_read (int regnum, gdb_byte *buf)
+regcache_raw::raw_read (int regnum, gdb_byte *buf)
 {
   gdb_assert (buf != NULL);
   raw_update (regnum);
 
-  if (m_register_status[regnum] != REG_VALID)
+  if (get_register_status(regnum) != REG_VALID)
     memset (buf, 0, m_descr->sizeof_register[regnum]);
   else
     memcpy (buf, register_buffer (regnum),
 	    m_descr->sizeof_register[regnum]);
 
-  return (enum register_status) m_register_status[regnum];
+  return get_register_status (regnum);
 }
 
 enum register_status
@@ -608,7 +646,7 @@ regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 
 template<typename T, typename>
 enum register_status
-regcache::raw_read (int regnum, T *val)
+regcache_raw::raw_read (int regnum, T *val)
 {
   gdb_byte *buf;
   enum register_status status;
@@ -642,7 +680,7 @@ regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 
 template<typename T, typename>
 void
-regcache::raw_write (int regnum, T val)
+regcache_raw::raw_write (int regnum, T val)
 {
   gdb_byte *buf;
 
@@ -688,17 +726,17 @@ regcache::cooked_read (int regnum, gdb_byte *buf)
   if (regnum < m_descr->nr_raw_registers)
     return raw_read (regnum, buf);
   else if (m_readonly_p
-	   && m_register_status[regnum] != REG_UNKNOWN)
+	   && get_register_status(regnum) != REG_UNKNOWN)
     {
       /* Read-only register cache, perhaps the cooked value was
 	 cached?  */
-      if (m_register_status[regnum] == REG_VALID)
+      if (get_register_status (regnum) == REG_VALID)
 	memcpy (buf, register_buffer (regnum),
 		m_descr->sizeof_register[regnum]);
       else
 	memset (buf, 0, m_descr->sizeof_register[regnum]);
 
-      return (enum register_status) m_register_status[regnum];
+      return get_register_status(regnum);
     }
   else if (gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
     {
@@ -740,7 +778,7 @@ regcache::cooked_read_value (int regnum)
   gdb_assert (regnum < m_descr->nr_cooked_registers);
 
   if (regnum < m_descr->nr_raw_registers
-      || (m_readonly_p && m_register_status[regnum] != REG_UNKNOWN)
+      || (m_readonly_p && get_register_status (regnum) != REG_UNKNOWN)
       || !gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
     {
       struct value *result;
@@ -837,8 +875,10 @@ regcache_raw_set_cached_value (struct regcache *regcache, int regnum,
 }
 
 void
-regcache::raw_set_cached_value (int regnum, const gdb_byte *buf)
+reg_buffer::raw_set_cached_value (int regnum, const gdb_byte *buf)
 {
+  validate (regnum);
+
   memcpy (register_buffer (regnum), buf,
 	  m_descr->sizeof_register[regnum]);
   m_register_status[regnum] = REG_VALID;
@@ -853,7 +893,7 @@ regcache_raw_write (struct regcache *regcache, int regnum,
 }
 
 void
-regcache::raw_write (int regnum, const gdb_byte *buf)
+regcache_raw::raw_write (int regnum, const gdb_byte *buf)
 {
 
   gdb_assert (buf != NULL);
@@ -915,12 +955,7 @@ typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 
 enum register_status
 regcache::xfer_part (int regnum, int offset, int len, void *in,
-		     const void *out,
-		     enum register_status (*read) (struct regcache *regcache,
-						   int regnum,
-						   gdb_byte *buf),
-		     void (*write) (struct regcache *regcache, int regnum,
-				    const gdb_byte *buf))
+		     const void *out, bool is_raw)
 {
   struct gdbarch *gdbarch = arch ();
   gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
@@ -938,7 +973,10 @@ regcache::xfer_part (int regnum, int offset, int len, void *in,
       enum register_status status;
 
       gdb_assert (read != NULL);
-      status = read (this, regnum, reg);
+      if (is_raw)
+	status = raw_read (regnum, reg);
+      else
+	status = cooked_read (regnum, reg);
       if (status != REG_VALID)
 	return status;
     }
@@ -950,8 +988,10 @@ regcache::xfer_part (int regnum, int offset, int len, void *in,
   /* ... write (when needed).  */
   if (out != NULL)
     {
-      gdb_assert (write != NULL);
-      write (this, regnum, reg);
+      if (is_raw)
+	raw_write (regnum, reg);
+      else
+	raw_write (regnum, reg);
     }
 
   return REG_VALID;
@@ -968,8 +1008,7 @@ enum register_status
 regcache::raw_read_part (int regnum, int offset, int len, gdb_byte *buf)
 {
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  return xfer_part (regnum, offset, len, buf, NULL,
-		    regcache_raw_read, regcache_raw_write);
+  return xfer_part (regnum, offset, len, buf, NULL, true);
 }
 
 void
@@ -984,8 +1023,7 @@ regcache::raw_write_part (int regnum, int offset, int len,
 			  const gdb_byte *buf)
 {
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  xfer_part (regnum, offset, len, NULL, buf, regcache_raw_read,
-	     regcache_raw_write);
+  xfer_part (regnum, offset, len, NULL, buf, true);
 }
 
 enum register_status
@@ -1000,8 +1038,7 @@ enum register_status
 regcache::cooked_read_part (int regnum, int offset, int len, gdb_byte *buf)
 {
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
-  return xfer_part (regnum, offset, len, buf, NULL,
-		    regcache_cooked_read, regcache_cooked_write);
+  return xfer_part (regnum, offset, len, buf, NULL, false);
 }
 
 void
@@ -1016,27 +1053,25 @@ regcache::cooked_write_part (int regnum, int offset, int len,
 			     const gdb_byte *buf)
 {
   gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
-  xfer_part (regnum, offset, len, NULL, buf,
-	     regcache_cooked_read, regcache_cooked_write);
+  xfer_part (regnum, offset, len, NULL, buf, false);
 }
 
 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 
 void
-regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
+regcache_raw_supply (regcache_raw *regcache, int regnum, const void *buf)
 {
   gdb_assert (regcache != NULL);
   regcache->raw_supply (regnum, buf);
 }
 
 void
-regcache::raw_supply (int regnum, const void *buf)
+reg_buffer::raw_supply (int regnum, const void *buf)
 {
   void *regbuf;
   size_t size;
 
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  gdb_assert (!m_readonly_p);
+  validate (regnum);
 
   regbuf = register_buffer (regnum);
   size = m_descr->sizeof_register[regnum];
@@ -1063,15 +1098,14 @@ regcache::raw_supply (int regnum, const void *buf)
    most significant bytes of the integer will be truncated.  */
 
 void
-regcache::raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
-			      bool is_signed)
+reg_buffer::raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
+				bool is_signed)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
   gdb_byte *regbuf;
   size_t regsize;
 
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  gdb_assert (!m_readonly_p);
+  validate (regnum);
 
   regbuf = register_buffer (regnum);
   regsize = m_descr->sizeof_register[regnum];
@@ -1086,14 +1120,13 @@ regcache::raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
    unavailable).  */
 
 void
-regcache::raw_supply_zeroed (int regnum)
+reg_buffer::raw_supply_zeroed (int regnum)
 {
   void *regbuf;
   size_t size;
 
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
-  gdb_assert (!m_readonly_p);
-
+  validate (regnum);
+ 
   regbuf = register_buffer (regnum);
   size = m_descr->sizeof_register[regnum];
 
@@ -1104,20 +1137,20 @@ regcache::raw_supply_zeroed (int regnum)
 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 
 void
-regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
+regcache_raw_collect (const regcache_raw *regcache, int regnum, void *buf)
 {
   gdb_assert (regcache != NULL && buf != NULL);
   regcache->raw_collect (regnum, buf);
 }
 
 void
-regcache::raw_collect (int regnum, void *buf) const
+reg_buffer::raw_collect (int regnum, void *buf) const
 {
   const void *regbuf;
   size_t size;
 
   gdb_assert (buf != NULL);
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
+  validate (regnum);
 
   regbuf = register_buffer (regnum);
   size = m_descr->sizeof_register[regnum];
@@ -1135,14 +1168,14 @@ regcache::raw_collect (int regnum, void *buf) const
    most significant bytes of the integer will be truncated.  */
 
 void
-regcache::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
-			       bool is_signed) const
+reg_buffer::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
+				 bool is_signed) const
 {
   enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
   const gdb_byte *regbuf;
   size_t regsize;
 
-  gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers);
+  validate (regnum);
 
   regbuf = register_buffer (regnum);
   regsize = m_descr->sizeof_register[regnum];
@@ -1152,10 +1185,10 @@ regcache::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
 }
 
 void
-regcache::transfer_regset (const struct regset *regset,
-			   struct regcache *out_regcache,
-			   int regnum, const void *in_buf,
-			   void *out_buf, size_t size) const
+reg_buffer::transfer_regset (const struct regset *regset,
+			     struct reg_buffer *out_regcache,
+			     int regnum, const void *in_buf,
+			     void *out_buf, size_t size) const
 {
   const struct regcache_map_entry *map;
   int offs = 0, count;
@@ -1212,15 +1245,15 @@ regcache::transfer_regset (const struct regset *regset,
 
 void
 regcache_supply_regset (const struct regset *regset,
-			struct regcache *regcache,
+			regcache_raw *regcache,
 			int regnum, const void *buf, size_t size)
 {
   regcache->supply_regset (regset, regnum, buf, size);
 }
 
 void
-regcache::supply_regset (const struct regset *regset,
-			 int regnum, const void *buf, size_t size)
+reg_buffer::supply_regset (const struct regset *regset,
+			   int regnum, const void *buf, size_t size)
 {
   transfer_regset (regset, this, regnum, buf, NULL, size);
 }
@@ -1231,15 +1264,15 @@ regcache::supply_regset (const struct regset *regset,
 
 void
 regcache_collect_regset (const struct regset *regset,
-			 const struct regcache *regcache,
+			 const regcache_raw *regcache,
 			 int regnum, void *buf, size_t size)
 {
   regcache->collect_regset (regset, regnum, buf, size);
 }
 
 void
-regcache::collect_regset (const struct regset *regset,
-			 int regnum, void *buf, size_t size) const
+reg_buffer::collect_regset (const struct regset *regset,
+			    int regnum, void *buf, size_t size) const
 {
   transfer_regset (regset, NULL, regnum, NULL, buf, size);
 }
@@ -1294,7 +1327,7 @@ regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
 }
 
 void
-regcache::debug_print_register (const char *func,  int regno)
+regcache_raw::debug_print_register (const char *func,  int regno)
 {
   struct gdbarch *gdbarch = arch ();
 

gdb/regcache.h

@@ -27,6 +27,8 @@ struct regcache;
 struct regset;
 struct gdbarch;
 struct address_space;
+class regcache_raw;
+class reg_buffer;
 
 extern struct regcache *get_current_regcache (void);
 extern struct regcache *get_thread_regcache (ptid_t ptid);
@@ -37,27 +39,27 @@ extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
 
 /* Return REGCACHE's ptid.  */
 
-extern ptid_t regcache_get_ptid (const struct regcache *regcache);
+extern ptid_t regcache_get_ptid (const regcache_raw *regcache);
 
 /* Return REGCACHE's architecture.  */
 
-extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
+extern struct gdbarch *get_regcache_arch (const regcache_raw *regcache);
 
 /* Return REGCACHE's address space.  */
 
 extern struct address_space *get_regcache_aspace (const struct regcache *);
 
-enum register_status regcache_register_status (const struct regcache *regcache,
+enum register_status regcache_register_status (const reg_buffer *regcache,
 					       int regnum);
 
 /* Make certain that the register REGNUM in REGCACHE is up-to-date.  */
 
-void regcache_raw_update (struct regcache *regcache, int regnum);
+void regcache_raw_update (regcache_raw *regcache, int regnum);
 
 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
    regcache.  The read variants return the status of the register.  */
 
-enum register_status regcache_raw_read (struct regcache *regcache,
+enum register_status regcache_raw_read (regcache_raw *regcache,
 					int rawnum, gdb_byte *buf);
 void regcache_raw_write (struct regcache *regcache, int rawnum,
 			 const gdb_byte *buf);
@@ -94,7 +96,7 @@ extern enum register_status
 void regcache_raw_write_part (struct regcache *regcache, int regnum,
 			      int offset, int len, const gdb_byte *buf);
 
-void regcache_invalidate (struct regcache *regcache, int regnum);
+void regcache_invalidate (regcache_raw *regcache, int regnum);
 
 /* Transfer of pseudo-registers.  The read variants return a register
    status, as an indication of when a ``cooked'' register was
@@ -143,9 +145,9 @@ extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
    target.  These functions are called by the target in response to a
    target_fetch_registers() or target_store_registers().  */
 
-extern void regcache_raw_supply (struct regcache *regcache,
+extern void regcache_raw_supply (regcache_raw *regcache,
 				 int regnum, const void *buf);
-extern void regcache_raw_collect (const struct regcache *regcache,
+extern void regcache_raw_collect (const regcache_raw *regcache,
 				  int regnum, void *buf);
 
 /* Mapping between register numbers and offsets in a buffer, for use
@@ -186,11 +188,11 @@ enum
    'regset_collect' fields in a regset structure.  */
 
 extern void regcache_supply_regset (const struct regset *regset,
-				    struct regcache *regcache,
+				    regcache_raw *regcache,
 				    int regnum, const void *buf,
 				    size_t size);
 extern void regcache_collect_regset (const struct regset *regset,
-				     const struct regcache *regcache,
+				     const regcache_raw *regcache,
 				     int regnum, void *buf, size_t size);
 
 
@@ -235,9 +237,122 @@ typedef struct cached_reg
   gdb_byte *data;
 } cached_reg_t;
 
+/* Buffer of registers.  */
+
+class reg_buffer
+{
+public:
+  reg_buffer (gdbarch *gdbarch, bool has_pseudo);
+
+  DISABLE_COPY_AND_ASSIGN (reg_buffer);
+
+  gdbarch *arch () const;
+
+  virtual ~reg_buffer ()
+  {
+    xfree (m_registers);
+    xfree (m_register_status);
+  }
+
+  void clear ();
+
+  enum register_status get_register_status (int regnum) const;
+  void set_register_status (int regnum, enum register_status status);
+
+  void raw_collect (int regnum, void *buf) const;
+
+  void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
+			    bool is_signed) const;
+
+  void raw_supply (int regnum, const void *buf);
+
+  void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
+			   bool is_signed);
+
+  void raw_supply_zeroed (int regnum);
+
+  void raw_set_cached_value (int regnum, const gdb_byte *buf);
+
+  gdb_byte *register_buffer (int regnum) const;
+
+  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;
+
+protected:
+  struct regcache_descr *m_descr;
+
+private:
+  void validate (int regnum) const;
+
+  void transfer_regset (const struct regset *regset,
+			struct reg_buffer *out_regcache,
+			int regnum, const void *in_buf,
+			void *out_buf, size_t size) const;
+
+  bool m_has_pseudo;
+  /* The register buffers.  */
+  gdb_byte *m_registers;
+  /* Register cache status.  */
+  signed char *m_register_status;
+};
+
+class regcache_raw : public reg_buffer
+{
+public:
+  regcache_raw () = delete;
+
+  enum register_status raw_read (int regnum, gdb_byte *buf);
+  void raw_write (int regnum, const gdb_byte *buf);
+
+  template<typename T, typename = RequireLongest<T>>
+  enum register_status raw_read (int regnum, T *val);
+
+  template<typename T, typename = RequireLongest<T>>
+  void raw_write (int regnum, T val);
+
+  void raw_update (int regnum);
+
+  void invalidate (int regnum);
+
+  ptid_t ptid () const
+  {
+    return m_ptid;
+  }
+
+  void set_ptid (const ptid_t ptid)
+  {
+    this->m_ptid = ptid;
+  }
+
+  gdbarch *arch () const;
+
+/* Dump the contents of a register from the register cache to the target
+   debug.  */
+  void debug_print_register (const char *func, int regno);
+
+protected:
+  regcache_raw (gdbarch *gdbarch, bool readonly_p_);
+
+  /* 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;
+
+private:
+  /* If this is a read-write cache, which thread's registers is
+     it connected to?  */
+  ptid_t m_ptid;
+};
+
 /* The register cache for storing raw register values.  */
 
-class regcache
+class regcache : public regcache_raw
 {
 public:
   regcache (gdbarch *gdbarch, address_space *aspace_)
@@ -252,14 +367,6 @@ public:
 
   DISABLE_COPY_AND_ASSIGN (regcache);
 
-  ~regcache ()
-  {
-    xfree (m_registers);
-    xfree (m_register_status);
-  }
-
-  gdbarch *arch () const;
-
   address_space *aspace () const
   {
     return m_aspace;
@@ -270,16 +377,6 @@ public:
   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);
-
-  template<typename T, typename = RequireLongest<T>>
-  enum register_status raw_read (int regnum, T *val);
-
-  template<typename T, typename = RequireLongest<T>>
-  void raw_write (int regnum, T val);
-
   struct value *cooked_read_value (int regnum);
 
   template<typename T, typename = RequireLongest<T>>
@@ -288,26 +385,6 @@ public:
   template<typename T, typename = RequireLongest<T>>
   void cooked_write (int regnum, T val);
 
-  void raw_update (int regnum);
-
-  void raw_collect (int regnum, void *buf) const;
-
-  void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
-			    bool is_signed) const;
-
-  void raw_supply (int regnum, const void *buf);
-
-  void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
-			   bool is_signed);
-
-  void raw_supply_zeroed (int regnum);
-
-  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);
 
@@ -319,29 +396,8 @@ public:
   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);
-
   static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid);
 protected:
   regcache (gdbarch *gdbarch, address_space *aspace_, bool readonly_p_);
@@ -349,43 +405,15 @@ protected:
   static std::forward_list<regcache *> current_regcache;
 
 private:
-  gdb_byte *register_buffer (int regnum) const;
-
   void restore (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;
+				  const void *out, bool is_raw);
 
   /* 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);

gdb/regset.h

@@ -25,10 +25,10 @@ struct regcache;
 
 /* Data structure describing a register set.  */
 
-typedef void (supply_regset_ftype) (const struct regset *, struct regcache *,
+typedef void (supply_regset_ftype) (const struct regset *, regcache_raw *,
                                     int, const void *, size_t);
-typedef void (collect_regset_ftype) (const struct regset *, 
-                                     const struct regcache *,
+typedef void (collect_regset_ftype) (const struct regset *,
+                                     const regcache_raw *,
                                      int, void *, size_t);
 
 struct regset

gdb/remote.c

@@ -105,7 +105,7 @@ static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
 static void remote_files_info (struct target_ops *ignore);
 
 static void remote_prepare_to_store (struct target_ops *self,
-				     struct regcache *regcache);
+				     regcache_raw *regcache);
 
 static void remote_open_1 (const char *, int, struct target_ops *,
 			   int extended_p);
@@ -7554,7 +7554,7 @@ remote_wait (struct target_ops *ops,
 /* Fetch a single register using a 'p' packet.  */
 
 static int
-fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
+fetch_register_using_p (regcache_raw *regcache, struct packet_reg *reg)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct remote_state *rs = get_remote_state ();
@@ -7647,7 +7647,7 @@ send_g_packet (void)
 }
 
 static void
-process_g_packet (struct regcache *regcache)
+process_g_packet (regcache_raw *regcache)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct remote_state *rs = get_remote_state ();
@@ -7752,7 +7752,7 @@ process_g_packet (struct regcache *regcache)
 }
 
 static void
-fetch_registers_using_g (struct regcache *regcache)
+fetch_registers_using_g (regcache_raw *regcache)
 {
   send_g_packet ();
   process_g_packet (regcache);
@@ -7783,7 +7783,7 @@ set_remote_traceframe (void)
 
 static void
 remote_fetch_registers (struct target_ops *ops,
-			struct regcache *regcache, int regnum)
+			regcache_raw *regcache, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   remote_arch_state *rsa = get_remote_arch_state (gdbarch);
@@ -7834,7 +7834,7 @@ remote_fetch_registers (struct target_ops *ops,
    first.  */
 
 static void
-remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)
+remote_prepare_to_store (struct target_ops *self, regcache_raw *regcache)
 {
   remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
   int i;
@@ -7858,7 +7858,7 @@ remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)
    packet was not recognized.  */
 
 static int
-store_register_using_P (const struct regcache *regcache, 
+store_register_using_P (const regcache_raw *regcache,
 			struct packet_reg *reg)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -7899,7 +7899,7 @@ store_register_using_P (const struct regcache *regcache,
    contents of the register cache buffer.  FIXME: ignores errors.  */
 
 static void
-store_registers_using_G (const struct regcache *regcache)
+store_registers_using_G (const regcache_raw *regcache)
 {
   struct remote_state *rs = get_remote_state ();
   remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
@@ -7939,7 +7939,7 @@ store_registers_using_G (const struct regcache *regcache)
 
 static void
 remote_store_registers (struct target_ops *ops,
-			struct regcache *regcache, int regnum)
+			regcache_raw *regcache, int regnum)
 {
   struct gdbarch *gdbarch = regcache->arch ();
   remote_arch_state *rsa = get_remote_arch_state (gdbarch);

gdb/s390-linux-tdep.c

@@ -177,7 +177,7 @@ s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
 
 static void
 s390_guess_tracepoint_registers (struct gdbarch *gdbarch,
-				 struct regcache *regcache,
+				 regcache_raw *regcache,
 				 CORE_ADDR addr)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

gdb/target-debug.h

@@ -98,7 +98,7 @@
   target_debug_do_print (core_addr_to_string (*(X)))
 #define target_debug_print_int_p(X)		\
   target_debug_do_print (plongest (*(X)))
-#define target_debug_print_struct_regcache_p(X) \
+#define target_debug_print_regcache_raw_p(X) \
   target_debug_do_print (host_address_to_string (X))
 #define target_debug_print_struct_thread_info_p(X)	\
   target_debug_do_print (host_address_to_string (X))

gdb/target-delegates.c

@@ -159,80 +159,80 @@ debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2
 }
 
 static void
-delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+delegate_fetch_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
   self = self->beneath;
   self->to_fetch_registers (self, arg1, arg2);
 }
 
 static void
-tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+tdefault_fetch_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
 }
 
 static void
-debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+debug_fetch_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
   debug_target.to_fetch_registers (&debug_target, arg1, arg2);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
   target_debug_print_struct_target_ops_p (&debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_struct_regcache_p (arg1);
+  target_debug_print_regcache_raw_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg2);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
 static void
-delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+delegate_store_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
   self = self->beneath;
   self->to_store_registers (self, arg1, arg2);
 }
 
 static void
-tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+tdefault_store_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
   noprocess ();
 }
 
 static void
-debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+debug_store_registers (struct target_ops *self, regcache_raw *arg1, int arg2)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
   debug_target.to_store_registers (&debug_target, arg1, arg2);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
   target_debug_print_struct_target_ops_p (&debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_struct_regcache_p (arg1);
+  target_debug_print_regcache_raw_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg2);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
 static void
-delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+delegate_prepare_to_store (struct target_ops *self, regcache_raw *arg1)
 {
   self = self->beneath;
   self->to_prepare_to_store (self, arg1);
 }
 
 static void
-tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+tdefault_prepare_to_store (struct target_ops *self, regcache_raw *arg1)
 {
   noprocess ();
 }
 
 static void
-debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+debug_prepare_to_store (struct target_ops *self, regcache_raw *arg1)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
   debug_target.to_prepare_to_store (&debug_target, arg1);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
   target_debug_print_struct_target_ops_p (&debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_struct_regcache_p (arg1);
+  target_debug_print_regcache_raw_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 

gdb/target.c

@@ -3443,7 +3443,7 @@ target_options_to_string (int target_options)
 }
 
 void
-target_fetch_registers (struct regcache *regcache, int regno)
+target_fetch_registers (regcache_raw *regcache, int regno)
 {
   current_target.to_fetch_registers (&current_target, regcache, regno);
   if (targetdebug)
@@ -3451,7 +3451,7 @@ target_fetch_registers (struct regcache *regcache, int regno)
 }
 
 void
-target_store_registers (struct regcache *regcache, int regno)
+target_store_registers (regcache_raw *regcache, int regno)
 {
   if (!may_write_registers)
     error (_("Writing to registers is not allowed (regno %d)"), regno);

gdb/target.h

@@ -475,11 +475,11 @@ struct target_ops
 		       ptid_t, struct target_waitstatus *,
 		       int TARGET_DEBUG_PRINTER (target_debug_print_options))
       TARGET_DEFAULT_FUNC (default_target_wait);
-    void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
+    void (*to_fetch_registers) (struct target_ops *, regcache_raw *, int)
       TARGET_DEFAULT_IGNORE ();
-    void (*to_store_registers) (struct target_ops *, struct regcache *, int)
+    void (*to_store_registers) (struct target_ops *, regcache_raw *, int)
       TARGET_DEFAULT_NORETURN (noprocess ());
-    void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
+    void (*to_prepare_to_store) (struct target_ops *, regcache_raw *)
       TARGET_DEFAULT_NORETURN (noprocess ());
 
     void (*to_files_info) (struct target_ops *)
@@ -1401,13 +1401,13 @@ extern ptid_t default_target_wait (struct target_ops *ops,
 
 /* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
 
-extern void target_fetch_registers (struct regcache *regcache, int regno);
+extern void target_fetch_registers (regcache_raw *regcache, int regno);
 
 /* Store at least register REGNO, or all regs if REGNO == -1.
    It can store as many registers as it wants to, so target_prepare_to_store
    must have been previously called.  Calls error() if there are problems.  */
 
-extern void target_store_registers (struct regcache *regcache, int regs);
+extern void target_store_registers (regcache_raw *regcache, int regs);
 
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines

gdb/tracefile-tfile.c

@@ -841,7 +841,7 @@ traceframe_find_block_type (char type_wanted, int pos)
 
 static void
 tfile_fetch_registers (struct target_ops *ops,
-		       struct regcache *regcache, int regno)
+		       regcache_raw *regcache, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int offset, regn, regsize, dummy;

gdb/tracefile.c

@@ -385,7 +385,7 @@ trace_save_ctf (const char *dirname, int target_does_save)
    ctf.  */
 
 void
-tracefile_fetch_registers (struct regcache *regcache, int regno)
+tracefile_fetch_registers (regcache_raw *regcache, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());

gdb/tracefile.h

@@ -115,6 +115,6 @@ extern struct trace_file_writer *tfile_trace_file_writer_new (void);
 
 extern void init_tracefile_ops (struct target_ops *ops);
 
-extern void tracefile_fetch_registers (struct regcache *regcache, int regno);
+extern void tracefile_fetch_registers (regcache_raw *regcache, int regno);
 
 #endif /* TRACEFILE_H */