This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch/rfc] Finish deprecating REGISTER_RAW_SIZE


Hello,

This follows through the deprecation of REGISTER_RAW_SIZE. The road-block (MIPS) was cleaned up so it's no longer needed.

I'll look to commit this in a few days,
Andrew
2003-09-27  Andrew Cagney  <cagney@redhat.com>

	* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
	REGISTER_RAW_SIZE.
	* gdbarch.h, gdbarch.c: Re-generate.
	* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
	* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
	* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
	* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
	* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
	* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
	* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
	* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
	* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
	* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
	* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
	* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
	* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
	* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
	* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
	* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
	
Index: doc/ChangeLog
2003-09-27  Andrew Cagney  <cagney@redhat.com>

	* gdbint.texinfo (Target Architecture Definition): Rename
	REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
	* gdb.texinfo (Packets, Stop Reply Packets): Ditto.

Index: tui/ChangeLog
2003-09-27  Andrew Cagney  <cagney@redhat.com>

	* tuiRegs.c: Rename REGISTER_RAW_SIZE to
	DEPRECATED_REGISTER_RAW_SIZE.

Index: aix-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/aix-thread.c,v
retrieving revision 1.14
diff -u -r1.14 aix-thread.c
--- aix-thread.c	22 Aug 2002 15:27:16 -0000	1.14
+++ aix-thread.c	28 Sep 2003 01:46:10 -0000
@@ -852,7 +852,7 @@
     return;
 
   /* Check application word size.  */
-  arch64 = REGISTER_RAW_SIZE (0) == 8;
+  arch64 = DEPRECATED_REGISTER_RAW_SIZE (0) == 8;
 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
@@ -1281,7 +1281,7 @@
      they're not, then either GDB has been built incorrectly, or
      there's some other kind of internal error.  To be really safe,
      we should check all of the sizes.   */
-  gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (PC_REGNUM));
+  gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
 
   if (register_cached (PC_REGNUM))
     regcache_collect (PC_REGNUM, iar);
@@ -1316,7 +1316,7 @@
      built incorrectly.  In order to make use of many of the header
      files in /usr/include/sys, GDB needs to be configured so that
      sizeof (long) == 4).  */
-  gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (PC_REGNUM));
+  gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
 
   if (register_cached (PC_REGNUM))
     regcache_collect (PC_REGNUM, iar);
Index: alpha-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.h,v
retrieving revision 1.19
diff -u -r1.19 alpha-tdep.h
--- alpha-tdep.h	11 Jul 2003 21:49:04 -0000	1.19
+++ alpha-tdep.h	28 Sep 2003 01:46:10 -0000
@@ -23,8 +23,9 @@
 #define ALPHA_TDEP_H
 
 /* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places;  REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
+   used in push_word and a few other places;
+   DEPRECATED_REGISTER_RAW_SIZE is the real way to know how big a
+   register is.  */
 #define ALPHA_REGISTER_SIZE 8
 
 /* Number of machine registers.  */
Index: arm-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/arm-tdep.c,v
retrieving revision 1.151
diff -u -r1.151 arm-tdep.c
--- arm-tdep.c	25 Sep 2003 14:21:00 -0000	1.151
+++ arm-tdep.c	28 Sep 2003 01:46:20 -0000
@@ -1102,7 +1102,7 @@
   cache->framereg = ARM_SP_REGNUM;
   cache->prev_sp
     = read_memory_integer (cache->saved_regs[cache->framereg].addr,
-			   REGISTER_RAW_SIZE (cache->framereg));
+			   DEPRECATED_REGISTER_RAW_SIZE (cache->framereg));
 
   return cache;
 }
Index: core-sol2.c
===================================================================
RCS file: /cvs/src/src/gdb/core-sol2.c,v
retrieving revision 1.12
diff -u -r1.12 core-sol2.c
--- core-sol2.c	17 Sep 2003 15:42:17 -0000	1.12
+++ core-sol2.c	28 Sep 2003 01:46:20 -0000
@@ -98,7 +98,7 @@
 
 	  /* The globals and output registers.  */
 	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
-		  &gregs->r_g1, 15 * REGISTER_RAW_SIZE (G1_REGNUM));
+		  &gregs->r_g1, 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
 	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
 	    = gregs->r_ps;
 	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)]
@@ -119,7 +119,7 @@
 	    sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
 	    if (0 != target_read_memory (sp,
 					 &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-					 16 * REGISTER_RAW_SIZE (L0_REGNUM)))
+					 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)))
 	      {
 		warning ("couldn't read input and local registers from core file\n");
 	      }
Index: cris-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/cris-tdep.c,v
retrieving revision 1.88
diff -u -r1.88 cris-tdep.c
--- cris-tdep.c	27 Sep 2003 15:51:02 -0000	1.88
+++ cris-tdep.c	28 Sep 2003 01:47:02 -0000
@@ -1224,7 +1224,7 @@
           /* SRP was saved on the stack; non-leaf function.  */
           get_frame_extra_info (fi)->return_pc =
             read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM], 
-                                 REGISTER_RAW_SIZE (SRP_REGNUM));
+                                 REGISTER_REGISTER_RAW_SIZE (SRP_REGNUM));
         }
       else
         {
@@ -4184,8 +4184,9 @@
 
   set_gdbarch_register_name (gdbarch, cris_register_name);
   
-  /* Length of ordinary registers used in push_word and a few other places. 
-     REGISTER_RAW_SIZE is the real way to know how big a register is.  */
+  /* Length of ordinary registers used in push_word and a few other
+     places.  DEPRECATED_REGISTER_RAW_SIZE is the real way to know how
+     big a register is.  */
   set_gdbarch_deprecated_register_size (gdbarch, 4);
   
   /* NEW */
@@ -4239,7 +4240,7 @@
   /* The length of the registers in the actual machine representation.  */
   set_gdbarch_deprecated_register_raw_size (gdbarch, cris_register_size);
   
-  /* The largest value REGISTER_RAW_SIZE can have.  */
+  /* The largest value DEPRECATED_REGISTER_RAW_SIZE can have.  */
   set_gdbarch_deprecated_max_register_raw_size (gdbarch, 32);
   
   /* The length of the registers in the program's representation.  */
Index: dve3900-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/dve3900-rom.c,v
retrieving revision 1.12
diff -u -r1.12 dve3900-rom.c
--- dve3900-rom.c	8 May 2003 22:33:13 -0000	1.12
+++ dve3900-rom.c	28 Sep 2003 01:47:12 -0000
@@ -471,7 +471,7 @@
 
   /* supply register stores in target byte order, so swap here */
 
-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+  store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
   supply_register (regno, regbuf);
 
 }
Index: findvar.c
===================================================================
RCS file: /cvs/src/src/gdb/findvar.c,v
retrieving revision 1.65
diff -u -r1.65 findvar.c
--- findvar.c	16 Sep 2003 18:56:35 -0000	1.65
+++ findvar.c	28 Sep 2003 01:47:18 -0000
@@ -289,15 +289,15 @@
       DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
 					      raw_buffer, VALUE_CONTENTS_RAW (reg_val));
     }
-  else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
+  else if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
-	    REGISTER_RAW_SIZE (regnum));
+	    DEPRECATED_REGISTER_RAW_SIZE (regnum));
   else
     internal_error (__FILE__, __LINE__,
 		    "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 		    REGISTER_NAME (regnum),
 		    regnum,
-		    REGISTER_RAW_SIZE (regnum),
+		    DEPRECATED_REGISTER_RAW_SIZE (regnum),
 		    REGISTER_VIRTUAL_SIZE (regnum));
   VALUE_LVAL (reg_val) = lval;
   VALUE_ADDRESS (reg_val) = addr;
@@ -647,7 +647,7 @@
       /* Copy all of the data out, whereever it may be.  */
       for (local_regnum = regnum, value_bytes_copied = 0;
 	   value_bytes_copied < len;
-	   (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
+	   (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum),
 	    ++local_regnum))
 	{
 	  int realnum;
@@ -713,9 +713,9 @@
          some fiddling with the last register copied here for little
          endian machines.  */
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-	  && len < REGISTER_RAW_SIZE (regnum))
+	  && len < DEPRECATED_REGISTER_RAW_SIZE (regnum))
 	/* Big-endian, and we want less than full size.  */
-	VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
+	VALUE_OFFSET (v) = DEPRECATED_REGISTER_RAW_SIZE (regnum) - len;
       else
 	VALUE_OFFSET (v) = 0;
       memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);
Index: frame.c
===================================================================
RCS file: /cvs/src/src/gdb/frame.c,v
retrieving revision 1.142
diff -u -r1.142 frame.c
--- frame.c	25 Sep 2003 20:44:01 -0000	1.142
+++ frame.c	28 Sep 2003 01:48:13 -0000
@@ -744,7 +744,7 @@
 /* frame_register_read ()
 
    Find and return the value of REGNUM for the specified stack frame.
-   The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
+   The number of bytes copied is DEPRECATED_REGISTER_RAW_SIZE (REGNUM).
 
    Returns 0 if the register value could not be found.  */
 
@@ -1007,7 +1007,7 @@
 	  if (bufferp != NULL)
 	    /* NOTE: cagney/2003-05-09: In-lined store_address with
                it's body - store_unsigned_integer.  */
-	    store_unsigned_integer (bufferp, REGISTER_RAW_SIZE (regnum),
+	    store_unsigned_integer (bufferp, DEPRECATED_REGISTER_RAW_SIZE (regnum),
 				    deprecated_get_frame_saved_regs (frame)[regnum]);
 	}
       else
@@ -1036,13 +1036,13 @@
 		  regs[regnum]
 		    = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum));
 		  read_memory (deprecated_get_frame_saved_regs (frame)[regnum], regs[regnum],
-			       REGISTER_RAW_SIZE (regnum));
+			       DEPRECATED_REGISTER_RAW_SIZE (regnum));
 		}
-	      memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum));
+	      memcpy (bufferp, regs[regnum], DEPRECATED_REGISTER_RAW_SIZE (regnum));
 #else
 	      /* Read the value in from memory.  */
 	      read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp,
-			   REGISTER_RAW_SIZE (regnum));
+			   DEPRECATED_REGISTER_RAW_SIZE (regnum));
 #endif
 	    }
 	}
@@ -1150,7 +1150,7 @@
 		    /* NOTE: cagney/2003-05-09: In-line store_address
                        with it's body - store_unsigned_integer.  */
 		    store_unsigned_integer (raw_buffer,
-					    REGISTER_RAW_SIZE (regnum),
+					    DEPRECATED_REGISTER_RAW_SIZE (regnum),
 					    deprecated_get_frame_saved_regs (frame)[regnum]);
 		}
 	      else
@@ -1159,7 +1159,7 @@
 		    *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
 		  if (raw_buffer)
 		    read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer,
-				 REGISTER_RAW_SIZE (regnum));
+				 DEPRECATED_REGISTER_RAW_SIZE (regnum));
 		}
 	      return;
 	    }
Index: gdbarch.sh
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.sh,v
retrieving revision 1.272
diff -u -r1.272 gdbarch.sh
--- gdbarch.sh	18 Sep 2003 22:39:21 -0000	1.272
+++ gdbarch.sh	28 Sep 2003 01:50:21 -0000
@@ -486,7 +486,7 @@
 # sizes agree with the value computed from REGISTER_TYPE,
 # DEPRECATED_REGISTER_RAW_SIZE can be deleted.  See: maint print
 # registers.
-F:2:REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
+F:2:DEPRECATED_REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
 # If all registers have identical raw and virtual sizes and those
 # sizes agree with the value computed from REGISTER_TYPE,
 # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted.  See: maint print
Index: hppa-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/hppa-tdep.c,v
retrieving revision 1.99
diff -u -r1.99 hppa-tdep.c
--- hppa-tdep.c	25 Sep 2003 20:44:01 -0000	1.99
+++ hppa-tdep.c	28 Sep 2003 01:50:39 -0000
@@ -2980,7 +2980,7 @@
   frame_register_read (deprecated_selected_frame, i, raw_buffer);
 
   /* Put it in the buffer.  No conversions are ever necessary.  */
-  memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
+  memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
 
   fputs_filtered (REGISTER_NAME (i), gdb_stdout);
   print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
@@ -2998,8 +2998,8 @@
       frame_register_read (deprecated_selected_frame, i + 1, raw_buffer);
 
       /* Copy it into the appropriate part of the virtual buffer.  */
-      memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer,
-	      REGISTER_RAW_SIZE (i));
+      memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buffer,
+	      DEPRECATED_REGISTER_RAW_SIZE (i));
 
       /* Dump it as a double.  */
       fputs_filtered (REGISTER_NAME (i), gdb_stdout);
@@ -3026,7 +3026,7 @@
   frame_register_read (deprecated_selected_frame, i, raw_buffer);
 
   /* Put it in the buffer.  No conversions are ever necessary.  */
-  memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
+  memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
 
   if (precision == double_precision && (i % 2) == 0)
     {
@@ -3037,7 +3037,7 @@
       frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
 
       /* Copy it into the appropriate part of the virtual buffer.  */
-      memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i));
+      memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i));
 
       val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
 		 1, 0, Val_pretty_default);
