Remove regcache_cooked_write

Remove regcache_cooked_write, update callers to use
regcache::cooked_write.

gdb/ChangeLog:

	* regcache.h (regcache_cooked_write): Remove, update callers to
	use regcache::cooked_write.
	* regcache.c (regcache_cooked_write): Remove.

1 files changed, 75 insertions, 105 deletions

diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 04f9447..42dc63c 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -139,9 +139,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		      struct type *regtype
 			= register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
 		      target_float_convert (val, type, regval, regtype);
-		      regcache_cooked_write (regcache,
-                                             tdep->ppc_fp0_regnum + freg,
-					     regval);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg,
+					      regval);
 		    }
 		  freg++;
 		}
@@ -176,12 +175,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		{
 		  if (write_pass)
 		    {
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_fp0_regnum + freg,
-					     val);
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_fp0_regnum + freg + 1,
-					     val + 8);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg, val);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg + 1,
+					      val + 8);
 		    }
 		  freg += 2;
 		}
@@ -221,12 +217,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		    greg++;
 		  if (write_pass)
 		    {
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 0,
-					     val + 0);
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 1,
-					     val + 4);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 0,
+					      val + 0);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 1,
+					      val + 4);
 		    }
 		  greg += 2;
 		}
@@ -253,18 +247,14 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		{
 		  if (write_pass)
 		    {
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 0,
-					     val + 0);
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 1,
-					     val + 4);
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 2,
-					     val + 8);
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_gp0_regnum + greg + 3,
-					     val + 12);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 0,
+					      val + 0);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 1,
+					      val + 4);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 2,
+					      val + 8);
+		      regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 3,
+					      val + 12);
 		    }
 		  greg += 4;
 		}
@@ -292,8 +282,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		      else
 			p = val;
 
-		      regcache_cooked_write (regcache,
-			  tdep->ppc_fp0_regnum + freg, p);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg, p);
 		    }
 
 		  freg++;
@@ -322,10 +311,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
 		  if (write_pass)
 		    {
-		      regcache_cooked_write (regcache,
-					     tdep->ppc_fp0_regnum + freg, val);
-		      regcache_cooked_write (regcache,
-			  tdep->ppc_fp0_regnum + freg + 1, val + 8);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg, val);
+		      regcache->cooked_write (tdep->ppc_fp0_regnum + freg + 1,
+					      val + 8);
 		    }
 		}
 	      else
@@ -370,7 +358,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 				= register_type (gdbarch, regnum);
 			      target_float_convert (elval, eltype,
 						    regval, regtype);
-			      regcache_cooked_write (regcache, regnum, regval);
+			      regcache->cooked_write (regnum, regval);
 			    }
 			  freg++;
 			}
@@ -402,10 +390,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 			  if (write_pass)
 			    {
 			      int regnum = tdep->ppc_gp0_regnum + greg;
-			      regcache_cooked_write (regcache,
-						     regnum + 0, elval + 0);
-			      regcache_cooked_write (regcache,
-						     regnum + 1, elval + 4);
+			      regcache->cooked_write (regnum + 0, elval + 0);
+			      regcache->cooked_write (regnum + 1, elval + 4);
 			    }
 			  greg += 2;
 			}
@@ -419,9 +405,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		      if (greg <= 10)
 			{
 			  if (write_pass)
-			    regcache_cooked_write (regcache,
-						   tdep->ppc_gp0_regnum + greg,
-						   word);
+			    regcache->cooked_write (tdep->ppc_gp0_regnum + greg,
+						    word);
 			  greg++;
 			}
 		      else
@@ -450,9 +435,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		  if (vreg <= 13)
 		    {
 		      if (write_pass)
-			regcache_cooked_write (regcache,
-					       tdep->ppc_vr0_regnum + vreg,
-					       elval);
+			regcache->cooked_write (tdep->ppc_vr0_regnum + vreg,
+						elval);
 		      vreg++;
 		    }
 		  else
@@ -474,8 +458,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	      if (vreg <= 13)
 		{
 		  if (write_pass)
-		    regcache_cooked_write (regcache,
-					   tdep->ppc_vr0_regnum + vreg, val);
+		    regcache->cooked_write (tdep->ppc_vr0_regnum + vreg, val);
 		  vreg++;
 		}
 	      else
@@ -501,8 +484,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	      if (greg <= 10)
 		{
 		  if (write_pass)
-		    regcache_cooked_write (regcache,
-					   tdep->ppc_ev0_regnum + greg, val);
+		    regcache->cooked_write (tdep->ppc_ev0_regnum + greg, val);
 		  greg++;
 		}
 	      else
