2005-05-24 Andrew Cagney <cagney@gnu.org>

	* rs6000-tdep.c (ppc_supply_reg, ppc_collect_reg): Use gdb_byte
	for byte buffers.
	(rs6000_fetch_pointer_argument): Use get_frame_register_unsigned.
	(rs6000_software_single_step, sstep_breaks, skip_prologue)
	(rs6000_push_dummy_call, rs6000_push_dummy_call)
	(rs6000_push_dummy_call, rs6000_push_dummy_call)
	(rs6000_register_to_value, e500_pseudo_register_read)
	(rs6000_store_return_value, e500_pseudo_register_write)
	(rs6000_frame_prev_register, rs6000_extract_return_value): Ditto.
	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call)
	(ppc_sysv_abi_push_dummy_call, do_ppc_sysv_return_value)
	(do_ppc_sysv_return_value, ppc_sysv_abi_return_value)
	(ppc_sysv_abi_broken_return_value)
	(ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_push_dummy_call)
	(ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_return_value)
	(ppc64_sysv_abi_return_value, ppc64_sysv_abi_return_value): Ditto.
	* ppc-linux-tdep.c (ppc_linux_in_sigtramp)
	(ppc_linux_at_sigtramp_return_path)
	(ppc_linux_skip_trampoline_code)
	(ppc_linux_memory_remove_breakpoint, ppc_linux_return_value):
	* rs6000-tdep.c (rs6000_value_to_register)
	(rs6000_register_to_value): Ditto.
	* ppc-tdep.h (ppc_sysv_abi_return_value)
	(ppc64_sysv_abi_return_value, ppc_sysv_abi_broken_return_value)
	(ppc_linux_memory_remove_breakpoint): Ditto.

5 files changed, 94 insertions, 67 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ffd1c80..a91f556 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,31 @@
+2005-05-24  Andrew Cagney  <cagney@gnu.org>
+
+	* rs6000-tdep.c (ppc_supply_reg, ppc_collect_reg): Use gdb_byte
+	for byte buffers.
+	(rs6000_fetch_pointer_argument): Use get_frame_register_unsigned.
+	(rs6000_software_single_step, sstep_breaks, skip_prologue) 
+	(rs6000_push_dummy_call, rs6000_push_dummy_call) 
+	(rs6000_push_dummy_call, rs6000_push_dummy_call) 
+	(rs6000_register_to_value, e500_pseudo_register_read) 
+	(rs6000_store_return_value, e500_pseudo_register_write) 
+	(rs6000_frame_prev_register, rs6000_extract_return_value): Ditto.
+	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call)
+	(ppc_sysv_abi_push_dummy_call, do_ppc_sysv_return_value)
+	(do_ppc_sysv_return_value, ppc_sysv_abi_return_value)
+	(ppc_sysv_abi_broken_return_value)
+	(ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_push_dummy_call)
+	(ppc64_sysv_abi_push_dummy_call, ppc64_sysv_abi_return_value)
+	(ppc64_sysv_abi_return_value, ppc64_sysv_abi_return_value): Ditto.
+	* ppc-linux-tdep.c (ppc_linux_in_sigtramp)
+	(ppc_linux_at_sigtramp_return_path)
+	(ppc_linux_skip_trampoline_code)
+	(ppc_linux_memory_remove_breakpoint, ppc_linux_return_value):
+	* rs6000-tdep.c (rs6000_value_to_register)
+	(rs6000_register_to_value): Ditto.
+	* ppc-tdep.h (ppc_sysv_abi_return_value)
+	(ppc64_sysv_abi_return_value, ppc_sysv_abi_broken_return_value)
+	(ppc_linux_memory_remove_breakpoint): Ditto.
+
 2005-05-24  Ulrich Weigand  <uweigand@de.ibm.com>
 
 	* s390-tdep.c (s390_frame_prev_register): Change type of last
diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index 6b69573..e6d8941 100644
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -157,7 +157,7 @@ ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
   CORE_ADDR lr;
   CORE_ADDR sp;
   CORE_ADDR tramp_sp;
-  char buf[4];
+  gdb_byte buf[4];
   CORE_ADDR handler;
 
   lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