Index: hppab-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppab-nat.c,v
retrieving revision 1.11
diff -u -r1.11 hppab-nat.c
--- hppab-nat.c	17 Sep 2003 14:24:30 -0000	1.11
+++ hppab-nat.c	28 Sep 2003 01:50:39 -0000
@@ -64,7 +64,7 @@
   offset = U_REGS_OFFSET;
 
   regaddr = register_addr (regno, offset);
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
     {
       errno = 0;
       *(int *) &buf[i] = ptrace (PT_RUREGS, PIDGET (inferior_ptid),
@@ -130,7 +130,7 @@
 	    }
 	}
       else
-	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+	for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
 	  {
 	    errno = 0;
 	    ptrace (PT_WUREGS, PIDGET (inferior_ptid),
Index: hppah-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppah-nat.c,v
retrieving revision 1.28
diff -u -r1.28 hppah-nat.c
--- hppah-nat.c	19 Sep 2003 20:09:44 -0000	1.28
+++ hppah-nat.c	28 Sep 2003 01:50:42 -0000
@@ -98,7 +98,7 @@
 	return;
 
       offset = 0;
-      len = REGISTER_RAW_SIZE (regno);
+      len = DEPRECATED_REGISTER_RAW_SIZE (regno);
 
       /* Requests for register zero actually want the save_state's
 	 ss_flags member.  As RM says: "Oh, what a hack!"  */
@@ -109,10 +109,11 @@
 	  len = sizeof (ss.ss_flags);
 
 	  /* Note that ss_flags is always an int, no matter what
-	     REGISTER_RAW_SIZE(0) says.  Assuming all HP-UX PA machines
-	     are big-endian, put it at the least significant end of the
-	     value, and zap the rest of the buffer.  */
-	  offset = REGISTER_RAW_SIZE (0) - len;
+	     DEPRECATED_REGISTER_RAW_SIZE(0) says.  Assuming all HP-UX
+	     PA machines are big-endian, put it at the least
+	     significant end of the value, and zap the rest of the
+	     buffer.  */
+	  offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len;
 	}
 
       /* Floating-point registers come from the ss_fpblock area.  */
@@ -215,7 +216,7 @@
   int i;
 
   offset = 0;
-  len = REGISTER_RAW_SIZE (regno);
+  len = DEPRECATED_REGISTER_RAW_SIZE (regno);
 
   /* Requests for register zero actually want the save_state's
      ss_flags member.  As RM says: "Oh, what a hack!"  */
@@ -226,10 +227,10 @@
       len = sizeof (ss.ss_flags);
 
       /* Note that ss_flags is always an int, no matter what
-	 REGISTER_RAW_SIZE(0) says.  Assuming all HP-UX PA machines
-	 are big-endian, put it at the least significant end of the
-	 value, and zap the rest of the buffer.  */
-      offset = REGISTER_RAW_SIZE (0) - len;
+	 DEPRECATED_REGISTER_RAW_SIZE(0) says.  Assuming all HP-UX PA
+	 machines are big-endian, put it at the least significant end
+	 of the value, and zap the rest of the buffer.  */
+      offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len;
       memset (buf, 0, sizeof (buf));
     }
 
Index: hppam3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppam3-nat.c,v
retrieving revision 1.8
diff -u -r1.8 hppam3-nat.c
--- hppam3-nat.c	17 Sep 2003 14:24:30 -0000	1.8
+++ hppam3-nat.c	28 Sep 2003 01:50:42 -0000
@@ -116,13 +116,13 @@
   if (regno > 0 && regno < NUM_REGS)
     {
       memcpy (&state[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-	      REGISTER_RAW_SIZE (regno));
+	      DEPRECATED_REGISTER_RAW_SIZE (regno));
     }
   else
     {
       for (index = 0; index < NUM_REGS; index++)
 	memcpy (&state[index], &deprecated_registers[DEPRECATED_REGISTER_BYTE (index)],
-		REGISTER_RAW_SIZE (index));
+		DEPRECATED_REGISTER_RAW_SIZE (index));
 /*      state[index] = deprecated_registers[DEPRECATED_REGISTER_BYTE (index)]; */
 
     }
Index: hpux-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/hpux-thread.c,v
retrieving revision 1.20
diff -u -r1.20 hpux-thread.c
--- hpux-thread.c	21 Sep 2003 01:26:44 -0000	1.20
+++ hpux-thread.c	28 Sep 2003 01:50:42 -0000
@@ -291,13 +291,13 @@
 
 	  if (regno == FLAGS_REGNUM)
 	    /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */
-	    memset (buf, '\000', REGISTER_RAW_SIZE (regno));
+	    memset (buf, '\000', DEPRECATED_REGISTER_RAW_SIZE (regno));
 	  else if (regno == SP_REGNUM)
 	    store_unsigned_integer (buf, sizeof sp, sp);
 	  else if (regno == PC_REGNUM)
-	    read_memory (sp - 20, buf, REGISTER_RAW_SIZE (regno));
+	    read_memory (sp - 20, buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
 	  else
-	    read_memory (sp + regmap[regno], buf, REGISTER_RAW_SIZE (regno));
+	    read_memory (sp + regmap[regno], buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
 
 	  supply_register (regno, buf);
 	}
@@ -357,19 +357,19 @@
 	    {
 	      write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
 			    &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-			    REGISTER_RAW_SIZE (regno));
+			    DEPRECATED_REGISTER_RAW_SIZE (regno));
 	      tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *)
 		(extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-					   REGISTER_RAW_SIZE (regno)) + 160);
+					   DEPRECATED_REGISTER_RAW_SIZE (regno)) + 160);
 	    }
 	  else if (regno == PC_REGNUM)
 	    write_memory (sp - 20,
 			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-			  REGISTER_RAW_SIZE (regno));
+			  DEPRECATED_REGISTER_RAW_SIZE (regno));
 	  else
 	    write_memory (sp + regmap[regno],
 			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-			  REGISTER_RAW_SIZE (regno));
+			  DEPRECATED_REGISTER_RAW_SIZE (regno));
 	}
     }
 
Index: i386gnu-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386gnu-nat.c,v
retrieving revision 1.15
diff -u -r1.15 i386gnu-nat.c
--- i386gnu-nat.c	17 Sep 2003 14:24:30 -0000	1.15
+++ i386gnu-nat.c	28 Sep 2003 01:50:42 -0000
@@ -242,7 +242,7 @@
 	    if ((thread->fetched_regs & (1 << check_regno))
 		&& memcpy (REG_ADDR (&old_state, check_regno),
 			   REG_ADDR (state, check_regno),
-			   REGISTER_RAW_SIZE (check_regno)))
+			   DEPRECATED_REGISTER_RAW_SIZE (check_regno)))
 	      /* Register CHECK_REGNO has changed!  Ack!  */
 	      {
 		warning ("Register %s changed after the thread was aborted",
@@ -257,7 +257,7 @@
 
 #define fill(state, regno)                                               \
   memcpy (REG_ADDR(state, regno), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],     \
-          REGISTER_RAW_SIZE (regno))
+          DEPRECATED_REGISTER_RAW_SIZE (regno))
 
       if (regno == -1)
 	{
Index: ia64-aix-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-aix-nat.c,v
retrieving revision 1.7
diff -u -r1.7 ia64-aix-nat.c
--- ia64-aix-nat.c	17 Sep 2003 14:24:30 -0000	1.7
+++ ia64-aix-nat.c	28 Sep 2003 01:50:58 -0000
@@ -87,7 +87,7 @@
 #define COPY_REG(_fld_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
     memcpy (&(gregsetp->_fld_), &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \
-	    REGISTER_RAW_SIZE (_regi_))
+	    DEPRECATED_REGISTER_RAW_SIZE (_regi_))
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
@@ -110,10 +110,10 @@
     {
       memcpy (&(gregsetp->__bspstore),
 	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
-	      REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
+	      DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
 	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
-	      REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
+	      DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
     }
 
 #if 0
@@ -156,7 +156,7 @@
 	{
 	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]);
-	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
+	  memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
 	}
     }
 }
Index: ia64-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-linux-nat.c,v
retrieving revision 1.19
diff -u -r1.19 ia64-linux-nat.c
--- ia64-linux-nat.c	17 Sep 2003 14:24:30 -0000	1.19
+++ ia64-linux-nat.c	28 Sep 2003 01:50:58 -0000
@@ -403,7 +403,7 @@
 #define COPY_REG(_idx_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
     memcpy (regp + _idx_, &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \
-	    REGISTER_RAW_SIZE (_regi_))
+	    DEPRECATED_REGISTER_RAW_SIZE (_regi_))
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
@@ -469,7 +469,7 @@
 	{
 	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
-	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
+	  memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
 	}
     }
 }
Index: ia64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-tdep.c,v
retrieving revision 1.97
diff -u -r1.97 ia64-tdep.c
--- ia64-tdep.c	9 Sep 2003 23:29:52 -0000	1.97
+++ ia64-tdep.c	28 Sep 2003 01:50:59 -0000
@@ -343,7 +343,7 @@
 
   regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum);
   if (regaddr)
-    return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum));
+    return read_memory_integer (regaddr, DEPRECATED_REGISTER_RAW_SIZE (regnum));
   else
     internal_error (__FILE__, __LINE__,
 		    "read_sigcontext_register: Register %d not in struct sigcontext", regnum);
@@ -716,10 +716,10 @@
 	{
 	  ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
 	  reg = read_memory_integer ((CORE_ADDR)reg_addr, 8);
-	  store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), reg);
+	  store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), reg);
 	}
       else
-	store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), 0);
+	store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), 0);
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
     {
@@ -727,7 +727,7 @@
       ULONGEST unat;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
       unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0;
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), unatN_val);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), unatN_val);
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
     {
@@ -762,7 +762,7 @@
 	  natN_val = (nat_collection >> nat_bit) & 1;
 	}
       
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), natN_val);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), natN_val);
     }
   else if (regnum == VBOF_REGNUM)
     {
@@ -777,7 +777,7 @@
       /* The bsp points at the end of the register frame so we
 	 subtract the size of frame from it to get beginning of frame.  */
       vbsp = rse_address_add (bsp, -(cfm & 0x7f));
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), vbsp);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), vbsp);
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
@@ -799,10 +799,10 @@
 	         + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
 	}
       prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0;
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), prN_val);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), prN_val);
     }
   else
-    memset (buf, 0, REGISTER_RAW_SIZE (regnum));
+    memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum));
 }
 
 static void
@@ -829,7 +829,7 @@
     {
       ULONGEST unatN_val, unat, unatN_mask;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
-      unatN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); 
+      unatN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); 
       unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM));
       if (unatN_val == 0)
 	unat &= ~unatN_mask;
@@ -853,7 +853,7 @@
       if ((cfm & 0x7f) > regnum - V32_REGNUM) 
 	gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
       
-      natN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); 
+      natN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); 
 
       if (gr_addr != 0 && (natN_val == 0 || natN_val == 1))
 	{
@@ -882,7 +882,7 @@
 		nat_collection |= natN_mask;
 	      else
 		nat_collection &= ~natN_mask;
-	      store_unsigned_integer (nat_buf, REGISTER_RAW_SIZE (regnum), nat_collection);
+	      store_unsigned_integer (nat_buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), nat_collection);
 	      write_memory (nat_addr, nat_buf, 8);
 	    }
 	}
@@ -907,7 +907,7 @@
 	  regnum = VP16_REGNUM 
 	         + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
 	}
-      prN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); 
+      prN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); 
       prN_mask = (1LL << (regnum - VP0_REGNUM));
       if (prN_val == 0)
 	pr &= ~prN_mask;
@@ -1593,12 +1593,12 @@
   if (!valuep)
     valuep = dummy_valp;
   
-  memset (valuep, 0, REGISTER_RAW_SIZE (regnum));
+  memset (valuep, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum));
  
   if (regnum == SP_REGNUM)
     {
       /* Handle SP values for all frames but the topmost. */
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum),
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum),
 			      cache->base);
     }
   else if (regnum == IA64_BSP_REGNUM)
@@ -1623,7 +1623,7 @@
       bsp = rse_address_add (cache->bsp, -(cache->sof));
       prev_bsp = rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f));
 
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), 
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), 
 			      prev_bsp);
     }
   else if (regnum == IA64_CFM_REGNUM)
@@ -1639,7 +1639,7 @@
 	{
 	  addr = cache->saved_regs[IA64_CFM_REGNUM];
 	  if (addr != 0)
-	    read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum));
+	    read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	}
     }
   else if (regnum == IA64_VFP_REGNUM)
