[pushed,13/15] Remove regcache_cooked_write_part

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0f06926..b0fb0c6 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,11 @@ 
 2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
 
+	* regcache.h (regcache_cooked_write_part): Remove, update
+	callers to use regcache::cooked_write_part.
+	* regcache.c (regcache_cooked_write_part): Remove.
+
+2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
+
 	* regcache.h (regcache_cooked_read_part): Remove, update callers
 	to use readable_regcache::cooked_read_part.
 	* regcache.c (regcache_cooked_read_part): Remove.
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 81e8a4c..1ea3670 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -1044,8 +1044,8 @@  hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		     passed in floating-point registers, are passed in
 		     the right halves of the floating point registers;
 		     the left halves are unused."  */
-		  regcache_cooked_write_part (regcache, regnum, offset % 8,
-					      len, value_contents (arg));
+		  regcache->cooked_write_part (regnum, offset % 8, len,
+					       value_contents (arg));
 		}
 	    }
 	}
@@ -1086,8 +1086,8 @@  hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       regnum = HPPA_ARG0_REGNUM - offset / 8;
       while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
 	{
-	  regcache_cooked_write_part (regcache, regnum,
-				      offset % 8, std::min (len, 8), valbuf);
+	  regcache->cooked_write_part (regnum, offset % 8, std::min (len, 8),
+				       valbuf);
 	  offset += std::min (len, 8);
 	  valbuf += std::min (len, 8);
 	  len -= std::min (len, 8);
@@ -1154,8 +1154,7 @@  hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
 	  if (readbuf != NULL)
 	    regcache->cooked_read_part (reg, 4 - part, part, readbuf);
 	  if (writebuf != NULL)
-	    regcache_cooked_write_part (regcache, reg, 4 - part,
-					part, writebuf);
+	    regcache->cooked_write_part (reg, 4 - part, part, writebuf);
 	  reg++;
 	}
       /* Now transfer the remaining register values.  */