@@ -205,7 +205,7 @@ insn_is_sigreturn (unsigned long pcinsn)
 static int
 ppc_linux_at_sigtramp_return_path (CORE_ADDR pc)
 {
-  char buf[12];
+  gdb_byte buf[12];
   unsigned long pcinsn;
   if (target_read_memory (pc - 4, buf, sizeof (buf)) != 0)
     return 0;
@@ -224,7 +224,7 @@ ppc_linux_at_sigtramp_return_path (CORE_ADDR pc)
 static CORE_ADDR
 ppc_linux_skip_trampoline_code (CORE_ADDR pc)
 {
-  char buf[4];
+  gdb_byte buf[4];
   struct obj_section *sect;
   struct objfile *objfile;
   unsigned long insn;
@@ -317,7 +317,8 @@ ppc_linux_skip_trampoline_code (CORE_ADDR pc)
   /* Fetch the string; we don't know how long it is.  Is it possible
      that the following will fail because we're trying to fetch too
      much? */
-  if (target_read_memory (strtab + symidx, symname, sizeof (symname)) != 0)
+  if (target_read_memory (strtab + symidx, (gdb_byte *) symname,
+			  sizeof (symname)) != 0)
     return 0;
 
   /* This might not work right if we have multiple symbols with the
@@ -455,12 +456,13 @@ ppc_linux_skip_trampoline_code (CORE_ADDR pc)
    regard to removing breakpoints in some potentially self modifying
    code.  */
 int
-ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
+ppc_linux_memory_remove_breakpoint (CORE_ADDR addr,
+				    gdb_byte *contents_cache)
 {
   const unsigned char *bp;
   int val;
   int bplen;
-  char old_contents[BREAKPOINT_MAX];
+  gdb_byte old_contents[BREAKPOINT_MAX];
 
   /* Determine appropriate breakpoint contents and size for this address.  */
   bp = BREAKPOINT_FROM_PC (&addr, &bplen);
@@ -485,8 +487,8 @@ ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 
 static enum return_value_convention
 ppc_linux_return_value (struct gdbarch *gdbarch, struct type *valtype,
-			struct regcache *regcache, void *readbuf,
-			const void *writebuf)
+			struct regcache *regcache, gdb_byte *readbuf,
+			const gdb_byte *writebuf)
 {  
   if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
        || TYPE_CODE (valtype) == TYPE_CODE_UNION)
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 7863aca..b172dc0 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -114,7 +114,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		    {
 		      /* Always store the floating point value using
 		         the register's floating-point format.  */
-		      char regval[MAX_REGISTER_SIZE];
+		      gdb_byte regval[MAX_REGISTER_SIZE];
 		      struct type *regtype
 			= register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
 		      convert_typed_floating (val, type, regval, regtype);
@@ -242,7 +242,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	    {
 	      /* Reduce the parameter down to something that fits in a
 	         "word".  */
-	      char word[MAX_REGISTER_SIZE];
+	      gdb_byte word[MAX_REGISTER_SIZE];
 	      memset (word, 0, MAX_REGISTER_SIZE);
 	      if (len > tdep->wordsize
 		  || TYPE_CODE (type) == TYPE_CODE_STRUCT
@@ -340,7 +340,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
 	{
 	  /* Floats and doubles stored in "f1".  Convert the value to
 	     the required type.  */
-	  char regval[MAX_REGISTER_SIZE];
+	  gdb_byte regval[MAX_REGISTER_SIZE];
 	  struct type *regtype = register_type (gdbarch,
                                                 tdep->ppc_fp0_regnum + 1);
 	  regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
@@ -350,7 +350,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
 	{
 	  /* Floats and doubles stored in "f1".  Convert the value to
 	     the register's "double" type.  */
-	  char regval[MAX_REGISTER_SIZE];
+	  gdb_byte regval[MAX_REGISTER_SIZE];
 	  struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
 	  convert_typed_floating (writebuf, type, regval, regtype);
 	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
@@ -488,7 +488,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
 	  /* This matches SVr4 PPC, it does not match GCC.  */
 	  /* The value is right-padded to 8 bytes and then loaded, as
 	     two "words", into r3/r4.  */
-	  char regvals[MAX_REGISTER_SIZE * 2];
+	  gdb_byte regvals[MAX_REGISTER_SIZE * 2];
 	  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
 				regvals + 0 * tdep->wordsize);
 	  if (TYPE_LENGTH (type) > tdep->wordsize)
@@ -501,7 +501,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
 	  /* This matches SVr4 PPC, it does not match GCC.  */
 	  /* The value is padded out to 8 bytes and then loaded, as
 	     two "words" into r3/r4.  */
-	  char regvals[MAX_REGISTER_SIZE * 2];
+	  gdb_byte regvals[MAX_REGISTER_SIZE * 2];
 	  memset (regvals, 0, sizeof regvals);
 	  memcpy (regvals, writebuf, TYPE_LENGTH (type));
 	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
@@ -517,8 +517,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
 
 enum return_value_convention
 ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
-			   struct regcache *regcache, void *readbuf,
-			   const void *writebuf)
+			   struct regcache *regcache, gdb_byte *readbuf,
+			   const gdb_byte *writebuf)
 {
   return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf,
 				   writebuf, 0);
@@ -528,7 +528,7 @@ enum return_value_convention
 ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch,
 				  struct type *valtype,
 				  struct regcache *regcache,
-				  void *readbuf, const void *writebuf)
+				  gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf,
 				   writebuf, 1);
@@ -688,7 +688,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		  if (ppc_floating_point_unit_p (current_gdbarch)
 		      && freg <= 13)
 		    {
-		      char regval[MAX_REGISTER_SIZE];
+		      gdb_byte regval[MAX_REGISTER_SIZE];
 		      struct type *regtype
                         = register_type (gdbarch, tdep->ppc_fp0_regnum);
 		      convert_typed_floating (val, type, regval, regtype);
@@ -707,7 +707,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
 		         This code interprets that to mean: store it,
 		         left aligned, in the general register.  */
-		      char regval[MAX_REGISTER_SIZE];
+		      gdb_byte regval[MAX_REGISTER_SIZE];
 		      memset (regval, 0, sizeof regval);
 		      memcpy (regval, val, TYPE_LENGTH (type));
 		      regcache_cooked_write (regcache,
@@ -782,7 +782,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 		{
 		  if (write_pass && greg <= 10)
 		    {
-		      char regval[MAX_REGISTER_SIZE];
+		      gdb_byte regval[MAX_REGISTER_SIZE];
 		      int len = TYPE_LENGTH (type) - byte;
 		      if (len > tdep->wordsize)
 			len = tdep->wordsize;
@@ -880,8 +880,8 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
    corresponding register return-value location.  */
 enum return_value_convention
 ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
-			     struct regcache *regcache, void *readbuf,
-			     const void *writebuf)
+			     struct regcache *regcache, gdb_byte *readbuf,
+			     const gdb_byte *writebuf)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
@@ -893,7 +893,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
   /* Floats and doubles in F1.  */
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
     {
-      char regval[MAX_REGISTER_SIZE];
+      gdb_byte regval[MAX_REGISTER_SIZE];
       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
       if (writebuf != NULL)
 	{
@@ -984,7 +984,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
 	  int i;
 	  for (i = 0; i < 2; i++)
 	    {
-	      char regval[MAX_REGISTER_SIZE];
+	      gdb_byte regval[MAX_REGISTER_SIZE];
 	      struct type *regtype =
 		register_type (current_gdbarch, tdep->ppc_fp0_regnum);
 	      if (writebuf != NULL)
diff --git a/gdb/ppc-tdep.h b/gdb/ppc-tdep.h
index 1a5bc6f..a2c77da 100644
--- a/gdb/ppc-tdep.h
+++ b/gdb/ppc-tdep.h
@@ -33,13 +33,13 @@ struct type;
 enum return_value_convention ppc_sysv_abi_return_value (struct gdbarch *gdbarch,
 							struct type *valtype,
 							struct regcache *regcache,
-							void *readbuf,
-							const void *writebuf);
+							gdb_byte *readbuf,
+							const gdb_byte *writebuf);
 enum return_value_convention ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch,
 							       struct type *valtype,
 							       struct regcache *regcache,
-							       void *readbuf,
-							       const void *writebuf);
+							       gdb_byte *readbuf,
+							       const gdb_byte *writebuf);
 CORE_ADDR ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
 					struct value *function,
 					struct regcache *regcache,
@@ -56,7 +56,8 @@ CORE_ADDR ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
 					  CORE_ADDR struct_addr);
 CORE_ADDR ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch *gdbarch,
 						    CORE_ADDR bpaddr);
-int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
+int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr,
+					gdb_byte *contents_cache);
 struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
 void ppc_linux_supply_gregset (struct regcache *regcache,
 			       int regnum, const void *gregs, size_t size,
@@ -68,8 +69,8 @@ void ppc_linux_supply_fpregset (const struct regset *regset,
 enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch,
 							  struct type *valtype,
 							  struct regcache *regcache,
-							  void *readbuf,
-							  const void *writebuf);
+							  gdb_byte *readbuf,
+							  const gdb_byte *writebuf);
 
 /* From rs6000-tdep.c... */
 int altivec_register_p (int regno);
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 230f110..7f37d3e 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -112,12 +112,12 @@ struct reg
 /* Breakpoint shadows for the single step instructions will be kept here. */
 
 static struct sstep_breaks
-  {
-    /* Address, or 0 if this is not in use.  */
-    CORE_ADDR address;
-    /* Shadow contents.  */
-    char data[4];
-  }
+{
+  /* Address, or 0 if this is not in use.  */
+  CORE_ADDR address;
+  /* Shadow contents.  */
+  gdb_byte data[4];
+}
 stepBreaks[2];
 
 /* Hook for determining the TOC address when calling functions in the
@@ -319,7 +319,7 @@ rs6000_register_sim_regno (int reg)
 
 static void
 ppc_supply_reg (struct regcache *regcache, int regnum, 
-		const char *regs, size_t offset)
+		const gdb_byte *regs, size_t offset)
 {
   if (regnum != -1 && offset != -1)
     regcache_raw_supply (regcache, regnum, regs + offset);
@@ -327,7 +327,7 @@ ppc_supply_reg (struct regcache *regcache, int regnum,
 
 static void
 ppc_collect_reg (const struct regcache *regcache, int regnum,
-		 char *regs, size_t offset)
+		 gdb_byte *regs, size_t offset)
 {
   if (regnum != -1 && offset != -1)
     regcache_raw_collect (regcache, regnum, regs + offset);
@@ -520,9 +520,7 @@ static CORE_ADDR
 rs6000_fetch_pointer_argument (struct frame_info *frame, int argi, 
 			       struct type *type)
 {
-  CORE_ADDR addr;
-  get_frame_register (frame, 3 + argi, &addr);
-  return addr;
+  return get_frame_register_unsigned (frame, 3 + argi);
 }
 
 /* Calculate the destination of a branch/jump.  Return -1 if not a branch.  */
@@ -621,7 +619,7 @@ rs6000_software_single_step (enum target_signal signal,
 {
   CORE_ADDR dummy;
   int breakp_sz;
-  const char *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz);
+  const gdb_byte *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz);
   int ii, insn;
   CORE_ADDR loc;
   CORE_ADDR breaks[2];
@@ -831,7 +829,7 @@ skip_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct rs6000_framedata *fdata)
   CORE_ADDR orig_pc = pc;
   CORE_ADDR last_prologue_pc = pc;
   CORE_ADDR li_found_pc = 0;