@@ -1649,7 +1649,7 @@
 	 above.  If the function lacks one of these frame pointers, we can
 	 still provide a value since we know the size of the frame.  */
       CORE_ADDR vfp = cache->base;
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
@@ -1673,7 +1673,7 @@
 	}
       prN_val = extract_bit_field ((unsigned char *) pr_valuep,
                                    regnum - VP0_REGNUM, 1);
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), prN_val);
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), prN_val);
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
     {
@@ -1687,7 +1687,7 @@
 				&unat_optim, &unat_lval, &unat_addr, &unat_realnum, unat_valuep);
       unatN_val = extract_bit_field ((unsigned char *) unat_valuep,
                                    regnum - IA64_NAT0_REGNUM, 1);
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), 
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), 
                               unatN_val);
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
@@ -1722,7 +1722,7 @@
 	  natval = (nat_collection >> nat_bit) & 1;
 	}
 
-      store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), natval);
+      store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), natval);
     }
   else if (regnum == IA64_IP_REGNUM)
     {
@@ -1738,7 +1738,7 @@
 	  CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
 	  if (addr != 0)
 	    {
-	      read_memory (addr, buf, REGISTER_RAW_SIZE (IA64_IP_REGNUM));
+	      read_memory (addr, buf, DEPRECATED_REGISTER_RAW_SIZE (IA64_IP_REGNUM));
 	      pc = extract_unsigned_integer (buf, 8);
 	    }
 	}
@@ -1765,7 +1765,7 @@
 	  CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
 	  if (addr != 0)
 	    {
-	      read_memory (addr, buf, REGISTER_RAW_SIZE (IA64_IP_REGNUM));
+	      read_memory (addr, buf, DEPRECATED_REGISTER_RAW_SIZE (IA64_IP_REGNUM));
 	      pc = extract_unsigned_integer (buf, 8);
 	    }
 	}
@@ -1785,7 +1785,7 @@
 	{
 	  *lvalp = lval_memory;
 	  *addrp = addr;
-	  read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum));
+	  read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	}
       else if (cache->frameless)
         {
@@ -1809,7 +1809,7 @@
 	  addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
 	  *lvalp = lval_memory;
 	  *addrp = addr;
-	  read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum));
+	  read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
         }
     }
   else
@@ -1833,7 +1833,7 @@
 	{
 	  *lvalp = lval_memory;
 	  *addrp = addr;
-	  read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum));
+	  read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	}
       /* Otherwise, punt and get the current value of the register.  */
       else 
Index: infcmd.c
===================================================================
RCS file: /cvs/src/src/gdb/infcmd.c,v
retrieving revision 1.91
diff -u -r1.91 infcmd.c
--- infcmd.c	21 Sep 2003 01:26:44 -0000	1.91
+++ infcmd.c	28 Sep 2003 01:50:59 -0000
@@ -1558,13 +1558,13 @@
 		     file, 0, 1, 0, Val_pretty_default);
 
 	  fprintf_filtered (file, "\t(raw 0x");
-	  for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+	  for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++)
 	    {
 	      int idx;
 	      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 		idx = j;
 	      else
-		idx = REGISTER_RAW_SIZE (i) - 1 - j;
+		idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j;
 	      fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
 	    }
 	  fprintf_filtered (file, ")");
Index: infptrace.c
===================================================================
RCS file: /cvs/src/src/gdb/infptrace.c,v
retrieving revision 1.28
diff -u -r1.28 infptrace.c
--- infptrace.c	14 Sep 2003 16:32:13 -0000	1.28
+++ infptrace.c	28 Sep 2003 01:51:00 -0000
@@ -366,7 +366,7 @@
 
   if (CANNOT_FETCH_REGISTER (regno))
     {
-      memset (buf, '\0', REGISTER_RAW_SIZE (regno));	/* Supply zeroes */
+      memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno));	/* Supply zeroes */
       supply_register (regno, buf);
       return;
     }
@@ -378,7 +378,7 @@
   offset = U_REGS_OFFSET;
 
   regaddr = register_addr (regno, offset);
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
       *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
@@ -445,7 +445,7 @@
   regcache_collect (regno, buf);
 
   /* Store the local buffer into the inferior a chunk at the time. */
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
       ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
Index: infrun.c
===================================================================
RCS file: /cvs/src/src/gdb/infrun.c,v
retrieving revision 1.114
diff -u -r1.114 infrun.c
--- infrun.c	21 Sep 2003 01:26:44 -0000	1.114
+++ infrun.c	28 Sep 2003 01:51:13 -0000
@@ -3622,7 +3622,7 @@
 write_inferior_status_register (struct inferior_status *inf_status, int regno,
 				LONGEST val)
 {
-  int size = REGISTER_RAW_SIZE (regno);
+  int size = DEPRECATED_REGISTER_RAW_SIZE (regno);
   void *buf = alloca (size);
   store_signed_integer (buf, size, val);
   regcache_raw_write (inf_status->registers, regno, buf);
Index: irix5-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/irix5-nat.c,v
retrieving revision 1.25
diff -u -r1.25 irix5-nat.c
--- irix5-nat.c	17 Sep 2003 14:24:30 -0000	1.25
+++ irix5-nat.c	28 Sep 2003 01:51:13 -0000
@@ -84,27 +84,27 @@
     if ((regno == -1) || (regno == regi))
       *(regp + regi) =
 	extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)],
-				REGISTER_RAW_SIZE (regi));
+				DEPRECATED_REGISTER_RAW_SIZE (regi));
 
   if ((regno == -1) || (regno == PC_REGNUM))
     *(regp + CTX_EPC) =
       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)],
-			      REGISTER_RAW_SIZE (PC_REGNUM));
+			      DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
 
   if ((regno == -1) || (regno == CAUSE_REGNUM))
     *(regp + CTX_CAUSE) =
       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (CAUSE_REGNUM)],
-			      REGISTER_RAW_SIZE (CAUSE_REGNUM));
+			      DEPRECATED_REGISTER_RAW_SIZE (CAUSE_REGNUM));
 
   if ((regno == -1) || (regno == HI_REGNUM))
     *(regp + CTX_MDHI) =
       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)],
-			      REGISTER_RAW_SIZE (HI_REGNUM));
+			      DEPRECATED_REGISTER_RAW_SIZE (HI_REGNUM));
 
   if ((regno == -1) || (regno == LO_REGNUM))
     *(regp + CTX_MDLO) =
       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)],
-			      REGISTER_RAW_SIZE (LO_REGNUM));
+			      DEPRECATED_REGISTER_RAW_SIZE (LO_REGNUM));
 }
 
 /*
@@ -147,7 +147,7 @@
 	{
 	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
-	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
+	  memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
 	}
     }
 
@@ -219,7 +219,7 @@
 	      *dstp++ = *srcp++;
 	      *dstp++ = *srcp++;
 	      *dstp++ = *srcp++;
-	      if (REGISTER_RAW_SIZE (regno) == 4)
+	      if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 4)
 		{
 		  /* copying 4 bytes from eight bytes?
 		     I don't see how this can be right...  */
Index: lynx-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/lynx-nat.c,v
retrieving revision 1.16
diff -u -r1.16 lynx-nat.c
--- lynx-nat.c	17 Sep 2003 15:42:18 -0000	1.16
+++ lynx-nat.c	28 Sep 2003 01:51:16 -0000
@@ -293,12 +293,12 @@
       if (errno)
 	perror_with_name ("ptrace(PTRACE_GETREGS)");
 
-      memset (buf, 0, REGISTER_RAW_SIZE (G0_REGNUM));
+      memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (G0_REGNUM));
       supply_register (G0_REGNUM, buf);
       supply_register (TBR_REGNUM, (char *) &ec.tbr);
 
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &ec.g1,
-	      4 * REGISTER_RAW_SIZE (G1_REGNUM));
+	      4 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
       for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
 	deprecated_register_valid[i] = 1;
 
@@ -309,7 +309,7 @@
       supply_register (WIM_REGNUM, (char *) &ec.wim);
 
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)], ec.o,
-	      8 * REGISTER_RAW_SIZE (O0_REGNUM));
+	      8 * DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM));
       for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
 	deprecated_register_valid[i] = 1;
     }
@@ -323,13 +323,13 @@
 
       target_read_memory (sp + FRAME_SAVED_I0,
 			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)],
-			  8 * REGISTER_RAW_SIZE (I0_REGNUM));
+			  8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM));
       for (i = I0_REGNUM; i <= I7_REGNUM; i++)
 	deprecated_register_valid[i] = 1;
 
       target_read_memory (sp + FRAME_SAVED_L0,
 			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-			  8 * REGISTER_RAW_SIZE (L0_REGNUM));
+			  8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
       for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
 	deprecated_register_valid[i] = 1;
     }
@@ -347,7 +347,7 @@
 	perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
-	      32 * REGISTER_RAW_SIZE (FP0_REGNUM));
+	      32 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM));
       for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
 	deprecated_register_valid[i] = 1;
 
@@ -385,7 +385,7 @@
 
       ec.tbr = read_register (TBR_REGNUM);
       memcpy (&ec.g1, &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
-	      4 * REGISTER_RAW_SIZE (G1_REGNUM));
+	      4 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
 
       ec.psr = read_register (PS_REGNUM);
       ec.y = read_register (Y_REGNUM);
@@ -394,7 +394,7 @@
       ec.wim = read_register (WIM_REGNUM);
 
       memcpy (ec.o, &deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)],
-	      8 * REGISTER_RAW_SIZE (O0_REGNUM));
+	      8 * DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM));
 
       errno = 0;
       retval = ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
@@ -416,11 +416,11 @@
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  target_write_memory (sp + FRAME_SAVED_I0,
 			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)],
-			      8 * REGISTER_RAW_SIZE (I0_REGNUM));
+			      8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM));
 
 	  target_write_memory (sp + FRAME_SAVED_L0,
 			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-			      8 * REGISTER_RAW_SIZE (L0_REGNUM));
+			      8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
 	}
       else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
 	{
@@ -434,7 +434,7 @@
 	      + FRAME_SAVED_I0;
 	  target_write_memory (sp + regoffset, 
 			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-			      REGISTER_RAW_SIZE (regno));
+			      DEPRECATED_REGISTER_RAW_SIZE (regno));
 	}
     }
 
@@ -451,7 +451,7 @@
 	perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 
       memcpy (fc.f.fregs, &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
-	      32 * REGISTER_RAW_SIZE (FP0_REGNUM));
+	      32 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM));
 
       fc.fsr = read_register (FPS_REGNUM);
 
@@ -521,7 +521,7 @@
 	ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD;
 #endif
 	
-	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+	for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
 	  {
 	    unsigned int reg;
 	    
@@ -570,7 +570,7 @@
       ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER;
 #endif
 
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+      for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
 	{
 	  unsigned int reg;
 
Index: mips-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-linux-tdep.c,v
retrieving revision 1.14
diff -u -r1.14 mips-linux-tdep.c
--- mips-linux-tdep.c	17 Sep 2003 14:24:30 -0000	1.14
+++ mips-linux-tdep.c	28 Sep 2003 01:51:16 -0000
@@ -92,7 +92,7 @@
 supply_32bit_reg (int regnum, const void *addr)
 {
   char buf[MAX_REGISTER_SIZE];
-  store_signed_integer (buf, REGISTER_RAW_SIZE (regnum),
+  store_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum),
                         extract_signed_integer (addr, 4));
   supply_register (regnum, buf);
 }
@@ -218,13 +218,13 @@
     {
       from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + regno - FP0_REGNUM);
-      memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM));
     }
   else if (regno == FCRCS_REGNUM)
     {
       from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + 32);
-      memcpy (to, from, REGISTER_RAW_SIZE (regno));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
     }
   else if (regno == -1)
     {
@@ -493,13 +493,13 @@
     {
       from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + regno - FP0_REGNUM);
-      memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM));
     }
   else if (regno == FCRCS_REGNUM)
     {
       from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + 32);
-      memcpy (to, from, REGISTER_RAW_SIZE (regno));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
     }
   else if (regno == -1)
     {
Index: mips-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-nat.c,v
retrieving revision 1.14
diff -u -r1.14 mips-nat.c
--- mips-nat.c	14 Sep 2003 16:32:13 -0000	1.14
+++ mips-nat.c	28 Sep 2003 01:51:16 -0000
@@ -83,7 +83,7 @@
   for (regno = 1; regno < NUM_REGS; regno++)
     {
       regaddr = register_ptrace_addr (regno);
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+      for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
 	{
 	  *(int *) &buf[i] = ptrace (PT_READ_U, PIDGET (inferior_ptid),
 				     (PTRACE_ARG3_TYPE) regaddr, 0);
Index: mips-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-tdep.c,v
retrieving revision 1.237
diff -u -r1.237 mips-tdep.c
--- mips-tdep.c	25 Sep 2003 20:44:01 -0000	1.237
+++ mips-tdep.c	28 Sep 2003 01:51:39 -0000
@@ -181,9 +181,9 @@
 static LONGEST
 read_signed_register (int regnum)
 {
-  void *buf = alloca (REGISTER_RAW_SIZE (regnum));
+  void *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum));
   deprecated_read_register_gen (regnum, buf);
-  return (extract_signed_integer (buf, REGISTER_RAW_SIZE (regnum)));
+  return (extract_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)));
 }
 
 static LONGEST