@@ -552,8 +534,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	      if (greg <= 10)
 		{
 		  if (write_pass)
-		    regcache_cooked_write (regcache,
-					   tdep->ppc_gp0_regnum + greg, word);
+		    regcache->cooked_write (tdep->ppc_gp0_regnum + greg, word);
 		  greg++;
 		}
 	      else
@@ -636,7 +617,7 @@ get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype,
 	  else
 	    p = writebuf;
 
-	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, p);
+	  regcache->cooked_write (tdep->ppc_fp0_regnum + 1, p);
 	}
       if (readbuf != NULL)
 	{
@@ -657,8 +638,8 @@ get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype,
 	  for (i = 0; i < 2; i++)
 	    {
 	      if (writebuf != NULL)
-		regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2 + i,
-				       writebuf + i * 8);
+		regcache->cooked_write (tdep->ppc_fp0_regnum + 2 + i,
+					writebuf + i * 8);
 	      if (readbuf != NULL)
 		regcache->cooked_read (tdep->ppc_fp0_regnum + 2 + i,
 				       readbuf + i * 8);
@@ -720,7 +701,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	  gdb_byte regval[PPC_MAX_REGISTER_SIZE];
 	  struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
 	  target_float_convert (writebuf, type, regval, regtype);
-	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
+	  regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -738,9 +719,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	}
       if (writebuf)
 	{
-	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, writebuf);
-	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2,
-				 writebuf + 8);
+	  regcache->cooked_write (tdep->ppc_fp0_regnum + 1, writebuf);
+	  regcache->cooked_write (tdep->ppc_fp0_regnum + 2, writebuf + 8);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -761,13 +741,10 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	}
       if (writebuf)
 	{
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
-				 writebuf + 4);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
-				 writebuf + 8);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
-				 writebuf + 12);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 5, writebuf + 8);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 6, writebuf + 12);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -787,10 +764,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	{
 	  /* A long long, double or _Decimal64 stored in the 32 bit
 	     r3/r4.  */
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
-				 writebuf + 0);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
-				 writebuf + 4);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf + 0);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -849,7 +824,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 		{
 		  target_float_convert (writebuf + offset, eltype,
 					regval, regtype);
-		  regcache_cooked_write (regcache, regnum, regval);
+		  regcache->cooked_write (regnum, regval);
 		}
 	      if (readbuf != NULL)
 		{
@@ -895,7 +870,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	  int regnum = tdep->ppc_vr0_regnum + 2 + i;
 
 	  if (writebuf != NULL)
-	    regcache_cooked_write (regcache, regnum, writebuf + offset);
+	    regcache->cooked_write (regnum, writebuf + offset);
 	  if (readbuf != NULL)
 	    regcache->cooked_read (regnum, readbuf + offset);
 	}
@@ -915,7 +890,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
       if (writebuf)
 	{
 	  /* Altivec places the return value in "v2".  */
-	  regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
+	  regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -936,14 +911,10 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	}
       if (writebuf)
 	{
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
-				 writebuf + 0);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
-				 writebuf + 4);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
-				 writebuf + 8);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
-				 writebuf + 12);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf + 0);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 5, writebuf + 8);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 6, writebuf + 12);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -960,7 +931,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
       if (readbuf)
 	regcache->cooked_read (tdep->ppc_ev0_regnum + 3, readbuf);
       if (writebuf)
-	regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf);
+	regcache->cooked_write (tdep->ppc_ev0_regnum + 3, writebuf);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
   if (broken_gcc && TYPE_LENGTH (type) <= 8)
@@ -985,11 +956,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	{
 	  memset (regvals, 0, sizeof regvals);
 	  memcpy (regvals + offset, writebuf, len);
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
-				 regvals + 0 * tdep->wordsize);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3,
+				  regvals + 0 * tdep->wordsize);
 	  if (len > tdep->wordsize)
-	    regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
-				   regvals + 1 * tdep->wordsize);
+	    regcache->cooked_write (tdep->ppc_gp0_regnum + 4,
+				    regvals + 1 * tdep->wordsize);
 	}
 
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -1017,11 +988,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
 	  gdb_byte regvals[PPC_MAX_REGISTER_SIZE * 2];
 	  memset (regvals, 0, sizeof regvals);
 	  memcpy (regvals, writebuf, TYPE_LENGTH (type));
-	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
-				 regvals + 0 * tdep->wordsize);
+	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3,
+				  regvals + 0 * tdep->wordsize);
 	  if (TYPE_LENGTH (type) > tdep->wordsize)
