Remove regcache_raw_read_part

Remove regcache_raw_read_part, update callers to use
readable_regcache::raw_read_part instead.

gdb/ChangeLog:

	* regcache.h (regcache_raw_read_part): Remove, update callers to
	use readable_regcache::raw_read_part instead.
	* regcache.c (regcache_raw_read_part): Remove.

7 files changed, 12 insertions, 15 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 98b80d3..e7a57c0 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,11 @@
 2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
 
+	* regcache.h (regcache_raw_read_part): Remove, update callers to
+	use readable_regcache::raw_read_part instead.
+	* regcache.c (regcache_raw_read_part): Remove.
+
+2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
+
 	* regcache.h (regcache_cooked_read): Remove, update callers to
 	use readable_regcache::cooked_read instead.
 	* regcache.c (regcache_cooked_read): Remove.
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 597bb0f..dfd1118 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -844,8 +844,8 @@ amd64_return_value (struct gdbarch *gdbarch, struct value *function,
       gdb_assert (regnum != -1);
 
       if (readbuf)
-	regcache_raw_read_part (regcache, regnum, offset, std::min (len, 8),
-				readbuf + i * 8);
+	regcache->raw_read_part (regnum, offset, std::min (len, 8),
+				 readbuf + i * 8);
       if (writebuf)
 	regcache_raw_write_part (regcache, regnum, offset, std::min (len, 8),
 				 writebuf + i * 8);
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index 32ebead..bf351ee 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -329,7 +329,7 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
     {
       /* Extract the return value from the register where it was stored.  */
       if (readbuf)
-	regcache_raw_read_part (regcache, regnum, 0, len, readbuf);
+	regcache->raw_read_part (regnum, 0, len, readbuf);
       if (writebuf)
 	regcache_raw_write_part (regcache, regnum, 0, len, writebuf);
       return RETURN_VALUE_REGISTER_CONVENTION;
diff --git a/gdb/regcache.c b/gdb/regcache.c
index ec1bfb0..051bd48 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -867,13 +867,6 @@ regcache::write_part (int regnum, int offset, int len,
 }
 
 enum register_status
-regcache_raw_read_part (struct regcache *regcache, int regnum,
-			int offset, int len, gdb_byte *buf)
-{
-  return regcache->raw_read_part (regnum, offset, len, buf);
-}
-
-enum register_status
 readable_regcache::raw_read_part (int regnum, int offset, int len, gdb_byte *buf)
 {
   assert_regnum (regnum);
diff --git a/gdb/regcache.h b/gdb/regcache.h
index f7228e4..4865d89 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -54,9 +54,6 @@ extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
    write style operations.  The read variant returns the status of the
    register.  */
 
-extern enum register_status
-  regcache_raw_read_part (struct regcache *regcache, int regnum,
-			  int offset, int len, gdb_byte *buf);
 void regcache_raw_write_part (struct regcache *regcache, int regnum,
 			      int offset, int len, const gdb_byte *buf);
 
@@ -243,6 +240,7 @@ public:
   template<typename T, typename = RequireLongest<T>>
   enum register_status raw_read (int regnum, T *val);
 
+  /* Partial transfer of raw registers.  Return the status of the register.  */
   enum register_status raw_read_part (int regnum, int offset, int len,
 				      gdb_byte *buf);
 
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 4628776..1d0766e 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -1655,7 +1655,7 @@ spu_software_single_step (struct regcache *regcache)
 	target += SPUADDR_ADDR (pc);
       else if (reg != -1)
       {
-	regcache_raw_read_part (regcache, reg, 0, 4, buf);
+	regcache->raw_read_part (reg, 0, 4, buf);
 	target += extract_unsigned_integer (buf, 4, byte_order) & -4;
       }
 
diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index c23d777..bee4969 100644
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -1596,7 +1596,7 @@ xtensa_extract_return_value (struct type *type,
   for (; len > 0; len -= 4, areg++, valbuf += 4)
     {
       if (len < 4)
-	regcache_raw_read_part (regcache, areg, offset, len, valbuf);
+	regcache->raw_read_part (areg, offset, len, valbuf);
       else
 	regcache->raw_read (areg, valbuf);
     }