@@ -279,7 +279,7 @@
   switch (endian)
     {
     case BFD_ENDIAN_BIG:
-      reg_offset = REGISTER_RAW_SIZE (reg_num) - length;
+      reg_offset = DEPRECATED_REGISTER_RAW_SIZE (reg_num) - length;
       break;
     case BFD_ENDIAN_LITTLE:
       reg_offset = 0;
@@ -325,7 +325,7 @@
 {
   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
      meaningful.  */
-  if (REGISTER_RAW_SIZE (FP0_REGNUM) == 4)
+  if (DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 4)
     return 0;
 
 #if 0
@@ -654,7 +654,7 @@
 	 NOTE: cagney/2003-06-15: This is so bogus.  The register's
 	 raw size is changing according to the ABI
 	 (FP_REGISTER_DOUBLE).  Also, GDB's protocol is defined by a
-	 combination of REGISTER_RAW_SIZE and DEPRECATED_REGISTER_BYTE.  */
+	 combination of DEPRECATED_REGISTER_RAW_SIZE and DEPRECATED_REGISTER_BYTE.  */
       if (mips64_transfers_32bit_regs_p)
 	return REGISTER_VIRTUAL_SIZE (regnum);
       else if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32
@@ -717,7 +717,7 @@
   if (mips64_transfers_32bit_regs_p)
     return 0;
   else
-    return (REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
+    return (DEPRECATED_REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
 }
 
 static void
@@ -726,7 +726,7 @@
 {
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
     memcpy (virt_buf,
-	    raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
+	    raw_buf + (DEPRECATED_REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 	    TYPE_LENGTH (virtual_type));
   else
     memcpy (virt_buf,
@@ -738,9 +738,9 @@
 mips_register_convert_to_raw (struct type *virtual_type, int n,
 			      const char *virt_buf, char *raw_buf)
 {
-  memset (raw_buf, 0, REGISTER_RAW_SIZE (n));
+  memset (raw_buf, 0, DEPRECATED_REGISTER_RAW_SIZE (n));
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    memcpy (raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
+    memcpy (raw_buf + (DEPRECATED_REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 	    virt_buf,
 	    TYPE_LENGTH (virtual_type));
   else
@@ -753,7 +753,7 @@
 mips_convert_register_p (int regnum, struct type *type)
 {
   return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-	  && REGISTER_RAW_SIZE (regnum) == 4
+	  && DEPRECATED_REGISTER_RAW_SIZE (regnum) == 4
 	  && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
 	  && TYPE_CODE(type) == TYPE_CODE_FLT
 	  && TYPE_LENGTH(type) == 8);
@@ -4065,7 +4065,7 @@
 mips_read_fp_register_single (struct frame_info *frame, int regno,
 			      char *rare_buffer)
 {
-  int raw_size = REGISTER_RAW_SIZE (regno);
+  int raw_size = DEPRECATED_REGISTER_RAW_SIZE (regno);
   char *raw_buffer = alloca (raw_size);
 
   if (!frame_register_read (frame, regno, raw_buffer))
@@ -4097,7 +4097,7 @@
 mips_read_fp_register_double (struct frame_info *frame, int regno,
 			      char *rare_buffer)
 {
-  int raw_size = REGISTER_RAW_SIZE (regno);
+  int raw_size = DEPRECATED_REGISTER_RAW_SIZE (regno);
 
   if (raw_size == 8 && !mips2_fp_compat ())
     {
@@ -4136,13 +4136,13 @@
   double doub, flt1, flt2;	/* doubles extracted from raw hex data */
   int inv1, inv2, namelen;
 
-  raw_buffer = (char *) alloca (2 * REGISTER_RAW_SIZE (FP0_REGNUM));
+  raw_buffer = (char *) alloca (2 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM));
 
   fprintf_filtered (file, "%s:", REGISTER_NAME (regnum));
   fprintf_filtered (file, "%*s", 4 - (int) strlen (REGISTER_NAME (regnum)),
 		    "");
 
-  if (REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ())
+  if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ())
     {
       /* 4-byte registers: Print hex and floating.  Also print even
          numbered registers as doubles.  */
@@ -4229,7 +4229,7 @@
     fprintf_filtered (file, ": ");
 
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    offset = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+    offset = DEPRECATED_REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
   else
     offset = 0;
 
@@ -4301,8 +4301,8 @@
 	printf_filtered ("  ");
       /* Now print the register value in hex, endian order. */
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
-	     byte < REGISTER_RAW_SIZE (regnum);
+	for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+	     byte < DEPRECATED_REGISTER_RAW_SIZE (regnum);
 	     byte++)
 	  fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]);
       else
@@ -4641,7 +4641,7 @@
 	  lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
 	  hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4;
 	  lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-			     && REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
+			     && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
 			    ? 4 : 0);
 	  hi->reg_offset = lo->reg_offset;
 	  lo->reg = FP0_REGNUM + 0;
@@ -4654,7 +4654,7 @@
 	  /* The floating point value fits in a single floating-point
 	     register. */
 	  lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-			     && REGISTER_RAW_SIZE (FP0_REGNUM) == 8
+			     && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8
 			     && len == 4)
 			    ? 4 : 0);
 	  lo->reg = FP0_REGNUM;
@@ -4710,7 +4710,7 @@
 	    }
 	}
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-	  && REGISTER_RAW_SIZE (regnum) == 8
+	  && DEPRECATED_REGISTER_RAW_SIZE (regnum) == 8
 	  && MIPS_SAVED_REGSIZE == 4)
 	{
 	  /* Account for the fact that only the least-signficant part
@@ -4778,14 +4778,14 @@
   memset (raw_buffer, 0, sizeof (raw_buffer));
   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
   deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer,
-				   REGISTER_RAW_SIZE (lo.reg));
+				   DEPRECATED_REGISTER_RAW_SIZE (lo.reg));
 
   if (hi.len > 0)
     {
       memset (raw_buffer, 0, sizeof (raw_buffer));
       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
       deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer,
-				       REGISTER_RAW_SIZE (hi.reg));
+				       DEPRECATED_REGISTER_RAW_SIZE (hi.reg));
     }
 }
 
@@ -4800,14 +4800,14 @@
   memset (raw_buffer, 0, sizeof (raw_buffer));
   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
   deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer,
-				   REGISTER_RAW_SIZE (lo.reg));
+				   DEPRECATED_REGISTER_RAW_SIZE (lo.reg));
 
   if (hi.len > 0)
     {
       memset (raw_buffer, 0, sizeof (raw_buffer));
       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
       deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer,
-				       REGISTER_RAW_SIZE (hi.reg));
+				       DEPRECATED_REGISTER_RAW_SIZE (hi.reg));
     }
 }
 
@@ -4902,9 +4902,9 @@
       int regnum;
       for (offset = 0, regnum = V0_REGNUM;
 	   offset < TYPE_LENGTH (type);
-	   offset += REGISTER_RAW_SIZE (regnum), regnum++)
+	   offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++)
 	{
-	  int xfer = REGISTER_RAW_SIZE (regnum);
+	  int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum);
 	  if (offset + xfer > TYPE_LENGTH (type))
 	    xfer = TYPE_LENGTH (type) - offset;
 	  if (mips_debug)
@@ -5013,9 +5013,9 @@
       int regnum;
       for (offset = 0, regnum = V0_REGNUM;
 	   offset < TYPE_LENGTH (type);
-	   offset += REGISTER_RAW_SIZE (regnum), regnum++)
+	   offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++)
 	{
-	  int xfer = REGISTER_RAW_SIZE (regnum);
+	  int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum);
 	  if (offset + xfer > TYPE_LENGTH (type))
 	    xfer = TYPE_LENGTH (type) - offset;
 	  if (mips_debug)
@@ -5033,9 +5033,9 @@
       int regnum;
       for (offset = 0, regnum = V0_REGNUM;
 	   offset < TYPE_LENGTH (type);
-	   offset += REGISTER_RAW_SIZE (regnum), regnum++)
+	   offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++)
 	{
-	  int xfer = REGISTER_RAW_SIZE (regnum);
+	  int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum);
 	  int pos = 0;
 	  if (offset + xfer > TYPE_LENGTH (type))
 	    xfer = TYPE_LENGTH (type) - offset;
Index: mipsv4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsv4-nat.c,v
retrieving revision 1.13
diff -u -r1.13 mipsv4-nat.c
--- mipsv4-nat.c	17 Sep 2003 14:24:30 -0000	1.13
+++ mipsv4-nat.c	28 Sep 2003 01:51:39 -0000
@@ -127,7 +127,7 @@
 	{
 	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
-	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
+	  memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
 	}
     }
 
Index: mn10300-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mn10300-tdep.c,v
retrieving revision 1.91
diff -u -r1.91 mn10300-tdep.c
--- mn10300-tdep.c	25 Sep 2003 20:44:01 -0000	1.91
+++ mn10300-tdep.c	28 Sep 2003 01:53:52 -0000
@@ -134,7 +134,7 @@
 mn10300_extract_struct_value_address (char *regbuf)
 {
   return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (4),
-				   REGISTER_RAW_SIZE (4));
+				   DEPRECATED_REGISTER_RAW_SIZE (4));
 }
 
 static void
@@ -748,8 +748,13 @@
       {
         ULONGEST value;
 
+<<<<<<< mn10300-tdep.c
+        value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
+                                              DEPRECATED_REGISTER_RAW_SIZE (regnum));
+=======
         value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                               REGISTER_RAW_SIZE (regnum));
+>>>>>>> 1.91
         write_register (regnum, value);
       }
 
@@ -1039,8 +1044,8 @@
       int byte;
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 	{
-	  for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
-	       byte < REGISTER_RAW_SIZE (regnum);
+	  for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+	       byte < DEPRECATED_REGISTER_RAW_SIZE (regnum);
 	       byte++)
 	    printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
 	}
Index: monitor.c
===================================================================
RCS file: /cvs/src/src/gdb/monitor.c,v
retrieving revision 1.43
diff -u -r1.43 monitor.c
--- monitor.c	22 Sep 2003 14:50:37 -0000	1.43
+++ monitor.c	28 Sep 2003 01:55:46 -0000
@@ -929,7 +929,7 @@
 
   /* supply register stores in target byte order, so swap here */
 
-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+  store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
 
   supply_register (regno, regbuf);
 
@@ -1235,7 +1235,7 @@
      spaces, but stop reading if something else is seen.  Some monitors
      like to drop leading zeros.  */
 
-  for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno) * 2; i++)
     {
       int c;
       c = readchar (timeout);
@@ -1352,7 +1352,7 @@
 
   val = read_register (regno);
   monitor_debug ("MON storeg %d %s\n", regno,
-		 phex (val, REGISTER_RAW_SIZE (regno)));
+		 phex (val, DEPRECATED_REGISTER_RAW_SIZE (regno)));
 
   /* send the register deposit command */
 
Index: ns32k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ns32k-tdep.c,v
retrieving revision 1.61
diff -u -r1.61 ns32k-tdep.c
--- ns32k-tdep.c	27 Sep 2003 15:51:02 -0000	1.61
+++ ns32k-tdep.c	28 Sep 2003 01:55:47 -0000
@@ -498,7 +498,7 @@
 static CORE_ADDR
 ns32k_extract_struct_value_address (char *regbuf)
 {
-  return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
+  return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), DEPRECATED_REGISTER_RAW_SIZE (0)));
 }
 
 void
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.25
diff -u -r1.25 ppc-linux-nat.c
--- ppc-linux-nat.c	14 Sep 2003 16:32:13 -0000	1.25
+++ ppc-linux-nat.c	28 Sep 2003 01:55:47 -0000
@@ -178,7 +178,7 @@
   int offset = 0;
   gdb_vrregset_t regs;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-  int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+  int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 
   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
   if (ret < 0)
@@ -196,7 +196,7 @@
      vector.  VRSAVE is at the end of the array in a 4 bytes slot, so
      there is no need to define an offset for it.  */
   if (regno == (tdep->ppc_vrsave_regnum - 1))
-    offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
+    offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
   
   supply_register (regno,
                    regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
@@ -230,12 +230,12 @@
 
   if (regaddr == -1)
     {
-      memset (buf, '\0', REGISTER_RAW_SIZE (regno));   /* Supply zeroes */
+      memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno));   /* Supply zeroes */
       supply_register (regno, buf);
       return;
     }
 
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
       *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
@@ -257,8 +257,8 @@
   int i;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
-  int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
-  int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
+  int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+  int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 
   for (i = 0; i < num_of_vrregs; i++)
     {
@@ -335,7 +335,7 @@
   int offset = 0;
   gdb_vrregset_t regs;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-  int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+  int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 
   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
   if (ret < 0)
@@ -351,7 +351,7 @@
   /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
      long on the hardware.  */
   if (regno == (tdep->ppc_vrsave_regnum - 1))
-    offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
+    offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 
   regcache_collect (regno,
                     regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
@@ -381,7 +381,7 @@
     return;
 
   regcache_collect (regno, buf);
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
       ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
@@ -410,8 +410,8 @@
   int i;
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
-  int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
-  int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
+  int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+  int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 
   for (i = 0; i < num_of_vrregs; i++)
     {
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.101
diff -u -r1.101 regcache.c
--- regcache.c	27 Sep 2003 19:32:53 -0000	1.101
+++ regcache.c	28 Sep 2003 01:55:54 -0000
@@ -112,8 +112,8 @@
          to overlap.  Ulgh!  New targets use gdbarch's register
          read/write and entirely avoid this uglyness.  */
       descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i);
-      descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
-      gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i));
+      descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i);
+      gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i));
       gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
     }
 