@@ -1254,8 +1253,8 @@  hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
     {
       while (len > 0)
 	{
-	  regcache_cooked_write_part (regcache, regnum, offset,
-				      std::min (len, 8), writebuf);
+	  regcache->cooked_write_part (regnum, offset, std::min (len, 8),
+				       writebuf);
 	  writebuf += std::min (len, 8);
 	  len -= std::min (len, 8);
 	  regnum++;
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index b7cba1c..f696568 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -463,7 +463,7 @@  m32c_part_write (struct m32c_reg *reg, struct regcache *cache,
   int offset, len;
 
   m32c_find_part (reg, &offset, &len);
-  regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf);
+  cache->cooked_write_part (reg->rx->num, offset, len, buf);
 
   return REG_VALID;
 }
diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
index 1f3f2bb..c8a5ecf 100644
--- a/gdb/mep-tdep.c
+++ b/gdb/mep-tdep.c
@@ -2139,9 +2139,8 @@  mep_store_return_value (struct gdbarch *arch,
       else
         offset = 0;
 
-      regcache_cooked_write_part (regcache, MEP_R0_REGNUM,
-                                  offset, TYPE_LENGTH (type),
-                                  valbuf);
+      regcache->cooked_write_part (MEP_R0_REGNUM, offset, TYPE_LENGTH (type),
+				   valbuf);
     }
 
   /* Return values larger than a single register are returned in
diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index fdf00f0..32b2d40 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -512,8 +512,7 @@  mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
   if (in != NULL)
     regcache->cooked_read_part (reg_num, reg_offset, length, in + buf_offset);
   if (out != NULL)
-    regcache_cooked_write_part (regcache, reg_num, reg_offset, length,
-				out + buf_offset);
+    regcache->cooked_write_part (reg_num, reg_offset, length, out + buf_offset);
   if (mips_debug && in != NULL)
     {
       int i;
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index b7dfdca..0bac225 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -1286,9 +1286,8 @@  ppc64_sysv_abi_push_val (struct gdbarch *gdbarch,
   if (len > 0)
     {
       if (argpos->regcache && argpos->greg <= 10)
-	regcache_cooked_write_part (argpos->regcache,
-				    tdep->ppc_gp0_regnum + argpos->greg,
-				    offset, len, val);
+	argpos->regcache->cooked_write_part
+	  (tdep->ppc_gp0_regnum + argpos->greg, offset, len, val);
       argpos->greg++;
     }
 }
@@ -1352,8 +1351,8 @@  ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch,
 	  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	    offset = 8 - TYPE_LENGTH (type);
 
-	  regcache_cooked_write_part (argpos->regcache, regnum,
-				      offset, TYPE_LENGTH (type), val);
+	  argpos->regcache->cooked_write_part (regnum, offset,
+					       TYPE_LENGTH (type), val);
 	}
 
       argpos->freg++;
@@ -1802,8 +1801,8 @@  ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 	offset = 8 - TYPE_LENGTH (valtype);
 
       if (writebuf != NULL)
-	regcache_cooked_write_part (regcache, regnum,
-				    offset, TYPE_LENGTH (valtype), writebuf);
+	regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype),
+				     writebuf);
       if (readbuf != NULL)
 	regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype),
 				    readbuf);
@@ -1878,8 +1877,8 @@  ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 	offset = 8 - TYPE_LENGTH (valtype);
 
       if (writebuf != NULL)
-	regcache_cooked_write_part (regcache, regnum,
-				    offset, TYPE_LENGTH (valtype), writebuf);
+	regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype),
+				     writebuf);
       if (readbuf != NULL)
 	regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype),
 				    readbuf);
@@ -1983,8 +1982,8 @@  ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
       int offset = (register_size (gdbarch, regnum) - TYPE_LENGTH (valtype));
 
       if (writebuf != NULL)
-	regcache_cooked_write_part (regcache, regnum,
-				    offset, TYPE_LENGTH (valtype), writebuf);
+	regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype),
+				     writebuf);
       if (readbuf != NULL)
 	regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype),
 				    readbuf);
diff --git a/gdb/regcache.c b/gdb/regcache.c
index d8fb36e..758f21c 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -872,13 +872,6 @@  readable_regcache::cooked_read_part (int regnum, int offset, int len,
 }
 
 void
-regcache_cooked_write_part (struct regcache *regcache, int regnum,
-			    int offset, int len, const gdb_byte *buf)
-{
-  regcache->cooked_write_part (regnum, offset, len, buf);
-}
-
-void
 regcache::cooked_write_part (int regnum, int offset, int len,
 			     const gdb_byte *buf)
 {
diff --git a/gdb/regcache.h b/gdb/regcache.h
index f1a3b24..064930c 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -62,12 +62,6 @@  extern void regcache_cooked_write_signed (struct regcache *regcache,
 extern void regcache_cooked_write_unsigned (struct regcache *regcache,
 					    int regnum, ULONGEST val);
 
-/* Partial transfer of a cooked register.  These perform read, modify,
-   write style operations.  */
-
-void regcache_cooked_write_part (struct regcache *regcache, int regnum,
-				 int offset, int len, const gdb_byte *buf);
-
 /* Special routines to read/write the PC.  */
 
 /* For regcache_read_pc see common/common-regcache.h.  */
@@ -315,6 +309,8 @@  public:
      operations.  */
   void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
 
+  /* Partial transfer of a cooked register.  Perform read, modify, write style
+     operations.  */
   void cooked_write_part (int regnum, int offset, int len,
 			  const gdb_byte *buf);
 
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index a894b4b..a3a3cb6 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -1723,10 +1723,8 @@  s390_handle_arg (struct s390_arg_state *as, struct value *arg,
 	  /* When we store a single-precision value in an FP register,
 	     it occupies the leftmost bits.  */
 	  if (write_mode)
-	    regcache_cooked_write_part (as->regcache,
-					S390_F0_REGNUM + as->fr,
-					0, length,
-					value_contents (arg));
+	    as->regcache->cooked_write_part (S390_F0_REGNUM + as->fr, 0, length,
+					     value_contents (arg));
 	  as->fr += 2;
 	}
       else
@@ -1749,9 +1747,8 @@  s390_handle_arg (struct s390_arg_state *as, struct value *arg,
 	  int regnum = S390_V24_REGNUM + use_vr[as->vr] - 24;
 
 	  if (write_mode)
-	    regcache_cooked_write_part (as->regcache, regnum,
-					0, length,
-					value_contents (arg));
+	    as->regcache->cooked_write_part (regnum, 0, length,
+					     value_contents (arg));
 	  as->vr++;
 	}
       else
@@ -1980,8 +1977,7 @@  s390_register_return_value (struct gdbarch *gdbarch, struct type *type,
     {
       /* Float-like value: left-aligned in f0.  */
       if (in != NULL)
-	regcache_cooked_write_part (regcache, S390_F0_REGNUM,
-				    0, length, in);
+	regcache->cooked_write_part (S390_F0_REGNUM, 0, length, in);
       else
 	regcache->cooked_read_part (S390_F0_REGNUM, 0, length, out);
     }
@@ -1989,8 +1985,7 @@  s390_register_return_value (struct gdbarch *gdbarch, struct type *type,
     {
       /* Vector: left-aligned in v24.  */
       if (in != NULL)
-	regcache_cooked_write_part (regcache, S390_V24_REGNUM,
-				    0, length, in);
+	regcache->cooked_write_part (S390_V24_REGNUM, 0, length, in);
       else
 	regcache->cooked_read_part (S390_V24_REGNUM, 0, length, out);
     }
diff --git a/gdb/score-tdep.c b/gdb/score-tdep.c
index aa50126..e764c65 100644
--- a/gdb/score-tdep.c
+++ b/gdb/score-tdep.c
@@ -445,8 +445,8 @@  score_xfer_register (struct regcache *regcache, int regnum, int length,
     regcache->cooked_read_part (regnum, reg_offset, length,
 				readbuf + buf_offset);
   if (writebuf != NULL)
-    regcache_cooked_write_part (regcache, regnum, reg_offset, length,
-                                writebuf + buf_offset);
+    regcache->cooked_write_part (regnum, reg_offset, length,
+				 writebuf + buf_offset);
 }
 
 static enum return_value_convention
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 583cb62..80458ab 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -1356,7 +1356,7 @@  spu_value_to_regcache (struct regcache *regcache, int regnum,
   if (spu_scalar_value_p (type))
     {
       int preferred_slot = len < 4 ? 4 - len : 0;
-      regcache_cooked_write_part (regcache, regnum, preferred_slot, len, in);
+      regcache->cooked_write_part (regnum, preferred_slot, len, in);
     }
   else
     {
@@ -1368,7 +1368,7 @@  spu_value_to_regcache (struct regcache *regcache, int regnum,
 	}
 
       if (len > 0)
-	regcache_cooked_write_part (regcache, regnum, 0, len, in);
+	regcache->cooked_write_part (regnum, 0, len, in);
     }
 }
 
@@ -1540,7 +1540,7 @@  spu_return_value (struct gdbarch *gdbarch, struct value *function,
 	{
 	case RETURN_VALUE_REGISTER_CONVENTION:
 	  if (opencl_vector && TYPE_LENGTH (type) == 2)
-	    regcache_cooked_write_part (regcache, SPU_ARG1_REGNUM, 2, 2, in);
+	    regcache->cooked_write_part (SPU_ARG1_REGNUM, 2, 2, in);
 	  else
 	    spu_value_to_regcache (regcache, SPU_ARG1_REGNUM, type, in);
 	  break;
diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
index 274b02f..efb8b05 100644
--- a/gdb/tic6x-tdep.c
+++ b/gdb/tic6x-tdep.c
@@ -760,8 +760,7 @@  tic6x_store_return_value (struct type *valtype, struct regcache *regcache,
   if (len <= 4)
     {
       if (len < 3 && byte_order == BFD_ENDIAN_BIG)
-	regcache_cooked_write_part (regcache, TIC6X_A4_REGNUM, 4 - len, len,
-				    valbuf);
+	regcache->cooked_write_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
       else
 	regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
     }
@@ -957,8 +956,8 @@  tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		     so, we write the contents in VAL to the lsp of
 		     register.  */
 		  if (len < 3 && byte_order == BFD_ENDIAN_BIG)
-		    regcache_cooked_write_part (regcache, arg_regs[argreg],
-						4 - len, len, val);
+		    regcache->cooked_write_part (arg_regs[argreg], 4 - len, len,
+						 val);
 		  else
 		    regcache->cooked_write (arg_regs[argreg], val);
 		}
@@ -988,16 +987,14 @@  tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		      if (byte_order == BFD_ENDIAN_BIG)
 			{
 			  regcache->cooked_write (arg_regs[argreg] + 1, val);
-			  regcache_cooked_write_part (regcache,
-						      arg_regs[argreg], 0,
-						      len - 4, val + 4);
+			  regcache->cooked_write_part (arg_regs[argreg], 0,
+						       len - 4, val + 4);
 			}
 		      else
 			{
 			  regcache->cooked_write (arg_regs[argreg], val);
-			  regcache_cooked_write_part (regcache,
-						      arg_regs[argreg] + 1, 0,
-						      len - 4, val + 4);
+			  regcache->cooked_write_part (arg_regs[argreg] + 1, 0,
+						       len - 4, val + 4);
 			}
 		    }
 		  else