-	    regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
-				   regvals + 1 * tdep->wordsize);
+	    regcache->cooked_write (tdep->ppc_gp0_regnum + 4,
+				    regvals + 1 * tdep->wordsize);
 	}
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
@@ -1305,8 +1276,8 @@ ppc64_sysv_abi_push_val (struct gdbarch *gdbarch,
   while (len >= tdep->wordsize)
     {
       if (argpos->regcache && argpos->greg <= 10)
-	regcache_cooked_write (argpos->regcache,
-			       tdep->ppc_gp0_regnum + argpos->greg, val);
+	argpos->regcache->cooked_write (tdep->ppc_gp0_regnum + argpos->greg,
+					val);
       argpos->greg++;
       len -= tdep->wordsize;
       val += tdep->wordsize;
@@ -1363,7 +1334,7 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch,
 	  gdb_byte regval[PPC_MAX_REGISTER_SIZE];
 
 	  target_float_convert (val, type, regval, regtype);
-	  regcache_cooked_write (argpos->regcache, regnum, regval);
+	  argpos->regcache->cooked_write (regnum, regval);
 	}
 
       argpos->freg++;
@@ -1397,9 +1368,9 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch,
 	{
 	  int regnum = tdep->ppc_fp0_regnum + argpos->freg;
 
-	  regcache_cooked_write (argpos->regcache, regnum, val);
+	  argpos->regcache->cooked_write (regnum, val);
 	  if (argpos->freg <= 12)
-	    regcache_cooked_write (argpos->regcache, regnum + 1, val + 8);
+	    argpos->regcache->cooked_write (regnum + 1, val + 8);
 	}
 
       argpos->freg += 2;
@@ -1417,8 +1388,8 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch,
 	  int lopart = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 8 : 0;
 	  int hipart = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 0 : 8;
 
-	  regcache_cooked_write (argpos->regcache, regnum, val + hipart);
-	  regcache_cooked_write (argpos->regcache, regnum + 1, val + lopart);
+	  argpos->regcache->cooked_write (regnum, val + hipart);
+	  argpos->regcache->cooked_write (regnum + 1, val + lopart);
 	}
 
       argpos->freg += 2;
@@ -1435,8 +1406,7 @@ ppc64_sysv_abi_push_vreg (struct gdbarch *gdbarch, const bfd_byte *val,
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (argpos->regcache && argpos->vreg <= 13)
-    regcache_cooked_write (argpos->regcache,
-			   tdep->ppc_vr0_regnum + argpos->vreg, val);
+    argpos->regcache->cooked_write (tdep->ppc_vr0_regnum + argpos->vreg, val);
 
   argpos->vreg++;
 }
@@ -1810,7 +1780,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
       if (writebuf != NULL)
 	{
 	  target_float_convert (writebuf, valtype, regval, regtype);
-	  regcache_cooked_write (regcache, regnum, regval);
+	  regcache->cooked_write (regnum, regval);
 	}
       if (readbuf != NULL)
 	{
@@ -1850,8 +1820,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 
       if (writebuf != NULL)
 	{
-	  regcache_cooked_write (regcache, regnum, writebuf);
-	  regcache_cooked_write (regcache, regnum + 1, writebuf + 8);
+	  regcache->cooked_write (regnum, writebuf);
+	  regcache->cooked_write (regnum + 1, writebuf + 8);
 	}
       if (readbuf != NULL)
 	{
@@ -1872,8 +1842,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 
       if (writebuf != NULL)
 	{
-	  regcache_cooked_write (regcache, regnum, writebuf + hipart);
-	  regcache_cooked_write (regcache, regnum + 1, writebuf + lopart);
+	  regcache->cooked_write (regnum, writebuf + hipart);
+	  regcache->cooked_write (regnum + 1, writebuf + lopart);
 	}
       if (readbuf != NULL)
 	{
@@ -1891,7 +1861,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
       int regnum = tdep->ppc_vr0_regnum + 2 + index;
 
       if (writebuf != NULL)
-	regcache_cooked_write (regcache, regnum, writebuf);
+	regcache->cooked_write (regnum, writebuf);
       if (readbuf != NULL)
 	regcache->cooked_read (regnum, readbuf);
       return 1;
@@ -1996,7 +1966,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
       int regnum = tdep->ppc_gp0_regnum + 3;
 
       if (writebuf != NULL)
-	regcache_cooked_write (regcache, regnum, writebuf);
+	regcache->cooked_write (regnum, writebuf);
       if (readbuf != NULL)
 	regcache->cooked_read (regnum, readbuf);
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -2078,7 +2048,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
 		memcpy (regval + tdep->wordsize - len, writebuf, len);
 	      else
 		memcpy (regval, writebuf + offset, len);
-	      regcache_cooked_write (regcache, regnum, regval);
+	      regcache->cooked_write (regnum, regval);
 	    }
 	  if (readbuf != NULL)
 	    {