@@ -187,7 +187,7 @@
   /* If an old style architecture, fill in the remainder of the
      register cache descriptor using the register macros.  */
   /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or
-     REGISTER_RAW_SIZE are still present, things are most likely
+     DEPRECATED_REGISTER_RAW_SIZE are still present, things are most likely
      totally screwed.  Ex: an architecture with raw register sizes
      smaller than what DEPRECATED_REGISTER_BYTE indicates; non
      monotonic DEPRECATED_REGISTER_BYTE values.  For GDB 6 check for
@@ -242,7 +242,7 @@
       if (DEPRECATED_REGISTER_BYTE_P ())
 	gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i));
 #if 0
-      gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
+      gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_RAW_SIZE (i));
       gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
 #endif
     }
@@ -278,9 +278,9 @@
   int size;
   gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
   size = descr->sizeof_register[regnum];
-  /* NB: The deprecated REGISTER_RAW_SIZE, if not provided, defaults
+  /* NB: The deprecated DEPRECATED_REGISTER_RAW_SIZE, if not provided, defaults
      to the size of the register's type.  */
-  gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */
+  gdb_assert (size == DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* OK */
   /* NB: Don't check the register's virtual size.  It, in say the case
      of the MIPS, may not match the raw size!  */
   return size;
@@ -661,7 +661,7 @@
       int byte;
 
       reg_start = DEPRECATED_REGISTER_BYTE (regnum);
-      reg_len = REGISTER_RAW_SIZE (regnum);
+      reg_len = DEPRECATED_REGISTER_RAW_SIZE (regnum);
       reg_end = reg_start + reg_len;
 
       if (reg_end <= in_start || in_end <= reg_start)
@@ -726,7 +726,7 @@
     target_fetch_registers (regnum);
 
   memcpy (myaddr, register_buffer (current_regcache, regnum),
-	  REGISTER_RAW_SIZE (regnum));
+	  DEPRECATED_REGISTER_RAW_SIZE (regnum));
 }
 
 void
@@ -913,7 +913,7 @@
       registers_ptid = inferior_ptid;
     }
 
-  size = REGISTER_RAW_SIZE (regnum);
+  size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
 
   if (real_register (regnum))
     {
@@ -1023,7 +1023,7 @@
       int regstart, regend;
 
       regstart = DEPRECATED_REGISTER_BYTE (regnum);
-      regend = regstart + REGISTER_RAW_SIZE (regnum);
+      regend = regstart + DEPRECATED_REGISTER_RAW_SIZE (regnum);
 
       /* Is this register completely outside the range the user is writing?  */
       if (myregend <= regstart || regend <= myregstart)
@@ -1152,9 +1152,9 @@
 ULONGEST
 read_register (int regnum)
 {
-  char *buf = alloca (REGISTER_RAW_SIZE (regnum));
+  char *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum));
   deprecated_read_register_gen (regnum, buf);
-  return (extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)));
+  return (extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)));
 }
 
 ULONGEST
@@ -1185,7 +1185,7 @@
 {
   void *buf;
   int size;
-  size = REGISTER_RAW_SIZE (regnum);
+  size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
   buf = alloca (size);
   store_signed_integer (buf, size, (LONGEST) val);
   deprecated_write_register_gen (regnum, buf);
@@ -1551,7 +1551,7 @@
 	  fprintf_unfiltered (file, " %5ld",
 			      regcache->descr->sizeof_register[regnum]);
 	  if ((regcache->descr->sizeof_register[regnum]
-	       != REGISTER_RAW_SIZE (regnum))
+	       != DEPRECATED_REGISTER_RAW_SIZE (regnum))
 	      || (regcache->descr->sizeof_register[regnum]
 		  != REGISTER_VIRTUAL_SIZE (regnum))
 	      || (regcache->descr->sizeof_register[regnum]
@@ -1609,7 +1609,7 @@
 	      regcache_raw_read (regcache, regnum, buf);
 	      fprintf_unfiltered (file, "0x");
 	      dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
-				 REGISTER_RAW_SIZE (regnum));
+				 DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	    }
 	}
 
Index: remote-e7000.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-e7000.c,v
retrieving revision 1.36
diff -u -r1.36 remote-e7000.c
--- remote-e7000.c	11 Jun 2003 13:16:28 -0000	1.36
+++ remote-e7000.c	28 Sep 2003 01:56:07 -0000
@@ -882,7 +882,7 @@
 		internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	    }
 	  store_signed_integer (buf,
-				REGISTER_RAW_SIZE (regno),
+				DEPRECATED_REGISTER_RAW_SIZE (regno),
 				(LONGEST) get_hex (&thischar));
 	  supply_register (regno, buf);
 	  break;
@@ -1964,7 +1964,7 @@
   char buf2[200];
 
   store_signed_integer (buf,
-			REGISTER_RAW_SIZE (PC_REGNUM),
+			DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM),
 			read_register (PC_REGNUM) - 2);
   supply_register (PC_REGNUM, buf);
   sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0));
Index: remote-mips.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-mips.c,v
retrieving revision 1.39
diff -u -r1.39 remote-mips.c
--- remote-mips.c	14 Sep 2003 16:32:13 -0000	1.39
+++ remote-mips.c	28 Sep 2003 01:56:53 -0000
@@ -1793,16 +1793,16 @@
     {
       char buf[MAX_REGISTER_SIZE];
 
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rpc);
       supply_register (PC_REGNUM, buf);
 
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rfp);
       supply_register (30, buf);	/* This register they are avoiding and so it is unnamed */
 
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp);
       supply_register (SP_REGNUM, buf);
 
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
+      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
       supply_register (DEPRECATED_FP_REGNUM, buf);
 
       if (nfields == 9)
@@ -1976,7 +1976,7 @@
 
     /* We got the number the register holds, but gdb expects to see a
        value in the target byte ordering.  */
-    store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
+    store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
     supply_register (regno, buf);
   }
 }
Index: remote-sim.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sim.c,v
retrieving revision 1.31
diff -u -r1.31 remote-sim.c
--- remote-sim.c	18 Jul 2003 00:21:00 -0000	1.31
+++ remote-sim.c	28 Sep 2003 01:56:55 -0000
@@ -320,14 +320,14 @@
 	memset (buf, 0, MAX_REGISTER_SIZE);
 	nr_bytes = sim_fetch_register (gdbsim_desc,
 				       REGISTER_SIM_REGNO (regno),
-				       buf, REGISTER_RAW_SIZE (regno));
-	if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno) && warn_user)
+				       buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
+	if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno) && warn_user)
 	  {
 	    fprintf_unfiltered (gdb_stderr,
 				"Size of register %s (%d/%d) incorrect (%d instead of %d))",
 				REGISTER_NAME (regno),
 				regno, REGISTER_SIM_REGNO (regno),
-				nr_bytes, REGISTER_RAW_SIZE (regno));
+				nr_bytes, DEPRECATED_REGISTER_RAW_SIZE (regno));
 	    warn_user = 0;
 	  }
 	/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
@@ -340,7 +340,7 @@
 	  {
 	    printf_filtered ("gdbsim_fetch_register: %d", regno);
 	    /* FIXME: We could print something more intelligible.  */
-	    dump_mem (buf, REGISTER_RAW_SIZE (regno));
+	    dump_mem (buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
 	  }
 	break;
       }
@@ -364,8 +364,8 @@
       deprecated_read_register_gen (regno, tmp);
       nr_bytes = sim_store_register (gdbsim_desc,
 				     REGISTER_SIM_REGNO (regno),
-				     tmp, REGISTER_RAW_SIZE (regno));
-      if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
+				     tmp, DEPRECATED_REGISTER_RAW_SIZE (regno));
+      if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno))
 	internal_error (__FILE__, __LINE__,
 			"Register size different to expected");
       /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
@@ -375,7 +375,7 @@
 	{
 	  printf_filtered ("gdbsim_store_register: %d", regno);
 	  /* FIXME: We could print something more intelligible.  */
-	  dump_mem (tmp, REGISTER_RAW_SIZE (regno));
+	  dump_mem (tmp, DEPRECATED_REGISTER_RAW_SIZE (regno));
 	}
     }
 }
Index: remote-vxmips.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxmips.c,v
retrieving revision 1.10
diff -u -r1.10 remote-vxmips.c
--- remote-vxmips.c	17 Sep 2003 14:24:30 -0000	1.10
+++ remote-vxmips.c	28 Sep 2003 01:56:55 -0000
@@ -131,20 +131,20 @@
 
       bcopy (&mips_fpreg_packet[MIPS_R_FP0],
 	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
-	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
+	     DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
 
       /* Copy the floating point control/status register (fpcsr).  */
 
       bcopy (&mips_fpreg_packet[MIPS_R_FPCSR],
 	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
-	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
+	     DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM));
     }
   else
     {
       bzero ((char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
-	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
+	     DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
       bzero ((char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
-	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
+	     DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM));
     }
 
   /* Mark the register cache valid.  */
@@ -187,13 +187,13 @@
 
       bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     &mips_fpreg_packet[MIPS_R_FP0],
-	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
+	     DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
 
       /* Copy the floating point control/status register (fpcsr).  */
 
       bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
 	     &mips_fpreg_packet[MIPS_R_FPCSR],
-	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
+	     DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM));
 
       net_write_registers (mips_fpreg_packet, MIPS_FPREG_PLEN,
 			   PTRACE_SETFPREGS);
Index: remote-vxsparc.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxsparc.c,v
retrieving revision 1.14
diff -u -r1.14 remote-vxsparc.c
--- remote-vxsparc.c	17 Sep 2003 15:42:21 -0000	1.14
+++ remote-vxsparc.c	28 Sep 2003 01:57:01 -0000
@@ -102,9 +102,9 @@
      automatically; it greatly simplifies debugging.  */
 
   sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)],
-				 REGISTER_RAW_SIZE (SP_REGNUM));
+				 DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM));
   write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-		16 * REGISTER_RAW_SIZE (L0_REGNUM));
+		16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
 
   /* If the target has floating point registers, fetch them.
      Otherwise, zero the floating point register values in
@@ -177,9 +177,9 @@
       if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM))
 	{
 	  sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)],
-					 REGISTER_RAW_SIZE (SP_REGNUM));
+					 DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM));
 	  write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-			16 * REGISTER_RAW_SIZE (L0_REGNUM));
+			16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
 	}
     }
 
Index: remote.c
===================================================================
RCS file: /cvs/src/src/gdb/remote.c,v
retrieving revision 1.115
diff -u -r1.115 remote.c
--- remote.c	21 Sep 2003 01:26:45 -0000	1.115
+++ remote.c	28 Sep 2003 01:57:54 -0000
@@ -216,7 +216,7 @@
   long regnum; /* GDB's internal register number.  */
   LONGEST pnum; /* Remote protocol register number.  */
   int in_g_packet; /* Always part of G packet.  */
-  /* long size in bytes;  == REGISTER_RAW_SIZE (regnum); at present.  */
+  /* long size in bytes;  == DEPRECATED_REGISTER_RAW_SIZE (regnum); at present.  */
   /* char *name; == REGISTER_NAME (regnum); at present.  */
 };
 
@@ -3023,9 +3023,9 @@
 		      error ("Remote sent bad register number %s: %s\nPacket: '%s'\n",
 			     phex_nz (pnum, 0), p, buf);
 
-		    fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum));
+		    fieldsize = hex2bin (p, regs, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum));
 		    p += 2 * fieldsize;
-		    if (fieldsize < REGISTER_RAW_SIZE (reg->regnum))
+		    if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum))
 		      warning ("Remote reply is too short: %s", buf);
 		    supply_register (reg->regnum, regs);
 		  }
@@ -3271,9 +3271,9 @@
 		      error ("Remote sent bad register number %ld: %s\nPacket: '%s'\n",
 			     pnum, p, buf);
 
-		    fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum));
+		    fieldsize = hex2bin (p, regs, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum));
 		    p += 2 * fieldsize;
-		    if (fieldsize < REGISTER_RAW_SIZE (reg->regnum))
+		    if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum))
 		      warning ("Remote reply is too short: %s", buf);
 		    supply_register (reg->regnum, regs);
 		  }
@@ -3548,7 +3548,7 @@
   sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
   p = buf + strlen (buf);
   regcache_collect (reg->regnum, regp);
-  bin2hex (regp, p, REGISTER_RAW_SIZE (reg->regnum));
+  bin2hex (regp, p, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum));
   remote_send (buf, rs->remote_packet_size);
 
   return buf[0] != '\0';