-  char buf[4];
+  gdb_byte buf[4];
   unsigned long op;
   long offset = 0;
   long vr_saved_offset = 0;
@@ -1429,7 +1427,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   int len = 0;
   int argno;			/* current argument number */
   int argbytes;			/* current argument byte */
-  char tmp_buffer[50];
+  gdb_byte tmp_buffer[50];
   int f_argno = 0;		/* current floating point argno */
   int wordsize = gdbarch_tdep (current_gdbarch)->wordsize;
   CORE_ADDR func_addr = find_function_addr (function, NULL);
@@ -1507,7 +1505,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	  /* Argument takes more than one register.  */
 	  while (argbytes < len)
 	    {
-	      char word[MAX_REGISTER_SIZE];
+	      gdb_byte word[MAX_REGISTER_SIZE];
 	      memset (word, 0, reg_size);
 	      memcpy (word,
 		      ((char *) value_contents (arg)) + argbytes,
@@ -1528,7 +1526,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 	{
 	  /* Argument can fit in one register.  No problem.  */
 	  int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
-	  char word[MAX_REGISTER_SIZE];
+	  gdb_byte word[MAX_REGISTER_SIZE];
 
 	  memset (word, 0, reg_size);
 	  memcpy (word, value_contents (arg), len);
@@ -1589,7 +1587,7 @@ ran_out_of_registers_for_arguments:
       if (argbytes)
 	{
 	  write_memory (sp + 24 + (ii * 4),
-			((char *) value_contents (arg)) + argbytes,
+			value_contents (arg) + argbytes,
 			len - argbytes);
 	  ++argno;
 	  ii += ((len - argbytes + 3) & -4) / 4;
@@ -1617,9 +1615,7 @@ ran_out_of_registers_for_arguments:
 	      ++f_argno;
 	    }
 
-	  write_memory (sp + 24 + (ii * 4),
-                        (char *) value_contents (arg),
-                        len);
+	  write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
 	  ii += ((len + 3) & -4) / 4;
 	}
     }
@@ -1665,8 +1661,8 @@ rs6000_use_struct_convention (int gcc_p, struct type *value_type)
 }
 
 static void