Index: rom68k-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/rom68k-rom.c,v
retrieving revision 1.12
diff -u -r1.12 rom68k-rom.c
--- rom68k-rom.c	11 Jun 2003 13:16:28 -0000	1.12
+++ rom68k-rom.c	28 Sep 2003 01:57:54 -0000
@@ -101,7 +101,7 @@
   while (is_whitespace (*hex))
     hex++;
 
-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), value);
+  store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), value);
   supply_register (regno, regbuf);
 
   return hex;
Index: rs6000-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-nat.c,v
retrieving revision 1.33
diff -u -r1.33 rs6000-nat.c
--- rs6000-nat.c	14 Sep 2003 16:32:14 -0000	1.33
+++ rs6000-nat.c	28 Sep 2003 02:02:47 -0000
@@ -71,7 +71,7 @@
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
-# define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
+# define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8)
 #endif
 
 /* Union of 32-bit and 64-bit ".reg" core file sections. */
@@ -251,7 +251,7 @@
 	     even if the register is really only 32 bits. */
 	  long long buf;
 	  rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
-	  if (REGISTER_RAW_SIZE (regno) == 8)
+	  if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)
 	    memcpy (addr, &buf, 8);
 	  else
 	    *addr = buf;
@@ -320,7 +320,7 @@
 	  /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
 	     area, even if the register is really only 32 bits. */
 	  long long buf;
-	  if (REGISTER_RAW_SIZE (regno) == 8)
+	  if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)
 	    memcpy (&buf, addr, 8);
 	  else
 	    buf = *addr;
Index: rs6000-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
retrieving revision 1.162
diff -u -r1.162 rs6000-tdep.c
--- rs6000-tdep.c	25 Sep 2003 20:44:01 -0000	1.162
+++ rs6000-tdep.c	28 Sep 2003 02:03:33 -0000
@@ -1154,7 +1154,7 @@
 
   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
     {
-      int reg_size = REGISTER_RAW_SIZE (ii + 3);
+      int reg_size = DEPRECATED_REGISTER_RAW_SIZE (ii + 3);
 
       arg = args[argno];
       type = check_typedef (VALUE_TYPE (arg));
@@ -1334,7 +1334,7 @@
          is a pseudo register.  */
       int offset = 0;
       int return_regnum = tdep->ppc_gp0_regnum + 3;
-      int reg_size = REGISTER_RAW_SIZE (return_regnum);
+      int reg_size = DEPRECATED_REGISTER_RAW_SIZE (return_regnum);
       int reg_part_size;
       char *val_buffer;
       int copied = 0;
@@ -1360,7 +1360,7 @@
          if the value is smaller than the register.  */
       while (copied < vallen)
         {
-          reg_part_size = REGISTER_RAW_SIZE (return_regnum + i);
+          reg_part_size = DEPRECATED_REGISTER_RAW_SIZE (return_regnum + i);
 	  /* It is a pseudo/cooked register.  */
           regcache_cooked_read (regbuf, return_regnum + i,
 				val_buffer + copied);
@@ -1421,8 +1421,8 @@
     {
       /* return value is copied starting from r3. */
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
-	  && TYPE_LENGTH (valtype) < REGISTER_RAW_SIZE (3))
-	offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
+	  && TYPE_LENGTH (valtype) < DEPRECATED_REGISTER_RAW_SIZE (3))
+	offset = DEPRECATED_REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
 
       memcpy (valbuf,
 	      regbuf + DEPRECATED_REGISTER_BYTE (3) + offset,
@@ -1699,8 +1699,13 @@
 	  CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset;
 	  for (i = fdatap->saved_vr; i < 32; i++)
 	    {
+<<<<<<< rs6000-tdep.c
+	      get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
+	      vr_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+=======
 	      deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
 	      vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
+>>>>>>> 1.162
 	    }
 	}
     }
@@ -1715,9 +1720,15 @@
 	  CORE_ADDR ev_addr = frame_addr + fdatap->ev_offset;
 	  for (i = fdatap->saved_ev; i < 32; i++)
 	    {
+<<<<<<< rs6000-tdep.c
+	      get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
+              get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
+	      ev_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum);
+=======
 	      deprecated_get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
               deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
 	      ev_addr += REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum);
+>>>>>>> 1.162
             }
 	}
     }
@@ -1782,7 +1793,7 @@
       {
 	get_frame_extra_info (fi)->initial_sp
 	  = extract_unsigned_integer (tmpbuf,
-				      REGISTER_RAW_SIZE (fdata.alloca_reg));
+				      DEPRECATED_REGISTER_RAW_SIZE (fdata.alloca_reg));
       }
     else
       /* NOTE: cagney/2002-04-17: At present the only time
@@ -1932,13 +1943,13 @@
 rs6000_register_convert_to_virtual (int n, struct type *type,
 				    char *from, char *to)
 {
-  if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n))
+  if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n))
     {
-      double val = deprecated_extract_floating (from, REGISTER_RAW_SIZE (n));
+      double val = deprecated_extract_floating (from, DEPRECATED_REGISTER_RAW_SIZE (n));
       deprecated_store_floating (to, TYPE_LENGTH (type), val);
     }
   else
-    memcpy (to, from, REGISTER_RAW_SIZE (n));
+    memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n));
 }
 
 /* Convert data from virtual format with type TYPE in buffer FROM
@@ -1948,13 +1959,13 @@
 rs6000_register_convert_to_raw (struct type *type, int n,
 				const char *from, char *to)
 {
-  if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n))
+  if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n))
     {
       double val = deprecated_extract_floating (from, TYPE_LENGTH (type));
-      deprecated_store_floating (to, REGISTER_RAW_SIZE (n), val);
+      deprecated_store_floating (to, DEPRECATED_REGISTER_RAW_SIZE (n), val);
     }
   else
-    memcpy (to, from, REGISTER_RAW_SIZE (n));
+    memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n));
 }
 
 static void
@@ -2060,7 +2071,7 @@
   while (copied < len)
     {
       int regnum = gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3 + i;
-      int reg_size = REGISTER_RAW_SIZE (regnum);
+      int reg_size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
       char *reg_val_buf = alloca (reg_size);
 
       memcpy (reg_val_buf, valbuf + copied, reg_size);
Index: s390-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/s390-tdep.c,v
retrieving revision 1.116
diff -u -r1.116 s390-tdep.c
--- s390-tdep.c	27 Sep 2003 15:51:02 -0000	1.116
+++ s390-tdep.c	28 Sep 2003 02:03:39 -0000
@@ -2000,7 +2000,7 @@
             ULONGEST value;
             
             value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
-                                                  REGISTER_RAW_SIZE (regnum));
+                                                  DEPRECATED_REGISTER_RAW_SIZE (regnum));
             write_register (regnum, value);
           }
 
Index: sh64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh64-tdep.c,v
retrieving revision 1.8
diff -u -r1.8 sh64-tdep.c
--- sh64-tdep.c	27 Sep 2003 15:51:02 -0000	1.8
+++ sh64-tdep.c	28 Sep 2003 02:03:44 -0000
@@ -753,7 +753,7 @@
       if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 	size = 4;
       else
-	size = REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode));
+	size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode));
       return read_memory_integer (get_frame_base (frame)
 				  + get_frame_extra_info (frame)->f_offset,
 				  size);
@@ -787,7 +787,7 @@
 	    int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
 	    int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 			? 4
-			: REGISTER_RAW_SIZE (gdb_reg_num));
+			: DEPRECATED_REGISTER_RAW_SIZE (gdb_reg_num));
 	    return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
 	  }
       }
@@ -1205,7 +1205,7 @@
       if (tdep->sh_abi == SH_ABI_32)
 	size = 4;
       else
-	size = REGISTER_RAW_SIZE (fp_regnum);
+	size = DEPRECATED_REGISTER_RAW_SIZE (fp_regnum);
       deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size);
     }
   else
@@ -1293,7 +1293,7 @@
 	    memcpy (raw_buffer,
 		    (deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
 		     + DEPRECATED_REGISTER_BYTE (regnum)),
-		    REGISTER_RAW_SIZE (regnum));
+		    DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	  return;
 	}
 
@@ -1306,8 +1306,13 @@
 	  if (regnum == SP_REGNUM)
 	    {
 	      if (raw_buffer)	/* SP register treated specially */
+<<<<<<< sh64-tdep.c
+		store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum),
+					get_frame_saved_regs (frame)[regnum]);
+=======
 		store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
 					deprecated_get_frame_saved_regs (frame)[regnum]);
+>>>>>>> 1.8
 	    }
 	  else
 	    { /* any other register */
@@ -1322,13 +1327,13 @@
 			  || live_regnum == PR_REGNUM))
 		    size = 4;
 		  else
-		    size = REGISTER_RAW_SIZE (live_regnum);
+		    size = DEPRECATED_REGISTER_RAW_SIZE (live_regnum);
 		  if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
 		    read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
 		  else
 		    read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
 				 raw_buffer
-				 + REGISTER_RAW_SIZE (live_regnum)
+				 + DEPRECATED_REGISTER_RAW_SIZE (live_regnum)
 				 - size,
 				 size);
 		}
@@ -1352,7 +1357,7 @@
 sh64_extract_struct_value_address (char *regbuf)
 {
   return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)), 
-				    REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
+				    DEPRECATED_REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
 }
 
 static CORE_ADDR
@@ -1392,7 +1397,7 @@
 		    || regnum ==  PR_REGNUM))
 	      size = 4;
 	    else
-	      size = REGISTER_RAW_SIZE (translate_insn_rn (regnum,
+	      size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (regnum,
 							   media_mode));
 	    write_register (regnum,
 			    read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
@@ -1526,7 +1531,7 @@
       
       if (TYPE_CODE (type) != TYPE_CODE_FLT)
 	{
-	  argreg_size = REGISTER_RAW_SIZE (int_argreg);
+	  argreg_size = DEPRECATED_REGISTER_RAW_SIZE (int_argreg);
 
 	  if (len < argreg_size)
 	    {
@@ -1702,7 +1707,7 @@
 	  return_register = DEFAULT_RETURN_REGNUM;
 	  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 	    offset = DEPRECATED_REGISTER_BYTE (return_register) +
-	      REGISTER_RAW_SIZE (return_register) - len;
+	      DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
 	  else
 	    offset = DEPRECATED_REGISTER_BYTE (return_register);
 	  memcpy (valbuf, (char *) regbuf + offset, len);
@@ -1743,14 +1748,14 @@
       int return_register = DEFAULT_RETURN_REGNUM;
       int offset = 0;
 
-      if (len <= REGISTER_RAW_SIZE (return_register))
+      if (len <= DEPRECATED_REGISTER_RAW_SIZE (return_register))
 	{
 	  /* Pad with zeros. */
-	  memset (buf, 0, REGISTER_RAW_SIZE (return_register));
+	  memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (return_register));
 	  if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
-	    offset = 0; /*REGISTER_RAW_SIZE (return_register) - len;*/
+	    offset = 0; /*DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;*/
 	  else
-	    offset = REGISTER_RAW_SIZE (return_register) - len;
+	    offset = DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
 
 	  memcpy (buf + offset, valbuf, len);
 	  deprecated_write_register_gen (return_register, buf);
@@ -2092,7 +2097,7 @@
   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op. */
-      memcpy (to, from, REGISTER_RAW_SIZE (regnum));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
       return;
     }
 
@@ -2118,7 +2123,7 @@
   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op. */
-      memcpy (to, from, REGISTER_RAW_SIZE (regnum));
+      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
       return;
     }
 
@@ -2155,7 +2160,7 @@
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   (temp_buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
 
       /* We must pay attention to the endiannes. */
       sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
@@ -2174,7 +2179,7 @@
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   ((char *) buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   else if (reg_nr >= FV0_REGNUM 
@@ -2188,7 +2193,7 @@
       for (portion = 0; portion < 4; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   ((char *) buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   /* sh compact pseudo registers. 1-to-1 with a shmedia register */
@@ -2225,7 +2230,7 @@
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   (temp_buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
 
       /* We must pay attention to the endiannes. */
       sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
@@ -2243,7 +2248,7 @@
       for (portion = 0; portion < 4; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   ((char *) buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   else if (reg_nr == FPSCR_C_REGNUM)
@@ -2322,7 +2327,7 @@
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_write (regcache, base_regnum + portion, 
 			    (temp_buffer
-			     + REGISTER_RAW_SIZE (base_regnum) * portion));
+			     + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   else if (reg_nr >= FPP0_REGNUM 
@@ -2334,7 +2339,7 @@
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_write (regcache, base_regnum + portion,
 			    ((char *) buffer
-			     + REGISTER_RAW_SIZE (base_regnum) * portion));
+			     + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   else if (reg_nr >= FV0_REGNUM
@@ -2346,7 +2351,7 @@
       for (portion = 0; portion < 4; portion++)
 	regcache_raw_write (regcache, base_regnum + portion,
 			    ((char *) buffer
-			     + REGISTER_RAW_SIZE (base_regnum) * portion));
+			     + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
     }
 
   /* sh compact general pseudo registers. 1-to-1 with a shmedia
@@ -2390,7 +2395,7 @@
 
 	  regcache_raw_write (regcache, base_regnum + portion,
 			      (temp_buffer
-			       + REGISTER_RAW_SIZE (base_regnum) * portion));
+			       + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
 	}
     }
 
@@ -2403,7 +2408,7 @@
 	{
 	  regcache_raw_write (regcache, base_regnum + portion,
 			      ((char *) buffer
-			       + REGISTER_RAW_SIZE (base_regnum) * portion));
+			       + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
 	}
     }
 
Index: sparc-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-nat.c,v
retrieving revision 1.21
diff -u -r1.21 sparc-nat.c
--- sparc-nat.c	17 Sep 2003 15:42:21 -0000	1.21
+++ sparc-nat.c	28 Sep 2003 02:03:44 -0000
@@ -103,7 +103,7 @@
 
       deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (1)],
-	      &inferior_registers.r_g1, 15 * REGISTER_RAW_SIZE (G0_REGNUM));
+	      &inferior_registers.r_g1, 15 * DEPRECATED_REGISTER_RAW_SIZE (G0_REGNUM));
       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
 	= inferior_registers.r_ps;
       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)]
@@ -149,7 +149,7 @@
     {
       CORE_ADDR sp = *(unsigned int *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
       target_read_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-			  16 * REGISTER_RAW_SIZE (L0_REGNUM));
+			  16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
       for (i = L0_REGNUM; i <= I7_REGNUM; i++)
 	deprecated_register_valid[i] = 1;
     }
@@ -160,7 +160,7 @@
       if (deprecated_register_valid[regno])
 	printf_unfiltered ("register %d valid and read\n", regno);
       target_read_memory (sp + i - DEPRECATED_REGISTER_BYTE (L0_REGNUM),
-			  &deprecated_registers[i], REGISTER_RAW_SIZE (regno));
+			  &deprecated_registers[i], DEPRECATED_REGISTER_RAW_SIZE (regno));
       deprecated_register_valid[regno] = 1;
     }
 }
@@ -234,7 +234,7 @@
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  target_write_memory (sp,
 			       &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-			       16 * REGISTER_RAW_SIZE (L0_REGNUM));
+			       16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
 	}
       else
 	{
@@ -242,7 +242,7 @@
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  target_write_memory (sp + DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM),
 			       &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-			       REGISTER_RAW_SIZE (regno));
+			       DEPRECATED_REGISTER_RAW_SIZE (regno));
 	}
 
     }
@@ -254,7 +254,7 @@
 
       memcpy (&inferior_registers.r_g1,
 	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
-	      15 * REGISTER_RAW_SIZE (G1_REGNUM));
+	      15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
 
       inferior_registers.r_ps =
 	*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)];
@@ -315,7 +315,7 @@
 
       /* The globals and output registers.  */
       memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
-	      15 * REGISTER_RAW_SIZE (G1_REGNUM));
+	      15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (DEPRECATED_NPC_REGNUM)] = gregs->r_npc;
@@ -332,7 +332,7 @@
 	sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
 	if (0 != target_read_memory (sp,
 				     &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
-				     16 * REGISTER_RAW_SIZE (L0_REGNUM)))
+				     16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)))
 	  {
 	    /* fprintf_unfiltered so user can still use gdb */
 	    fprintf_unfiltered (gdb_stderr,
Index: sparc-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-tdep.c,v
retrieving revision 1.128
diff -u -r1.128 sparc-tdep.c
--- sparc-tdep.c	18 Sep 2003 22:39:21 -0000	1.128
+++ sparc-tdep.c	28 Sep 2003 02:03:51 -0000
@@ -815,7 +815,7 @@
       if (raw_buffer != NULL)
 	{
 	  /* Put it back in target format.  */
-	  store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
+	  store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
 	}
       if (addrp != NULL)
 	*addrp = 0;
@@ -923,14 +923,14 @@
 	  if (raw_buffer != NULL)
 	    {
 	      /* Put it back in target format.  */
-	      store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
+	      store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), addr);
 	    }
 	  if (addrp != NULL)
 	    *addrp = 0;
 	  return;
 	}
       if (raw_buffer != NULL)
-	read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+	read_memory (addr, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));
     }
   else
     {
@@ -974,10 +974,10 @@
       /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
       deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM),
 				      &register_temp[0],
-				      REGISTER_RAW_SIZE (PC_REGNUM) * 7);
+				      DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM) * 7);
       deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM), 
 				      &register_temp[7 * SPARC_INTREG_SIZE],
-				      REGISTER_RAW_SIZE (PSTATE_REGNUM));
+				      DEPRECATED_REGISTER_RAW_SIZE (PSTATE_REGNUM));
       /* FIXME: not sure what needs to be saved here.  */
     }
   else
@@ -985,7 +985,7 @@
       /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
       deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM),
 				      &register_temp[0],
-				      REGISTER_RAW_SIZE (Y_REGNUM) * 8);
+				      DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM) * 8);
     }
 
   deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM),
@@ -1308,29 +1308,29 @@
     if (fsr[PS_REGNUM])
       write_register (PS_REGNUM, 
 		      read_memory_integer (fsr[PS_REGNUM], 
-					   REGISTER_RAW_SIZE (PS_REGNUM)));
+					   DEPRECATED_REGISTER_RAW_SIZE (PS_REGNUM)));
 
   if (fsr[Y_REGNUM])
     write_register (Y_REGNUM, 
 		    read_memory_integer (fsr[Y_REGNUM], 
-					 REGISTER_RAW_SIZE (Y_REGNUM)));
+					 DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM)));
   if (fsr[PC_REGNUM])
     {
       /* Explicitly specified PC (and maybe NPC) -- just restore them. */
       write_register (PC_REGNUM, 
 		      read_memory_integer (fsr[PC_REGNUM],
-					   REGISTER_RAW_SIZE (PC_REGNUM)));
+					   DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));
       if (fsr[DEPRECATED_NPC_REGNUM])
 	write_register (DEPRECATED_NPC_REGNUM,
 			read_memory_integer (fsr[DEPRECATED_NPC_REGNUM],
-					     REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM)));
+					     DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM)));
     }
   else if (get_frame_extra_info (frame)->flat)
     {
       if (get_frame_extra_info (frame)->pc_addr)
 	pc = PC_ADJUST ((CORE_ADDR)
 			read_memory_integer (get_frame_extra_info (frame)->pc_addr,
-					     REGISTER_RAW_SIZE (PC_REGNUM)));
+					     DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));
       else
 	{
 	  /* I think this happens only in the innermost frame, if so then
@@ -1713,7 +1713,7 @@
 	{
 	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
-	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
+	  memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
 	}
     }
 
@@ -1722,7 +1722,7 @@
       {
 	from = (char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)];
 	to = (char *) &fpregsetp->pr_fsr;
-	memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
+	memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (FPS_REGNUM));
       }
 }
 
@@ -2071,13 +2071,13 @@
 		     file, 0, 1, 0, Val_pretty_default);
 
 	  fprintf_filtered (file, "\t(raw 0x");
-	  for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+	  for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++)
 	    {
 	      int idx;
 	      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 		idx = j;
 	      else
-		idx = REGISTER_RAW_SIZE (i) - 1 - j;
+		idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j;
 	      fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
 	    }
 	  fprintf_filtered (file, ")");
@@ -2408,10 +2408,10 @@
     regno = O0_REGNUM;
 
   /* Add leading zeros to the value. */
-  if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno))
+  if (TYPE_LENGTH (type) < DEPRECATED_REGISTER_RAW_SIZE (regno))
     {
-      memset (buffer, 0, REGISTER_RAW_SIZE (regno));
-      memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
+      memset (buffer, 0, DEPRECATED_REGISTER_RAW_SIZE (regno));
+      memcpy (buffer + DEPRECATED_REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
 	      TYPE_LENGTH (type));
       deprecated_write_register_gen (regno, buffer);
     }
@@ -2722,7 +2722,7 @@
 			   int bitoffset)
 {
   int typelen = TYPE_LENGTH (type);
-  int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
+  int regsize = DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM);
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     {
Index: stack.c
===================================================================
RCS file: /cvs/src/src/gdb/stack.c,v
retrieving revision 1.89
diff -u -r1.89 stack.c
--- stack.c	25 Sep 2003 20:44:01 -0000	1.89
+++ stack.c	28 Sep 2003 02:03:54 -0000
@@ -1055,7 +1055,7 @@
 	    /* NOTE: cagney/2003-05-22: This is assuming that the
                stack pointer was packed as an unsigned integer.  That
                may or may not be valid.  */
-	    sp = extract_unsigned_integer (value, REGISTER_RAW_SIZE (SP_REGNUM));
+	    sp = extract_unsigned_integer (value, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM));
 	    printf_filtered (" Previous frame's sp is ");
 	    print_address_numeric (sp, 1, gdb_stdout);
 	    printf_filtered ("\n");
Index: target.c
===================================================================
RCS file: /cvs/src/src/gdb/target.c,v
retrieving revision 1.54
diff -u -r1.54 target.c
--- target.c	21 Sep 2003 01:26:45 -0000	1.54
+++ target.c	28 Sep 2003 02:03:55 -0000
@@ -1660,11 +1660,11 @@
       unsigned char buf[MAX_REGISTER_SIZE];
       deprecated_read_register_gen (regno, buf);
       fprintf_unfiltered (gdb_stdlog, " = ");
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
+      for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i++)
 	{
 	  fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
 	}
-      if (REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST))
+      if (DEPRECATED_REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST))
 	{
 	  fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
 			      paddr_nz (read_register (regno)),
Index: tracepoint.c
===================================================================
RCS file: /cvs/src/src/gdb/tracepoint.c,v
retrieving revision 1.53
diff -u -r1.53 tracepoint.c
--- tracepoint.c	14 Sep 2003 16:32:14 -0000	1.53
+++ tracepoint.c	28 Sep 2003 02:03:58 -0000
@@ -1215,7 +1215,7 @@
       /* check for doubles stored in two registers */
       /* FIXME: how about larger types stored in 3 or more regs? */
       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
-	  len > REGISTER_RAW_SIZE (reg))
+	  len > DEPRECATED_REGISTER_RAW_SIZE (reg))
 	add_register (collect, reg + 1);
       break;
     case LOC_REF_ARG:
Index: v850-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/v850-tdep.c,v
retrieving revision 1.75
diff -u -r1.75 v850-tdep.c
--- v850-tdep.c	27 Sep 2003 15:51:02 -0000	1.75
+++ v850-tdep.c	28 Sep 2003 02:04:00 -0000
@@ -1074,7 +1074,7 @@
          pointed to by R6. */
       return_buffer =
 	extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM),
-				  REGISTER_RAW_SIZE (E_V0_REGNUM));
+				  DEPRECATED_REGISTER_RAW_SIZE (E_V0_REGNUM));
 
       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
     }
Index: v850ice.c
===================================================================
RCS file: /cvs/src/src/gdb/v850ice.c,v
retrieving revision 1.17
diff -u -r1.17 v850ice.c
--- v850ice.c	21 Sep 2003 01:26:45 -0000	1.17
+++ v850ice.c	28 Sep 2003 02:04:02 -0000
@@ -534,7 +534,7 @@
     error ("v850ice_fetch_registers (%d):  bad value from ICE: %s.",
 	   regno, val);
 
-  store_unsigned_integer (val, REGISTER_RAW_SIZE (regno), regval);
+  store_unsigned_integer (val, DEPRECATED_REGISTER_RAW_SIZE (regno), regval);
   supply_register (regno, val);
 }
 
@@ -560,7 +560,7 @@
     }
 
   regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
-				     REGISTER_RAW_SIZE (regno));
+				     DEPRECATED_REGISTER_RAW_SIZE (regno));
   strcpy (cmd, "reg ");
   if (!convert_register (regno, &cmd[4]))
     return;
Index: valops.c
===================================================================
RCS file: /cvs/src/src/gdb/valops.c,v
retrieving revision 1.116
diff -u -r1.116 valops.c
--- valops.c	25 Sep 2003 16:39:38 -0000	1.116
+++ valops.c	28 Sep 2003 02:04:06 -0000
@@ -627,7 +627,7 @@
 	    {
 	      int offset;
 	      for (reg_offset = value_reg, offset = 0;
-		   offset + REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval);
+		   offset + DEPRECATED_REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval);
 		   reg_offset++);
 	      byte_offset = VALUE_OFFSET (toval) - offset;
 	    }
@@ -645,7 +645,7 @@
 	    /* Copy it in.  */
 	    for (regno = reg_offset, amount_copied = 0;
 		 amount_copied < amount_to_copy;
-		 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
+		 amount_copied += DEPRECATED_REGISTER_RAW_SIZE (regno), regno++)
 	      frame_register_read (frame, regno, buffer + amount_copied);
 	    
 	    /* Modify what needs to be modified.  */
@@ -662,7 +662,7 @@
 	    /* Copy it out.  */
 	    for (regno = reg_offset, amount_copied = 0;
 		 amount_copied < amount_to_copy;
-		 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
+		 amount_copied += DEPRECATED_REGISTER_RAW_SIZE (regno), regno++)
 	      put_frame_register (frame, regno, buffer + amount_copied);
 
 	  }