-rs6000_extract_return_value (struct type *valtype, bfd_byte *regbuf,
-			     bfd_byte *valbuf)
+rs6000_extract_return_value (struct type *valtype, gdb_byte *regbuf,
+			     gdb_byte *valbuf)
 {
   int offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@@ -1933,10 +1929,10 @@ static void
 rs6000_register_to_value (struct frame_info *frame,
                           int regnum,
                           struct type *type,
-                          void *to)
+                          gdb_byte *to)
 {
   const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum;
-  char from[MAX_REGISTER_SIZE];
+  gdb_byte from[MAX_REGISTER_SIZE];
   
   gdb_assert (reg->fpr);
   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
@@ -1949,10 +1945,10 @@ static void
 rs6000_value_to_register (struct frame_info *frame,
                           int regnum,
                           struct type *type,
-                          const void *from)
+                          const gdb_byte *from)
 {
   const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum;
-  char to[MAX_REGISTER_SIZE];
+  gdb_byte to[MAX_REGISTER_SIZE];
 
   gdb_assert (reg->fpr);
   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
@@ -1986,14 +1982,14 @@ rs6000_value_to_register (struct frame_info *frame,
    co-variant type qualifiers, ...  */
 static void
 e500_move_ev_register (void (*move) (struct regcache *regcache,
-                                     int regnum, void *buf),
+                                     int regnum, gdb_byte *buf),
                        struct regcache *regcache, int ev_reg,
-                       void *buffer)
+                       gdb_byte *buffer)
 {
   struct gdbarch *arch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (arch); 
   int reg_index;
-  char *byte_buffer = buffer;
+  gdb_byte *byte_buffer = buffer;
 
   gdb_assert (tdep->ppc_ev0_regnum <= ev_reg
               && ev_reg < tdep->ppc_ev0_regnum + ppc_num_gprs);
@@ -2014,7 +2010,7 @@ e500_move_ev_register (void (*move) (struct regcache *regcache,
 
 static void
 e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
-			   int reg_nr, void *buffer)
+			   int reg_nr, gdb_byte *buffer)
 {
   struct gdbarch *regcache_arch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
@@ -2033,7 +2029,7 @@ e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 
 static void
 e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
-			    int reg_nr, const void *buffer)
+			    int reg_nr, const gdb_byte *buffer)
 {
   struct gdbarch *regcache_arch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
@@ -2042,9 +2038,9 @@ e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
  
   if (tdep->ppc_ev0_regnum <= reg_nr
       && reg_nr < tdep->ppc_ev0_regnum + ppc_num_gprs)
-    e500_move_ev_register ((void (*) (struct regcache *, int, void *))
+    e500_move_ev_register ((void (*) (struct regcache *, int, gdb_byte *))
                            regcache_raw_write,
-                           regcache, reg_nr, (void *) buffer);
+                           regcache, reg_nr, (gdb_byte *) buffer);
   else
     internal_error (__FILE__, __LINE__,
                     _("e500_pseudo_register_read: "
@@ -2161,7 +2157,7 @@ rs6000_dwarf2_reg_to_regnum (int num)
 static void
 rs6000_store_return_value (struct type *type,
                            struct regcache *regcache,
-                           const void *valbuf)
+                           const gdb_byte *valbuf)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
@@ -2201,7 +2197,7 @@ rs6000_store_return_value (struct type *type,
                                      register_size (gdbarch, regnum));
         regcache_cooked_write_part (regcache, regnum,
                                     0, bytes_to_write,
-                                    (char *) valbuf + bytes_written);
+                                    valbuf + bytes_written);
         regnum++;
         bytes_written += bytes_to_write;
       }
@@ -3001,7 +2997,7 @@ rs6000_frame_prev_register (struct frame_info *next_frame,
 				 void **this_cache,
 				 int regnum, int *optimizedp,
 				 enum lval_type *lvalp, CORE_ADDR *addrp,
-				 int *realnump, void *valuep)
+				 int *realnump, gdb_byte *valuep)
 {
   struct rs6000_frame_cache *info = rs6000_frame_cache (next_frame,
 							this_cache);