Index: vax-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/vax-tdep.c,v
retrieving revision 1.64
diff -u -r1.64 vax-tdep.c
--- vax-tdep.c	27 Sep 2003 15:51:02 -0000	1.64
+++ vax-tdep.c	28 Sep 2003 02:04:06 -0000
@@ -280,7 +280,7 @@
 vax_extract_struct_value_address (char *regbuf)
 {
   return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0),
-				    REGISTER_RAW_SIZE (0)));
+				    DEPRECATED_REGISTER_RAW_SIZE (0)));
 }
 
 static const unsigned char *
Index: vax-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/vax-tdep.h,v
retrieving revision 1.3
diff -u -r1.3 vax-tdep.h
--- vax-tdep.h	4 Jan 2003 23:38:46 -0000	1.3
+++ vax-tdep.h	28 Sep 2003 02:04:06 -0000
@@ -22,7 +22,7 @@
 #define VAX_TDEP_H
 
 /* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places;  REGISTER_RAW_SIZE is the
+   used in push_word and a few other places;  DEPRECATED_REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */
 #define VAX_REGISTER_SIZE 4
 
@@ -33,7 +33,7 @@
    register state.  */
 #define VAX_REGISTER_BYTES (VAX_NUM_REGS * 4)
 
-/* Largest value REGISTER_RAW_SIZE can have.  */
+/* Largest value DEPRECATED_REGISTER_RAW_SIZE can have.  */
 #define VAX_MAX_REGISTER_RAW_SIZE 4
 
 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
Index: x86-64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/x86-64-tdep.c,v
retrieving revision 1.92
diff -u -r1.92 x86-64-tdep.c
--- x86-64-tdep.c	27 Sep 2003 18:11:58 -0000	1.92
+++ x86-64-tdep.c	28 Sep 2003 02:04:24 -0000
@@ -795,8 +795,8 @@
   /* XXX: What about complex floating point types?  */
   else
     {
-      int low_size = REGISTER_RAW_SIZE (0);
-      int high_size = REGISTER_RAW_SIZE (1);
+      int low_size = DEPRECATED_REGISTER_RAW_SIZE (0);
+      int high_size = DEPRECATED_REGISTER_RAW_SIZE (1);
 
       if (len <= low_size)
         regcache_cooked_write_part (regcache, 0, 0, len, valbuf);
Index: xstormy16-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/xstormy16-tdep.c,v
retrieving revision 1.65
diff -u -r1.65 xstormy16-tdep.c
--- xstormy16-tdep.c	27 Sep 2003 15:51:02 -0000	1.65
+++ xstormy16-tdep.c	28 Sep 2003 02:04:25 -0000
@@ -230,7 +230,7 @@
          pointed to by R2. */
       return_buffer =
 	extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM),
-				  REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
+				  DEPRECATED_REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
 
       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
     }
Index: config/m68k/tm-delta68.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m68k/tm-delta68.h,v
retrieving revision 1.13
diff -u -r1.13 tm-delta68.h
--- config/m68k/tm-delta68.h	17 Sep 2003 14:24:31 -0000	1.13
+++ config/m68k/tm-delta68.h	28 Sep 2003 02:04:25 -0000
@@ -68,10 +68,10 @@
 #define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
   if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)				\
       {									\
-	char raw_buf[REGISTER_RAW_SIZE (FP0_REGNUM)];			\
+	char raw_buf[DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)];			\
 	DEPRECATED_REGISTER_CONVERT_TO_RAW (TYPE, FP0_REGNUM, VALBUF, raw_buf);	\
 	deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),		\
-			      raw_buf, REGISTER_RAW_SIZE (FP0_REGNUM)); \
+			      raw_buf, DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)); \
       }									\
   else									\
     deprecated_write_register_bytes ((TYPE_CODE(TYPE) == TYPE_CODE_PTR ? 8 * 4 : 0), \
Index: config/m68k/tm-vx68.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m68k/tm-vx68.h,v
retrieving revision 1.8
diff -u -r1.8 tm-vx68.h
--- config/m68k/tm-vx68.h	5 May 2003 17:56:56 -0000	1.8
+++ config/m68k/tm-vx68.h	28 Sep 2003 02:04:25 -0000
@@ -78,5 +78,5 @@
 
 /* Number of registers in a ptrace_getfpregs call. */
 
-#define VX_SIZE_FPREGS (8 * REGISTER_RAW_SIZE (FP0_REGNUM) \
+#define VX_SIZE_FPREGS (8 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) \
 			+ (3 * DEPRECATED_REGISTER_SIZE))
Index: config/sparc/tm-sparc.h
===================================================================
RCS file: /cvs/src/src/gdb/config/sparc/tm-sparc.h,v
retrieving revision 1.60
diff -u -r1.60 tm-sparc.h
--- config/sparc/tm-sparc.h	22 Sep 2003 17:45:02 -0000	1.60
+++ config/sparc/tm-sparc.h	28 Sep 2003 02:04:30 -0000
@@ -223,7 +223,7 @@
    address).  Some vendors get it wrong.  */
 
 #define	FRAME_SAVED_L0	0
-#define	FRAME_SAVED_I0	(8 * REGISTER_RAW_SIZE (L0_REGNUM))
+#define	FRAME_SAVED_I0	(8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM))
 
 #define FRAME_STRUCT_ARGS_ADDRESS(FI) (get_frame_base (FI))
 
Index: config/sparc/tm-sparclynx.h
===================================================================
RCS file: /cvs/src/src/gdb/config/sparc/tm-sparclynx.h,v
retrieving revision 1.3
diff -u -r1.3 tm-sparclynx.h
--- config/sparc/tm-sparclynx.h	5 Jun 2002 19:18:29 -0000	1.3
+++ config/sparc/tm-sparclynx.h	28 Sep 2003 02:04:30 -0000
@@ -32,6 +32,6 @@
 #undef FRAME_SAVED_L0
 
 #define FRAME_SAVED_I0 0
-#define FRAME_SAVED_L0 (8 * REGISTER_RAW_SIZE (I0_REGNUM))
+#define FRAME_SAVED_L0 (8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM))
 
 #endif /* TM_SPARCLYNX_H */
Index: doc/gdb.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v
retrieving revision 1.175
diff -u -r1.175 gdb.texinfo
--- doc/gdb.texinfo	9 Aug 2003 15:10:09 -0000	1.175
+++ doc/gdb.texinfo	28 Sep 2003 02:07:24 -0000
@@ -19517,9 +19517,9 @@
 Each byte of register data is described by two hex digits.  The bytes
 with the register are transmitted in target byte order.  The size of
 each register and their position within the @samp{g} @var{packet} are
-determined by the @value{GDBN} internal macros @var{REGISTER_RAW_SIZE}
-and @var{REGISTER_NAME} macros.  The specification of several standard
-@code{g} packets is specified below.
+determined by the @value{GDBN} internal macros
+@var{DEPRECATED_REGISTER_RAW_SIZE} and @var{REGISTER_NAME} macros.  The
+specification of several standard @code{g} packets is specified below.
 @item E@var{NN}
 for an error.
 @end table
@@ -19971,12 +19971,13 @@
 
 @var{AA} = two hex digit signal number; @var{n...} = register number
 (hex), @var{r...}  = target byte ordered register contents, size defined
-by @code{REGISTER_RAW_SIZE}; @var{n...} = @samp{thread}, @var{r...} =
-thread process ID, this is a hex integer; @var{n...} = (@samp{watch} | 
-@samp{rwatch} | @samp{awatch}, @var{r...} = data address, this is a hex
-integer; @var{n...} = other string not starting with valid hex digit.
-@value{GDBN} should ignore this @var{n...}, @var{r...} pair and go on
-to the next.  This way we can extend the protocol.
+by @code{DEPRECATED_REGISTER_RAW_SIZE}; @var{n...} = @samp{thread},
+@var{r...} = thread process ID, this is a hex integer; @var{n...} =
+(@samp{watch} | @samp{rwatch} | @samp{awatch}, @var{r...} = data
+address, this is a hex integer; @var{n...} = other string not starting
+with valid hex digit.  @value{GDBN} should ignore this @var{n...},
+@var{r...} pair and go on to the next.  This way we can extend the
+protocol.
 
 @item W@var{AA}
 
Index: doc/gdbint.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdbint.texinfo,v
retrieving revision 1.167
diff -u -r1.167 gdbint.texinfo
--- doc/gdbint.texinfo	22 Sep 2003 23:20:54 -0000	1.167
+++ doc/gdbint.texinfo	28 Sep 2003 02:08:14 -0000
@@ -2766,7 +2766,7 @@
 unless this macro returns a non-zero value for that register.
 @end deftypefn
 
-@deftypefn {Target Macro} int REGISTER_RAW_SIZE (int @var{reg})
+@deftypefn {Target Macro} int DEPRECATED_REGISTER_RAW_SIZE (int @var{reg})
 The size of register number @var{reg}'s raw value.  This is the number
 of bytes the register will occupy in @code{registers}, or in a @value{GDBN}
 remote protocol packet.
@@ -3510,8 +3510,8 @@
 @var{type}.
 @xref{Target Architecture Definition, , Using Different Register and Memory Data Representations}.
 
-@item REGISTER_RAW_SIZE (@var{reg})
-@findex REGISTER_RAW_SIZE
+@item DEPRECATED_REGISTER_RAW_SIZE (@var{reg})
+@findex DEPRECATED_REGISTER_RAW_SIZE
 Return the raw size of @var{reg}; defaults to the size of the register's
 virtual type.
 @xref{Target Architecture Definition, , Raw and Virtual Register Representations}.
Index: mi/ChangeLog
===================================================================
RCS file: /cvs/src/src/gdb/mi/ChangeLog,v
retrieving revision 1.120
diff -u -r1.120 ChangeLog
--- mi/ChangeLog	20 Sep 2003 17:50:28 -0000	1.120
+++ mi/ChangeLog	28 Sep 2003 02:08:21 -0000
@@ -1,10 +1,11 @@
-2003-09-20  Andrew Cagney  <cagney@redhat.com>
+2003-09-27  Andrew Cagney  <cagney@redhat.com>
 
-	* mi-main.c (get_register): 
+	* mi-main.c: Rename REGISTER_RAW_SIZE to
+	DEPRECATED_REGISTER_RAW_SIZE.
 
 2003-09-17  Andrew Cagney  <cagney@redhat.com>
 
-	* mi/mi-main.c: Rename REGISTER_BYTE to DEPRECATED_REGISTER_BYTE.
+	* mi-main.c: Rename REGISTER_BYTE to DEPRECATED_REGISTER_BYTE.
 
 2003-09-10  Elena Zannoni  <ezannoni@redhat.com>
 
Index: mi/mi-main.c
===================================================================
RCS file: /cvs/src/src/gdb/mi/mi-main.c,v
retrieving revision 1.54
diff -u -r1.54 mi-main.c
--- mi/mi-main.c	20 Sep 2003 17:50:28 -0000	1.54
+++ mi/mi-main.c	28 Sep 2003 02:08:46 -0000
@@ -406,13 +406,13 @@
     return -1;
 
   if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
-	      REGISTER_RAW_SIZE (regnum)) == 0)
+	      DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0)
     return 0;
 
   /* Found a changed register. Return 1. */
 
   memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
-	  REGISTER_RAW_SIZE (regnum));
+	  DEPRECATED_REGISTER_RAW_SIZE (regnum));
 
   return 1;
 }
@@ -553,10 +553,10 @@
 
       strcpy (buf, "0x");
       ptr = buf + 2;
-      for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
+      for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (regnum); j++)
 	{
 	  int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
-	  : REGISTER_RAW_SIZE (regnum) - 1 - j;
+	  : DEPRECATED_REGISTER_RAW_SIZE (regnum) - 1 - j;
 	  sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
 	  ptr += 2;
 	}
@@ -642,7 +642,7 @@
 	  old_chain = make_cleanup (xfree, buffer);
 	  store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
 	  /* Write it down */
-	  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
+	  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));
 	  /* Free the buffer.  */
 	  do_cleanups (old_chain);
 	}
Index: tui/tuiRegs.c
===================================================================
RCS file: /cvs/src/src/gdb/tui/tuiRegs.c,v
retrieving revision 1.18
diff -u -r1.18 tuiRegs.c
--- tui/tuiRegs.c	22 Jun 2003 15:21:38 -0000	1.18
+++ tui/tuiRegs.c	28 Sep 2003 02:08:52 -0000
@@ -500,7 +500,7 @@
 		{
                   int size;
 
-                  size = REGISTER_RAW_SIZE (dataElementPtr->itemNo);
+                  size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo);
 		  for (j = 0; j < size; j++)
 		    ((char *) dataElementPtr->value)[j] = rawBuf[j];
 		  _tuiDisplayRegister (
@@ -763,7 +763,7 @@
       if (_tuiGetRegisterRawValue (
 			 dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
 	{
-          int size = REGISTER_RAW_SIZE (dataElement->itemNo);
+          int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->itemNo);
           
 	  for (i = 0; (i < size && !hasChanged); i++)
 	    hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]