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] REGISTER_BYTE -> DEPRECATED_REGISTER_BYTE


Hello,

This renames the REGISTER_BYTE macro, the corresponding architecture method was renamed some time ago. Now that there are only 270 occurances left (down from 440) doing this is much easier.

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

	* gdbarch.sh (DEPRECATED_REGISTER_BYTE): Rename REGISTER_BYTE.
	* gdbarch.h, gdbarch.c: Regenerate.
	* arm-linux-tdep.c, core-sol2.c, cris-tdep.c: Update.
	* d10v-tdep.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, irix5-nat.c, lynx-nat.c, m68knbsd-nat.c: Update.
	* mcore-tdep.c, mips-linux-tdep.c, mips-tdep.c: Update.
	* mipsv4-nat.c, mn10300-tdep.c, ns32k-tdep.c: Update.
	* ns32knbsd-nat.c, ppc-bdm.c, regcache.c, remote-sds.c: Update.
	* remote-vx68.c, remote-vxmips.c, remote-vxsparc.c: Update.
	* remote.c, rs6000-tdep.c, s390-tdep.c, sh64-tdep.c: Update.
	* sparc-nat.c, sparc-tdep.c, sun3-nat.c, v850-tdep.c: Update.
	* v850ice.c, vax-tdep.c, xstormy16-tdep.c: Update.
	* config/m68k/tm-cisco.h, config/m68k/tm-delta68.h: Update.
	* config/pa/nm-hppah.h, mi/mi-main.c: Update.

Index: arm-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/arm-linux-tdep.c,v
retrieving revision 1.36
diff -u -r1.36 arm-linux-tdep.c
--- arm-linux-tdep.c	7 Sep 2003 01:36:00 -0000	1.36
+++ arm-linux-tdep.c	14 Sep 2003 19:38:14 -0000
@@ -86,7 +86,7 @@
 
   int regnum = ((TYPE_CODE_FLT == TYPE_CODE (type))
 		? ARM_F0_REGNUM : ARM_A1_REGNUM);
-  memcpy (valbuf, &regbuf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
+  memcpy (valbuf, &regbuf[DEPRECATED_REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
 }
 
 /* Note: ScottB
Index: core-sol2.c
===================================================================
RCS file: /cvs/src/src/gdb/core-sol2.c,v
retrieving revision 1.10
diff -u -r1.10 core-sol2.c
--- core-sol2.c	14 Nov 2002 20:37:28 -0000	1.10
+++ core-sol2.c	14 Sep 2003 19:38:14 -0000
@@ -94,18 +94,18 @@
 	  struct regs *gregs = (struct regs *) core_reg_sect;
 
 	  /* G0 *always* holds 0.  */
-	  *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
+	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
 
 	  /* The globals and output registers.  */
-	  memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
 		  &gregs->r_g1, 15 * REGISTER_RAW_SIZE (G1_REGNUM));
-	  *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]
+	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
 	    = gregs->r_ps;
-	  *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]
+	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)]
 	    = gregs->r_pc;
-	  *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)]
+	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (NPC_REGNUM)]
 	    = gregs->r_npc;
-	  *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)]
+	  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)]
 	    = gregs->r_y;
 
 	  /* My best guess at where to get the locals and input
@@ -116,9 +116,9 @@
 	  {
 	    int sp;
 
-	    sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
+	    sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
 	    if (0 != target_read_memory (sp,
-					 &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+					 &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 					 16 * REGISTER_RAW_SIZE (L0_REGNUM)))
 	      {
 		warning ("couldn't read input and local registers from core file\n");
@@ -167,9 +167,9 @@
 	{
 	  struct fpu *fpuregs = (struct fpu *) core_reg_sect;
 
-	  memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 		  &fpuregs->fpu_fr, sizeof (fpuregs->fpu_fr));
-	  memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 		  &fpuregs->fpu_fsr, sizeof (FPU_FSR_TYPE));
 	}
       else
Index: cris-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/cris-tdep.c,v
retrieving revision 1.85
diff -u -r1.85 cris-tdep.c
--- cris-tdep.c	14 Sep 2003 16:32:12 -0000	1.85
+++ cris-tdep.c	14 Sep 2003 19:38:18 -0000
@@ -972,7 +972,7 @@
   int len = TYPE_LENGTH (type);
   
   if (len <= DEPRECATED_REGISTER_SIZE) 
-    deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RET_REGNUM), valbuf, len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
 }
@@ -987,8 +987,8 @@
   if (len <= 2 * DEPRECATED_REGISTER_SIZE)
     {
       /* Note that this works since R10 and R11 are consecutive registers.  */
-      deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf,
-				       len);
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RET_REGNUM),
+				       valbuf, len);
     }
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large.");
@@ -1058,7 +1058,7 @@
   int len = TYPE_LENGTH (type);
   
   if (len <= DEPRECATED_REGISTER_SIZE)
-    memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
 }
@@ -1072,7 +1072,7 @@
   int len = TYPE_LENGTH (type);
   
   if (len <= 2 * DEPRECATED_REGISTER_SIZE)
-    memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
 }
Index: d10v-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/d10v-tdep.c,v
retrieving revision 1.130
diff -u -r1.130 d10v-tdep.c
--- d10v-tdep.c	12 Sep 2003 18:40:16 -0000	1.130
+++ d10v-tdep.c	14 Sep 2003 19:38:24 -0000
@@ -277,9 +277,9 @@
   return reg;
 }
 
-/* MAP GDB's internal register numbering (determined by the layout fo
-   the REGISTER_BYTE array) onto the simulator's register
-   numbering. */
+/* MAP GDB's internal register numbering (determined by the layout
+   from the DEPRECATED_REGISTER_BYTE array) onto the simulator's
+   register numbering. */
 
 static int
 d10v_ts2_register_sim_regno (int nr)
Index: frame.c
===================================================================
RCS file: /cvs/src/src/gdb/frame.c,v
retrieving revision 1.140
diff -u -r1.140 frame.c
--- frame.c	14 Sep 2003 16:32:12 -0000	1.140
+++ frame.c	14 Sep 2003 19:38:28 -0000
@@ -1089,9 +1089,9 @@
    calculated rather than fetched).  We will use not_lval for values
    fetched from generic dummy frames.
 
-   Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
-   offset into the registers array.  If the value is stored in a dummy
-   frame, set *ADDRP to zero.
+   Set *ADDRP to the address, either in memory or as a
+   DEPRECATED_REGISTER_BYTE offset into the registers array.  If the
+   value is stored in a dummy frame, set *ADDRP to zero.
 
    The argument RAW_BUFFER must point to aligned memory.  */
 
@@ -1172,7 +1172,7 @@
   if (lval)			/* found it in a live register */
     *lval = lval_register;
   if (addrp)
-    *addrp = REGISTER_BYTE (regnum);
+    *addrp = DEPRECATED_REGISTER_BYTE (regnum);
   if (raw_buffer)
     deprecated_read_register_gen (regnum, raw_buffer);
 }
Index: gdbarch.sh
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.sh,v
retrieving revision 1.268
diff -u -r1.268 gdbarch.sh
--- gdbarch.sh	13 Sep 2003 14:12:40 -0000	1.268
+++ gdbarch.sh	14 Sep 2003 19:38:37 -0000
@@ -481,7 +481,7 @@
 # consequence, even when the predicate is false, the corresponding
 # function works.  This simplifies the migration process - old code,
 # calling DEPRECATED_REGISTER_BYTE, doesn't need to be modified.
-F::REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
+F::DEPRECATED_REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
 # If all registers have identical raw and virtual sizes and those
 # sizes agree with the value computed from REGISTER_TYPE,
 # DEPRECATED_REGISTER_RAW_SIZE can be deleted.  See: maint print
Index: hppa-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/hppa-tdep.c,v
retrieving revision 1.95
diff -u -r1.95 hppa-tdep.c
--- hppa-tdep.c	14 Sep 2003 16:32:12 -0000	1.95
+++ hppa-tdep.c	14 Sep 2003 19:38:49 -0000
@@ -1633,7 +1633,7 @@
 
   for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
     {
-      deprecated_read_register_bytes (REGISTER_BYTE (regnum),
+      deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (regnum),
 				      (char *) &freg_buffer, 8);
       sp = push_bytes (sp, (char *) &freg_buffer, 8);
     }
@@ -1714,7 +1714,7 @@
     if (fsr[regnum])
       {
 	read_memory (fsr[regnum], (char *) &freg_buffer, 8);
-	deprecated_write_register_bytes (REGISTER_BYTE (regnum),
+	deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum),
 					 (char *) &freg_buffer, 8);
       }
 
@@ -2679,7 +2679,8 @@
   /* Make a copy of gdb's save area (may cause actual
      reads from the target). */
   for (i = 0; i < NUM_REGS; i++)
-    frame_register_read (deprecated_selected_frame, i, raw_regs + REGISTER_BYTE (i));
+    frame_register_read (deprecated_selected_frame, i,
+			 raw_regs + DEPRECATED_REGISTER_BYTE (i));
 
   if (regnum == -1)
     pa_print_registers (raw_regs, regnum, fpregs);
@@ -2723,7 +2724,8 @@
   /* Make a copy of gdb's save area (may cause actual
      reads from the target). */
   for (i = 0; i < NUM_REGS; i++)
-    frame_register_read (deprecated_selected_frame, i, raw_regs + REGISTER_BYTE (i));
+    frame_register_read (deprecated_selected_frame, i,
+			 raw_regs + DEPRECATED_REGISTER_BYTE (i));
 
   if (regnum == -1)
     pa_strcat_registers (raw_regs, regnum, fpregs, stream);
@@ -2792,7 +2794,7 @@
 
   if (!is_pa_2)
     {
-      raw_val[1] = *(long *) (raw_regs + REGISTER_BYTE (regnum));
+      raw_val[1] = *(long *) (raw_regs + DEPRECATED_REGISTER_BYTE (regnum));
       return;
     }
 
@@ -4816,13 +4818,13 @@
 
      If its a float value, then we also store it into the floating
      point registers.  */
-  deprecated_write_register_bytes (REGISTER_BYTE (28)
+  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (28)
 				   + (TYPE_LENGTH (type) > 4
 				      ? (8 - TYPE_LENGTH (type))
 				      : (4 - TYPE_LENGTH (type))),
 				   valbuf, TYPE_LENGTH (type));
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
-    deprecated_write_register_bytes (REGISTER_BYTE (FP4_REGNUM),
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP4_REGNUM),
 				     valbuf, TYPE_LENGTH (type));
 }
 
@@ -4833,22 +4835,22 @@
 {
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     deprecated_write_register_bytes
-      (REGISTER_BYTE (FP4_REGNUM)
+      (DEPRECATED_REGISTER_BYTE (FP4_REGNUM)
         + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
        valbuf, TYPE_LENGTH (type));
   else if (is_integral_type(type))
     deprecated_write_register_bytes
-      (REGISTER_BYTE (28)
+      (DEPRECATED_REGISTER_BYTE (28)
         + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
        valbuf, TYPE_LENGTH (type));
   else if (TYPE_LENGTH (type) <= 8)
     deprecated_write_register_bytes
-      (REGISTER_BYTE (28),valbuf, TYPE_LENGTH (type));
+      (DEPRECATED_REGISTER_BYTE (28),valbuf, TYPE_LENGTH (type));
   else if (TYPE_LENGTH (type) <= 16)
     {
-      deprecated_write_register_bytes (REGISTER_BYTE (28),valbuf, 8);
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (28),valbuf, 8);
       deprecated_write_register_bytes
-        (REGISTER_BYTE (29), valbuf + 8, TYPE_LENGTH (type) - 8);
+        (DEPRECATED_REGISTER_BYTE (29), valbuf + 8, TYPE_LENGTH (type) - 8);
     }
 }
 
@@ -4863,11 +4865,11 @@
 hppa32_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 {
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
-    memcpy (valbuf, regbuf + REGISTER_BYTE (FP4_REGNUM), TYPE_LENGTH (type));
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (FP4_REGNUM), TYPE_LENGTH (type));
   else
     memcpy (valbuf,
 	    (regbuf
-	     + REGISTER_BYTE (28)
+	     + DEPRECATED_REGISTER_BYTE (28)
 	     + (TYPE_LENGTH (type) > 4
 		? (8 - TYPE_LENGTH (type))
 		: (4 - TYPE_LENGTH (type)))),
@@ -4885,20 +4887,22 @@
          Aggregates upto 128 bits are in r28 and r29, right padded.  */ 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     memcpy (valbuf,
-            regbuf + REGISTER_BYTE (FP4_REGNUM)
+            regbuf + DEPRECATED_REGISTER_BYTE (FP4_REGNUM)
              + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
             TYPE_LENGTH (type));
   else if (is_integral_type(type))
     memcpy (valbuf,
-            regbuf + REGISTER_BYTE (28)
+            regbuf + DEPRECATED_REGISTER_BYTE (28)
              + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
             TYPE_LENGTH (type));
   else if (TYPE_LENGTH (type) <= 8)
-    memcpy (valbuf, regbuf + REGISTER_BYTE (28), TYPE_LENGTH (type));
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (28),
+	    TYPE_LENGTH (type));
   else if (TYPE_LENGTH (type) <= 16)
     {
-      memcpy (valbuf, regbuf + REGISTER_BYTE (28), 8);
-      memcpy (valbuf + 8, regbuf + REGISTER_BYTE (29), TYPE_LENGTH (type) - 8);
+      memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (28), 8);
+      memcpy (valbuf + 8, regbuf + DEPRECATED_REGISTER_BYTE (29),
+	      TYPE_LENGTH (type) - 8);
     }
 }
 
@@ -5036,7 +5040,7 @@
      the address size is equal to the size of an int* _on the host_...
      One possible implementation that crossed my mind is to use
      extract_address.  */
-  return (*(int *)(regbuf + REGISTER_BYTE (28)));
+  return (*(int *)(regbuf + DEPRECATED_REGISTER_BYTE (28)));
 }
 
 /* Return True if REGNUM is not a register available to the user
Index: hppab-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppab-nat.c,v
retrieving revision 1.10
diff -u -r1.10 hppab-nat.c
--- hppab-nat.c	14 Sep 2003 16:32:12 -0000	1.10
+++ hppab-nat.c	14 Sep 2003 19:38:49 -0000
@@ -118,7 +118,7 @@
       errno = 0;
       if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
 	{
-	  scratch = *(int *) &deprecated_registers[REGISTER_BYTE (regno)] | 0x3;
+	  scratch = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)] | 0x3;
 	  ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr,
 		  scratch);
 	  if (errno != 0)
@@ -135,7 +135,7 @@
 	    errno = 0;
 	    ptrace (PT_WUREGS, PIDGET (inferior_ptid),
 	            (PTRACE_ARG3_TYPE) regaddr,
-		    *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
+		    *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i]);
 	    if (errno != 0)
 	      {
 		/* Warning, not error, in case we are attached; sometimes the
Index: hppah-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppah-nat.c,v
retrieving revision 1.26
diff -u -r1.26 hppah-nat.c
--- hppah-nat.c	14 Sep 2003 16:32:12 -0000	1.26
+++ hppah-nat.c	14 Sep 2003 19:38:57 -0000
@@ -98,7 +98,7 @@
       /* Floating-point registers come from the ss_fpblock area.  */
       else if (regno >= FP0_REGNUM)
 	addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock) 
-		+ (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
+		+ (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (FP0_REGNUM)));
 
       /* Wide registers come from the ss_wide area.
 	 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
@@ -107,13 +107,13 @@
 	 every register reference.  Bleah.  */
       else if (len == 8)
 	addr = (HPPAH_OFFSETOF (save_state_t, ss_wide) 
-		+ REGISTER_BYTE (regno));
+		+ DEPRECATED_REGISTER_BYTE (regno));
 
       /* Narrow registers come from the ss_narrow area.  Note that
 	 ss_narrow starts with gr1, not gr0.  */
       else if (len == 4)
 	addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
-		+ (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
+		+ (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (1)));
       else
 	internal_error (__FILE__, __LINE__,
 			"hppah-nat.c (write_register): unexpected register size");
@@ -128,7 +128,7 @@
 	{
 	  CORE_ADDR temp;
 
-	  temp = *(CORE_ADDR *)&deprecated_registers[REGISTER_BYTE (regno)];
+	  temp = *(CORE_ADDR *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
 
 	  /* Set the priv level (stored in the low two bits of the PC.  */
 	  temp |= 0x3;
@@ -153,7 +153,7 @@
 	 the high part of IPSW.  What will it take for HP to catch a
 	 clue about building sensible interfaces?  */
      if (regno == IPSW_REGNUM && len == 8)
-	*(int *)&deprecated_registers[REGISTER_BYTE (regno)] = 0;
+	*(int *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)] = 0;
 #endif
 
       for (i = 0; i < len; i += sizeof (int))
@@ -161,7 +161,7 @@
 	  errno = 0;
 	  call_ptrace (PT_WUREGS, PIDGET (inferior_ptid),
 	               (PTRACE_ARG3_TYPE) addr + i,
-		       *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
+		       *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i]);
 	  if (errno != 0)
 	    {
 	      /* Warning, not error, in case we are attached; sometimes
@@ -216,7 +216,7 @@
   /* Floating-point registers come from the ss_fpblock area.  */
   else if (regno >= FP0_REGNUM)
     addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock) 
-	    + (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
+	    + (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (FP0_REGNUM)));
 
   /* Wide registers come from the ss_wide area.
      I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
@@ -225,13 +225,13 @@
      every register reference.  Bleah.  */
   else if (len == 8)
     addr = (HPPAH_OFFSETOF (save_state_t, ss_wide) 
-	    + REGISTER_BYTE (regno));
+	    + DEPRECATED_REGISTER_BYTE (regno));
 
   /* Narrow registers come from the ss_narrow area.  Note that
      ss_narrow starts with gr1, not gr0.  */
   else if (len == 4)
     addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
-	    + (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
+	    + (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (1)));
 
   else
     internal_error (__FILE__, __LINE__,
Index: hppam3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppam3-nat.c,v
retrieving revision 1.6
diff -u -r1.6 hppam3-nat.c
--- hppam3-nat.c	14 Sep 2003 16:32:12 -0000	1.6
+++ hppam3-nat.c	14 Sep 2003 19:38:57 -0000
@@ -113,15 +113,15 @@
    */
   if (regno > 0 && regno < NUM_REGS)
     {
-      memcpy (&state[regno], &deprecated_registers[REGISTER_BYTE (regno)],
+      memcpy (&state[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 	      REGISTER_RAW_SIZE (regno));
     }
   else
     {
       for (index = 0; index < NUM_REGS; index++)
-	memcpy (&state[index], &deprecated_registers[REGISTER_BYTE (index)],
+	memcpy (&state[index], &deprecated_registers[DEPRECATED_REGISTER_BYTE (index)],
 		REGISTER_RAW_SIZE (index));
-/*      state[index] = deprecated_registers[REGISTER_BYTE (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.18
diff -u -r1.18 hpux-thread.c
--- hpux-thread.c	2 Jun 2003 02:09:39 -0000	1.18
+++ hpux-thread.c	14 Sep 2003 19:39:01 -0000
@@ -357,19 +357,19 @@
 	  else if (regno == SP_REGNUM)
 	    {
 	      write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
-			    &deprecated_registers[REGISTER_BYTE (regno)],
+			    &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 			    REGISTER_RAW_SIZE (regno));
 	      tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *)
-		(extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (regno)],
+		(extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 					   REGISTER_RAW_SIZE (regno)) + 160);
 	    }
 	  else if (regno == PC_REGNUM)
 	    write_memory (sp - 20,
-			  &deprecated_registers[REGISTER_BYTE (regno)],
+			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 			  REGISTER_RAW_SIZE (regno));
 	  else
 	    write_memory (sp + regmap[regno],
-			  &deprecated_registers[REGISTER_BYTE (regno)],
+			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 			  REGISTER_RAW_SIZE (regno));
 	}
     }
Index: i386gnu-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386gnu-nat.c,v
retrieving revision 1.14
diff -u -r1.14 i386gnu-nat.c
--- i386gnu-nat.c	23 Aug 2003 08:56:45 -0000	1.14
+++ i386gnu-nat.c	14 Sep 2003 19:39:01 -0000
@@ -256,7 +256,7 @@
 	}
 
 #define fill(state, regno)                                               \
-  memcpy (REG_ADDR(state, regno), &deprecated_registers[REGISTER_BYTE (regno)],     \
+  memcpy (REG_ADDR(state, regno), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],     \
           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.5
diff -u -r1.5 ia64-aix-nat.c
--- ia64-aix-nat.c	14 Sep 2003 16:32:13 -0000	1.5
+++ ia64-aix-nat.c	14 Sep 2003 19:39:01 -0000
@@ -85,7 +85,7 @@
 
 #define COPY_REG(_fld_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
-    memcpy (&(gregsetp->_fld_), &deprecated_registers[REGISTER_BYTE (_regi_)], \
+    memcpy (&(gregsetp->_fld_), &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \
 	    REGISTER_RAW_SIZE (_regi_))
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@@ -108,10 +108,10 @@
   if (regno == IA64_BSP_REGNUM || regno == -1)
     {
       memcpy (&(gregsetp->__bspstore),
-	      &deprecated_registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
+	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
 	      REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
-      memcpy (&deprecated_registers[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
-	      &deprecated_registers[REGISTER_BYTE (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));
     }
 
@@ -153,7 +153,7 @@
     {
       if ((regno == -1) || (regno == regi))
 	{
-	  from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]);
 	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
 	}
Index: ia64-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-linux-nat.c,v
retrieving revision 1.18
diff -u -r1.18 ia64-linux-nat.c
--- ia64-linux-nat.c	14 Sep 2003 16:32:13 -0000	1.18
+++ ia64-linux-nat.c	14 Sep 2003 19:39:04 -0000
@@ -402,7 +402,7 @@
 
 #define COPY_REG(_idx_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
-    memcpy (regp + _idx_, &deprecated_registers[REGISTER_BYTE (_regi_)], \
+    memcpy (regp + _idx_, &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \
 	    REGISTER_RAW_SIZE (_regi_))
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@@ -467,7 +467,7 @@
     {
       if ((regno == -1) || (regno == regi))
 	{
-	  from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 	  to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
 	  memcpy (to, from, REGISTER_RAW_SIZE (regi));
 	}
Index: irix5-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/irix5-nat.c,v
retrieving revision 1.24
diff -u -r1.24 irix5-nat.c
--- irix5-nat.c	14 Sep 2003 16:32:13 -0000	1.24
+++ irix5-nat.c	14 Sep 2003 19:39:04 -0000
@@ -83,27 +83,27 @@
   for (regi = 0; regi <= CTX_RA; regi++)
     if ((regno == -1) || (regno == regi))
       *(regp + regi) =
-	extract_signed_integer (&deprecated_registers[REGISTER_BYTE (regi)],
+	extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)],
 				REGISTER_RAW_SIZE (regi));
 
   if ((regno == -1) || (regno == PC_REGNUM))
     *(regp + CTX_EPC) =
-      extract_signed_integer (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
+      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)],
 			      REGISTER_RAW_SIZE (PC_REGNUM));
 
   if ((regno == -1) || (regno == CAUSE_REGNUM))
     *(regp + CTX_CAUSE) =
-      extract_signed_integer (&deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)],
+      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (CAUSE_REGNUM)],
 			      REGISTER_RAW_SIZE (CAUSE_REGNUM));
 
   if ((regno == -1) || (regno == HI_REGNUM))
     *(regp + CTX_MDHI) =
-      extract_signed_integer (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
+      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)],
 			      REGISTER_RAW_SIZE (HI_REGNUM));
 
   if ((regno == -1) || (regno == LO_REGNUM))
     *(regp + CTX_MDLO) =
-      extract_signed_integer (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
+      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)],
 			      REGISTER_RAW_SIZE (LO_REGNUM));
 }
 
@@ -145,14 +145,14 @@
     {
       if ((regno == -1) || (regno == regi))
 	{
-	  from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+	  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));
 	}
     }
 
   if ((regno == -1) || (regno == FCRCS_REGNUM))
-    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
+    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)];
 }
 
 
Index: lynx-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/lynx-nat.c,v
retrieving revision 1.14
diff -u -r1.14 lynx-nat.c
--- lynx-nat.c	8 May 2003 22:33:14 -0000	1.14
+++ lynx-nat.c	14 Sep 2003 19:39:07 -0000
@@ -297,7 +297,7 @@
       supply_register (G0_REGNUM, buf);
       supply_register (TBR_REGNUM, (char *) &ec.tbr);
 
-      memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &ec.g1,
 	      4 * REGISTER_RAW_SIZE (G1_REGNUM));
       for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
 	deprecated_register_valid[i] = 1;
@@ -308,7 +308,7 @@
       supply_register (NPC_REGNUM, (char *) &ec.npc);
       supply_register (WIM_REGNUM, (char *) &ec.wim);
 
-      memcpy (&deprecated_registers[REGISTER_BYTE (O0_REGNUM)], ec.o,
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)], ec.o,
 	      8 * REGISTER_RAW_SIZE (O0_REGNUM));
       for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
 	deprecated_register_valid[i] = 1;
@@ -322,13 +322,13 @@
       sp = read_register (SP_REGNUM);
 
       target_read_memory (sp + FRAME_SAVED_I0,
-			  &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
+			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)],
 			  8 * 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[REGISTER_BYTE (L0_REGNUM)],
+			  &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 			  8 * REGISTER_RAW_SIZE (L0_REGNUM));
       for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
 	deprecated_register_valid[i] = 1;
@@ -346,7 +346,7 @@
       if (errno)
 	perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 
-      memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
 	      32 * REGISTER_RAW_SIZE (FP0_REGNUM));
       for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
 	deprecated_register_valid[i] = 1;
@@ -384,7 +384,7 @@
       int retval;
 
       ec.tbr = read_register (TBR_REGNUM);
-      memcpy (&ec.g1, &deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
+      memcpy (&ec.g1, &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
 	      4 * REGISTER_RAW_SIZE (G1_REGNUM));
 
       ec.psr = read_register (PS_REGNUM);
@@ -393,7 +393,7 @@
       ec.npc = read_register (NPC_REGNUM);
       ec.wim = read_register (WIM_REGNUM);
 
-      memcpy (ec.o, &deprecated_registers[REGISTER_BYTE (O0_REGNUM)],
+      memcpy (ec.o, &deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)],
 	      8 * REGISTER_RAW_SIZE (O0_REGNUM));
 
       errno = 0;
@@ -415,11 +415,11 @@
 	  if (!deprecated_register_valid[L0_REGNUM + 5])
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  target_write_memory (sp + FRAME_SAVED_I0,
-			      &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
+			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)],
 			      8 * REGISTER_RAW_SIZE (I0_REGNUM));
 
 	  target_write_memory (sp + FRAME_SAVED_L0,
-			      &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 			      8 * REGISTER_RAW_SIZE (L0_REGNUM));
 	}
       else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
@@ -427,13 +427,13 @@
 	  if (!deprecated_register_valid[regno])
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  if (regno >= L0_REGNUM && regno <= L0_REGNUM + 7)
-	    regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM)
+	    regoffset = DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM)
 	      + FRAME_SAVED_L0;
 	  else
-	    regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM)
+	    regoffset = DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (I0_REGNUM)
 	      + FRAME_SAVED_I0;
 	  target_write_memory (sp + regoffset, 
-			      &deprecated_registers[REGISTER_BYTE (regno)],
+			      &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 			      REGISTER_RAW_SIZE (regno));
 	}
     }
@@ -450,7 +450,7 @@
       if (errno)
 	perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 
-      memcpy (fc.f.fregs, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      memcpy (fc.f.fregs, &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	      32 * REGISTER_RAW_SIZE (FP0_REGNUM));
 
       fc.fsr = read_register (FPS_REGNUM);
@@ -574,7 +574,7 @@
 	{
 	  unsigned int reg;
 
-	  reg = *(unsigned int *) &deprecated_registers[REGISTER_BYTE (regno) + i];
+	  reg = *(unsigned int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i];
 
 	  errno = 0;
 	  ptrace (ptrace_fun, PIDGET (inferior_ptid),
Index: m68knbsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/m68knbsd-nat.c,v
retrieving revision 1.9
diff -u -r1.9 m68knbsd-nat.c
--- m68knbsd-nat.c	14 Nov 2002 20:37:28 -0000	1.9
+++ m68knbsd-nat.c	14 Sep 2003 19:39:07 -0000
@@ -36,12 +36,12 @@
 
   ptrace (PT_GETREGS, PIDGET (inferior_ptid),
 	  (PTRACE_ARG3_TYPE) & inferior_registers, 0);
-  memcpy (&deprecated_registers[REGISTER_BYTE (0)], &inferior_registers,
+  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (0)], &inferior_registers,
 	  sizeof (inferior_registers));
 
   ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
 	  (PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
-  memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
 	  sizeof (inferior_fp_registers));
 
   deprecated_registers_fetched ();
@@ -53,12 +53,12 @@
   struct reg inferior_registers;
   struct fpreg inferior_fp_registers;
 
-  memcpy (&inferior_registers, &deprecated_registers[REGISTER_BYTE (0)],
+  memcpy (&inferior_registers, &deprecated_registers[DEPRECATED_REGISTER_BYTE (0)],
 	  sizeof (inferior_registers));
   ptrace (PT_SETREGS, PIDGET (inferior_ptid),
 	  (PTRACE_ARG3_TYPE) & inferior_registers, 0);
 
-  memcpy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+  memcpy (&inferior_fp_registers, &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	  sizeof (inferior_fp_registers));
   ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
 	  (PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
@@ -77,10 +77,10 @@
   struct md_core *core_reg = (struct md_core *) core_reg_sect;
 
   /* Integer registers */
-  memcpy (&deprecated_registers[REGISTER_BYTE (0)],
+  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (0)],
 	  &core_reg->intreg, sizeof (struct reg));
   /* Floating point registers */
-  memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	  &core_reg->freg, sizeof (struct fpreg));
 }
 
Index: mcore-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mcore-tdep.c,v
retrieving revision 1.75
diff -u -r1.75 mcore-tdep.c
--- mcore-tdep.c	13 Sep 2003 23:25:41 -0000	1.75
+++ mcore-tdep.c	14 Sep 2003 19:39:09 -0000
@@ -952,7 +952,7 @@
 static CORE_ADDR
 mcore_extract_struct_value_address (char *regbuf)
 {
-  return extract_unsigned_integer (regbuf + REGISTER_BYTE (FIRST_ARGREG), DEPRECATED_REGISTER_SIZE);
+  return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (FIRST_ARGREG), DEPRECATED_REGISTER_SIZE);
 }
 
 /* Given a function which returns a value of type TYPE, extract the
@@ -965,7 +965,7 @@
   /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */
   /* Only getting the first byte! if len = 1, we need the last byte of
      the register, not the first. */
-  memcpy (valbuf, regbuf + REGISTER_BYTE (RETVAL_REGNUM) +
+  memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) +
   (TYPE_LENGTH (type) < 4 ? 4 - TYPE_LENGTH (type) : 0), TYPE_LENGTH (type));
 }
 
@@ -991,11 +991,11 @@
 
   /* Return value fits into registers. */
   return_size = (value_size + DEPRECATED_REGISTER_SIZE - 1) & ~(DEPRECATED_REGISTER_SIZE - 1);
-  offset = REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
+  offset = DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
   zeros = alloca (return_size);
   memset (zeros, 0, return_size);
 
-  deprecated_write_register_bytes (REGISTER_BYTE (RETVAL_REGNUM), zeros,
+  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM), zeros,
 				   return_size);
   deprecated_write_register_bytes (offset, valbuf, value_size);
 }
Index: mips-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-linux-tdep.c,v
retrieving revision 1.13
diff -u -r1.13 mips-linux-tdep.c
--- mips-linux-tdep.c	14 Sep 2003 16:32:13 -0000	1.13
+++ mips-linux-tdep.c	14 Sep 2003 19:39:09 -0000
@@ -216,13 +216,13 @@
 
   if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
     {
-      from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
+      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + regno - FP0_REGNUM);
       memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
     }
   else if (regno == FCRCS_REGNUM)
     {
-      from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
+      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + 32);
       memcpy (to, from, REGISTER_RAW_SIZE (regno));
     }
@@ -491,13 +491,13 @@
 
   if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
     {
-      from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
+      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + regno - FP0_REGNUM);
       memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
     }
   else if (regno == FCRCS_REGNUM)
     {
-      from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
+      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + 32);
       memcpy (to, from, REGISTER_RAW_SIZE (regno));
     }
Index: mips-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-tdep.c,v
retrieving revision 1.231
diff -u -r1.231 mips-tdep.c
--- mips-tdep.c	14 Sep 2003 16:32:13 -0000	1.231
+++ mips-tdep.c	14 Sep 2003 19:39:19 -0000
@@ -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 REGISTER_BYTE.  */
+	 combination of 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
@@ -4742,12 +4742,12 @@
   return_value_location (valtype, &hi, &lo);
 
   memcpy (valbuf + lo.buf_offset,
-	  regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
+	  regbuf + DEPRECATED_REGISTER_BYTE (lo.reg) + lo.reg_offset,
 	  lo.len);
 
   if (hi.len > 0)
     memcpy (valbuf + hi.buf_offset,
-	    regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
+	    regbuf + DEPRECATED_REGISTER_BYTE (hi.reg) + hi.reg_offset,
 	    hi.len);
 }
 
@@ -4761,12 +4761,12 @@
   return_value_location (valtype, &hi, &lo);
 
   memcpy (valbuf + lo.buf_offset,
-	  regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
+	  regbuf + DEPRECATED_REGISTER_BYTE (lo.reg) + lo.reg_offset,
 	  lo.len);
 
   if (hi.len > 0)
     memcpy (valbuf + hi.buf_offset,
-	    regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
+	    regbuf + DEPRECATED_REGISTER_BYTE (hi.reg) + hi.reg_offset,
 	    hi.len);
 }
 
@@ -4783,14 +4783,14 @@
 
   memset (raw_buffer, 0, sizeof (raw_buffer));
   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
-  deprecated_write_register_bytes (REGISTER_BYTE (lo.reg), raw_buffer,
+  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer,
 				   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 (REGISTER_BYTE (hi.reg), raw_buffer,
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer,
 				       REGISTER_RAW_SIZE (hi.reg));
     }
 }
@@ -4805,14 +4805,14 @@
 
   memset (raw_buffer, 0, sizeof (raw_buffer));
   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
-  deprecated_write_register_bytes (REGISTER_BYTE (lo.reg), raw_buffer,
+  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer,
 				   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 (REGISTER_BYTE (hi.reg), raw_buffer,
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer,
 				       REGISTER_RAW_SIZE (hi.reg));
     }
 }
Index: mipsv4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsv4-nat.c,v
retrieving revision 1.12
diff -u -r1.12 mipsv4-nat.c
--- mipsv4-nat.c	14 Sep 2003 16:32:13 -0000	1.12
+++ mipsv4-nat.c	14 Sep 2003 19:39:19 -0000
@@ -75,19 +75,19 @@
 
   for (regi = 0; regi <= 32; regi++)
     if ((regno == -1) || (regno == regi))
-      *(regp + regi) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (regi)];
+      *(regp + regi) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 
   if ((regno == -1) || (regno == PC_REGNUM))
-    *(regp + CXT_EPC) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
+    *(regp + CXT_EPC) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)];
 
   if ((regno == -1) || (regno == CAUSE_REGNUM))
-    *(regp + CXT_CAUSE) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)];
+    *(regp + CXT_CAUSE) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (CAUSE_REGNUM)];
 
   if ((regno == -1) || (regno == HI_REGNUM))
-    *(regp + CXT_MDHI) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (HI_REGNUM)];
+    *(regp + CXT_MDHI) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)];
 
   if ((regno == -1) || (regno == LO_REGNUM))
-    *(regp + CXT_MDLO) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (LO_REGNUM)];
+    *(regp + CXT_MDLO) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)];
 }
 
 /*
@@ -125,14 +125,14 @@
     {
       if ((regno == -1) || (regno == regi))
 	{
-	  from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+	  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));
 	}
     }
 
   if ((regno == -1) || (regno == FCRCS_REGNUM))
-    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
+    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)];
 }
 
 
Index: mn10300-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mn10300-tdep.c,v
retrieving revision 1.88
diff -u -r1.88 mn10300-tdep.c
--- mn10300-tdep.c	13 Sep 2003 23:25:41 -0000	1.88
+++ mn10300-tdep.c	14 Sep 2003 19:39:25 -0000
@@ -125,15 +125,15 @@
 mn10300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 {
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
-    memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (4), TYPE_LENGTH (type));
   else
-    memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
+    memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (type));
 }
 
 static CORE_ADDR
 mn10300_extract_struct_value_address (char *regbuf)
 {
-  return extract_unsigned_integer (regbuf + REGISTER_BYTE (4),
+  return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (4),
 				   REGISTER_RAW_SIZE (4));
 }
 
@@ -141,10 +141,10 @@
 mn10300_store_return_value (struct type *type, char *valbuf)
 {
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
-    deprecated_write_register_bytes (REGISTER_BYTE (4), valbuf,
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (4), valbuf,
 				     TYPE_LENGTH (type));
   else
-    deprecated_write_register_bytes (REGISTER_BYTE (0), valbuf,
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (0), valbuf,
 				     TYPE_LENGTH (type));
 }
 
Index: ns32k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ns32k-tdep.c,v
retrieving revision 1.58
diff -u -r1.58 ns32k-tdep.c
--- ns32k-tdep.c	14 Sep 2003 16:32:13 -0000	1.58
+++ ns32k-tdep.c	14 Sep 2003 19:39:25 -0000
@@ -483,7 +483,7 @@
 ns32k_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 {
   memcpy (valbuf,
-          regbuf + REGISTER_BYTE (TYPE_CODE (valtype) == TYPE_CODE_FLT ?
+          regbuf + DEPRECATED_REGISTER_BYTE (TYPE_CODE (valtype) == TYPE_CODE_FLT ?
 				  FP0_REGNUM : 0), TYPE_LENGTH (valtype));
 }
 
@@ -498,7 +498,7 @@
 static CORE_ADDR
 ns32k_extract_struct_value_address (char *regbuf)
 {
-  return (extract_unsigned_integer (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
+  return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
 }
 
 void
Index: ns32knbsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ns32knbsd-nat.c,v
retrieving revision 1.11
diff -u -r1.11 ns32knbsd-nat.c
--- ns32knbsd-nat.c	29 Apr 2003 01:49:47 -0000	1.11
+++ ns32knbsd-nat.c	14 Sep 2003 19:39:25 -0000
@@ -32,10 +32,10 @@
 #include "regcache.h"
 
 #define RF(dst, src) \
-	memcpy(&deprecated_registers[REGISTER_BYTE(dst)], &src, sizeof(src))
+	memcpy(&deprecated_registers[DEPRECATED_REGISTER_BYTE(dst)], &src, sizeof(src))
 
 #define RS(src, dst) \
-	memcpy(&dst, &deprecated_registers[REGISTER_BYTE(src)], sizeof(dst))
+	memcpy(&dst, &deprecated_registers[DEPRECATED_REGISTER_BYTE(src)], sizeof(dst))
 
 void
 fetch_inferior_registers (int regno)
Index: ppc-bdm.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-bdm.c,v
retrieving revision 1.17
diff -u -r1.17 ppc-bdm.c
--- ppc-bdm.c	11 Jun 2003 13:16:28 -0000	1.17
+++ ppc-bdm.c	14 Sep 2003 19:39:28 -0000
@@ -295,7 +295,7 @@
           && ((i < FP0_REGNUM) || (i > FPLAST_REGNUM)))
 	{
 /*          printf("write valid reg %d\n", bdm_regno); */
-	  ocd_write_bdm_registers (bdm_regno, deprecated_registers + REGISTER_BYTE (i), 4);
+	  ocd_write_bdm_registers (bdm_regno, deprecated_registers + DEPRECATED_REGISTER_BYTE (i), 4);
 	}
 /*
    else if (i == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.97
diff -u -r1.97 regcache.c
--- regcache.c	29 Aug 2003 13:04:44 -0000	1.97
+++ regcache.c	14 Sep 2003 19:39:29 -0000
@@ -93,12 +93,13 @@
   gdb_assert (gdbarch != NULL);
 
   /* Compute the offset of each register.  Legacy architectures define
-     REGISTER_BYTE() so use that.  */
-  /* FIXME: cagney/2002-11-07: Instead of using REGISTER_BYTE() this
-     code should, as is done in init_regcache_descr(), compute the
-     offets at runtime.  This currently isn't possible as some ISAs
-     define overlapping register regions - see the mess in
-     read_register_bytes() and write_register_bytes() registers.  */
+     DEPRECATED_REGISTER_BYTE() so use that.  */
+  /* FIXME: cagney/2002-11-07: Instead of using
+     DEPRECATED_REGISTER_BYTE() this code should, as is done in
+     init_regcache_descr(), compute the offets at runtime.  This
+     currently isn't possible as some ISAs define overlapping register
+     regions - see the mess in read_register_bytes() and
+     write_register_bytes() registers.  */
   descr->sizeof_register
     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
   descr->register_offset
@@ -106,11 +107,11 @@
   for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       /* FIXME: cagney/2001-12-04: This code shouldn't need to use
-         REGISTER_BYTE().  Unfortunatly, legacy code likes to lay the
-         buffer out so that certain registers just happen to overlap.
-         Ulgh!  New targets use gdbarch's register read/write and
-         entirely avoid this uglyness.  */
-      descr->register_offset[i] = REGISTER_BYTE (i);
+         DEPRECATED_REGISTER_BYTE().  Unfortunatly, legacy code likes
+         to lay the buffer out so that certain registers just happen
+         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));
       gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
@@ -130,8 +131,8 @@
       /* Keep extending the buffer so that there is always enough
          space for all registers.  The comparison is necessary since
          legacy code is free to put registers in random places in the
-         buffer separated by holes.  Once REGISTER_BYTE() is killed
-         this can be greatly simplified.  */
+         buffer separated by holes.  Once DEPRECATED_REGISTER_BYTE()
+         is killed this can be greatly simplified.  */
       regend = descr->register_offset[i] + descr->sizeof_register[i];
       if (descr->sizeof_cooked_registers < regend)
 	descr->sizeof_cooked_registers = regend;
@@ -185,16 +186,17 @@
 
   /* 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 REGISTER_BYTE or
+  /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or
      REGISTER_RAW_SIZE are still present, things are most likely
      totally screwed.  Ex: an architecture with raw register sizes
-     smaller than what REGISTER_BYTE indicates; non monotonic
-     REGISTER_BYTE values.  For GDB 6 check for these nasty methods
-     and fall back to legacy code when present.  Sigh!  */
+     smaller than what DEPRECATED_REGISTER_BYTE indicates; non
+     monotonic DEPRECATED_REGISTER_BYTE values.  For GDB 6 check for
+     these nasty methods and fall back to legacy code when present.
+     Sigh!  */
   if ((!gdbarch_pseudo_register_read_p (gdbarch)
        && !gdbarch_pseudo_register_write_p (gdbarch)
        && !gdbarch_register_type_p (gdbarch))
-      || REGISTER_BYTE_P () || REGISTER_RAW_SIZE_P ())
+      || DEPRECATED_REGISTER_BYTE_P () || REGISTER_RAW_SIZE_P ())
     {
       descr->legacy_p = 1;
       init_legacy_regcache_descr (gdbarch, descr);
@@ -233,12 +235,12 @@
   descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
 
   /* Sanity check.  Confirm that there is agreement between the
-     regcache and the target's redundant REGISTER_BYTE (new targets
-     should not even be defining it).  */
+     regcache and the target's redundant DEPRECATED_REGISTER_BYTE (new
+     targets should not even be defining it).  */
   for (i = 0; i < descr->nr_cooked_registers; i++)
     {
-      if (REGISTER_BYTE_P ())
-	gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
+      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] == REGISTER_VIRTUAL_SIZE (i));
@@ -650,7 +652,7 @@
       int end;
       int byte;
 
-      reg_start = REGISTER_BYTE (regnum);
+      reg_start = DEPRECATED_REGISTER_BYTE (regnum);
       reg_len = REGISTER_RAW_SIZE (regnum);
       reg_end = reg_start + reg_len;
 
@@ -1012,7 +1014,7 @@
     {
       int regstart, regend;
 
-      regstart = REGISTER_BYTE (regnum);
+      regstart = DEPRECATED_REGISTER_BYTE (regnum);
       regend = regstart + REGISTER_RAW_SIZE (regnum);
 
       /* Is this register completely outside the range the user is writing?  */
@@ -1517,7 +1519,7 @@
 	  fprintf_unfiltered (file, " %6ld",
 			      regcache->descr->register_offset[regnum]);
 	  if (register_offset != regcache->descr->register_offset[regnum]
-	      || register_offset != REGISTER_BYTE (regnum)
+	      || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
 	      || (regnum > 0
 		  && (regcache->descr->register_offset[regnum]
 		      != (regcache->descr->register_offset[regnum - 1]
Index: remote-sds.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sds.c,v
retrieving revision 1.25
diff -u -r1.25 remote-sds.c
--- remote-sds.c	17 May 2003 05:59:58 -0000	1.25
+++ remote-sds.c	14 Sep 2003 19:39:33 -0000
@@ -499,7 +499,7 @@
   /* (should warn about reply too short) */
 
   for (i = 0; i < NUM_REGS; i++)
-    supply_register (i, &regs[REGISTER_BYTE (i)]);
+    supply_register (i, &regs[DEPRECATED_REGISTER_BYTE (i)]);
 }
 
 /* Prepare to store registers.  Since we may send them all, we have to
Index: remote-vx68.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vx68.c,v
retrieving revision 1.9
diff -u -r1.9 remote-vx68.c
--- remote-vx68.c	14 Nov 2002 20:37:29 -0000	1.9
+++ remote-vx68.c	14 Sep 2003 19:39:33 -0000
@@ -88,10 +88,10 @@
   bcopy (&mc68k_greg_packet[MC68K_R_D0], deprecated_registers,
 	 16 * MC68K_GREG_SIZE);
   bcopy (&mc68k_greg_packet[MC68K_R_SR],
-	 &deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)],
 	 MC68K_GREG_SIZE);
   bcopy (&mc68k_greg_packet[MC68K_R_PC],
-	 &deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)],
 	 MC68K_GREG_SIZE);
 
   /* Get floating-point registers, if the target system has them.
@@ -103,17 +103,17 @@
 			  PTRACE_GETFPREGS);
 
       bcopy (&mc68k_fpreg_packet[MC68K_R_FP0],
-	     &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     MC68K_FPREG_SIZE * 8);
       bcopy (&mc68k_fpreg_packet[MC68K_R_FPCR],
-	     &deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 	     MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
     }
   else
     {
-      bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bzero (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     MC68K_FPREG_SIZE * 8);
-      bzero (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+      bzero (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 	     MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
     }
 
@@ -136,9 +136,9 @@
 
   bcopy (deprecated_registers, &mc68k_greg_packet[MC68K_R_D0],
 	 16 * MC68K_GREG_SIZE);
-  bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)],
 	 &mc68k_greg_packet[MC68K_R_SR], MC68K_GREG_SIZE);
-  bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)],
 	 &mc68k_greg_packet[MC68K_R_PC], MC68K_GREG_SIZE);
 
   net_write_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_SETREGS);
@@ -147,10 +147,10 @@
 
   if (target_has_fp)
     {
-      bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     &mc68k_fpreg_packet[MC68K_R_FP0],
 	     MC68K_FPREG_SIZE * 8);
-      bcopy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 	     &mc68k_fpreg_packet[MC68K_R_FPCR],
 	     MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
 
Index: remote-vxmips.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxmips.c,v
retrieving revision 1.9
diff -u -r1.9 remote-vxmips.c
--- remote-vxmips.c	14 Nov 2002 20:37:29 -0000	1.9
+++ remote-vxmips.c	14 Sep 2003 19:39:33 -0000
@@ -109,13 +109,13 @@
   /* Copy SR, LO, HI, and PC.  */
 
   bcopy (&mips_greg_packet[MIPS_R_SR],
-	 &deprecated_registers[REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE);
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE);
   bcopy (&mips_greg_packet[MIPS_R_LO],
-	 &deprecated_registers[REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE);
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE);
   bcopy (&mips_greg_packet[MIPS_R_HI],
-	 &deprecated_registers[REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE);
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE);
   bcopy (&mips_greg_packet[MIPS_R_PC],
-	 &deprecated_registers[REGISTER_BYTE (PC_REGNUM)], MIPS_GREG_SIZE);
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)], MIPS_GREG_SIZE);
 
   /* If the target has floating point registers, fetch them.
      Otherwise, zero the floating point register values in
@@ -130,20 +130,20 @@
       /* Copy the floating point registers.  */
 
       bcopy (&mips_fpreg_packet[MIPS_R_FP0],
-	     &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
 
       /* Copy the floating point control/status register (fpcsr).  */
 
       bcopy (&mips_fpreg_packet[MIPS_R_FPCSR],
-	     &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
 	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
     }
   else
     {
-      bzero ((char *) &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bzero ((char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
-      bzero ((char *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
+      bzero ((char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
 	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
     }
 
@@ -168,13 +168,13 @@
 
   /* Copy SR, LO, HI, and PC.  */
 
-  bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)],
 	 &mips_greg_packet[MIPS_R_SR], MIPS_GREG_SIZE);
-  bcopy (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)],
 	 &mips_greg_packet[MIPS_R_LO], MIPS_GREG_SIZE);
-  bcopy (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)],
 	 &mips_greg_packet[MIPS_R_HI], MIPS_GREG_SIZE);
-  bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
+  bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)],
 	 &mips_greg_packet[MIPS_R_PC], MIPS_GREG_SIZE);
 
   net_write_registers (mips_greg_packet, MIPS_GREG_PLEN, PTRACE_SETREGS);
@@ -185,13 +185,13 @@
     {
       /* Copy the floating point data registers.  */
 
-      bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     &mips_fpreg_packet[MIPS_R_FP0],
 	     REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
 
       /* Copy the floating point control/status register (fpcsr).  */
 
-      bcopy (&deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
 	     &mips_fpreg_packet[MIPS_R_FPCSR],
 	     REGISTER_RAW_SIZE (FCRCS_REGNUM));
 
Index: remote-vxsparc.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxsparc.c,v
retrieving revision 1.12
diff -u -r1.12 remote-vxsparc.c
--- remote-vxsparc.c	2 Jun 2003 02:09:39 -0000	1.12
+++ remote-vxsparc.c	14 Sep 2003 19:39:33 -0000
@@ -92,18 +92,18 @@
      as defined in "tm-sparc.h".  */
 
   bcopy (&sparc_greg_packet[SPARC_R_G0],
-	 &deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (G0_REGNUM)],
 	 32 * SPARC_GREG_SIZE);
   bcopy (&sparc_greg_packet[SPARC_R_Y],
-	 &deprecated_registers[REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);
+	 &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);
 
   /* Now write the local and in registers to the register window spill
      area in the frame.  VxWorks does not do this for the active frame
      automatically; it greatly simplifies debugging.  */
 
-  sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
+  sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)],
 				 REGISTER_RAW_SIZE (SP_REGNUM));
-  write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+  write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 		16 * REGISTER_RAW_SIZE (L0_REGNUM));
 
   /* If the target has floating point registers, fetch them.
@@ -116,17 +116,17 @@
       net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
 			  PTRACE_GETFPREGS);
       bcopy (&sparc_fpreg_packet[SPARC_R_FP0],
-	     &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     32 * SPARC_FPREG_SIZE);
       bcopy (&sparc_fpreg_packet[SPARC_R_FSR],
-	     &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+	     &deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 	     1 * SPARC_FPREG_SIZE);
     }
   else
     {
-      bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bzero (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     32 * SPARC_FPREG_SIZE);
-      bzero (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+      bzero (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 	     1 * SPARC_FPREG_SIZE);
     }
 
@@ -164,9 +164,9 @@
     }
   if (in_gp_regs)
     {
-      bcopy (&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G0_REGNUM)],
 	     &sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE);
-      bcopy (&deprecated_registers[REGISTER_BYTE (Y_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)],
 	     &sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE);
 
       net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS);
@@ -176,9 +176,9 @@
 
       if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM))
 	{
-	  sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
+	  sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)],
 					 REGISTER_RAW_SIZE (SP_REGNUM));
-	  write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+	  write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 			16 * REGISTER_RAW_SIZE (L0_REGNUM));
 	}
     }
@@ -187,9 +187,9 @@
 
   if (in_fp_regs && target_has_fp)
     {
-      bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	     &sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE);
-      bcopy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+      bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 	     &sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE);
 
       net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
Index: remote.c
===================================================================
RCS file: /cvs/src/src/gdb/remote.c,v
retrieving revision 1.113
diff -u -r1.113 remote.c
--- remote.c	4 Aug 2003 22:24:44 -0000	1.113
+++ remote.c	14 Sep 2003 19:39:46 -0000
@@ -271,7 +271,7 @@
       struct packet_reg *r = &rs->regs[regnum];
       r->pnum = regnum;
       r->regnum = regnum;
-      r->offset = REGISTER_BYTE (regnum);
+      r->offset = DEPRECATED_REGISTER_BYTE (regnum);
       r->in_g_packet = (regnum < NUM_REGS);
       /* ...name = REGISTER_NAME (regnum); */
 
Index: rs6000-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
retrieving revision 1.158
diff -u -r1.158 rs6000-tdep.c
--- rs6000-tdep.c	14 Sep 2003 16:32:14 -0000	1.158
+++ rs6000-tdep.c	14 Sep 2003 19:39:47 -0000
@@ -1054,7 +1054,7 @@
       addr = prev_sp + fdata.gpr_offset;
       for (ii = fdata.saved_gpr; ii <= 31; ++ii)
 	{
-	  read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii)],
+	  read_memory (addr, &deprecated_registers[DEPRECATED_REGISTER_BYTE (ii)],
 		       wordsize);
 	  addr += wordsize;
 	}
@@ -1065,7 +1065,7 @@
       addr = prev_sp + fdata.fpr_offset;
       for (ii = fdata.saved_fpr; ii <= 31; ++ii)
 	{
-	  read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
+	  read_memory (addr, &deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + FP0_REGNUM)], 8);
 	  addr += 8;
 	}
     }
@@ -1171,7 +1171,7 @@
 	    printf_unfiltered (
 				"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 
-	  memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
 		  VALUE_CONTENTS (arg),
 		  len);
 	  ++f_argno;
@@ -1183,9 +1183,9 @@
 	  /* Argument takes more than one register.  */
 	  while (argbytes < len)
 	    {
-	      memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0,
+	      memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)], 0,
 		      reg_size);
-	      memcpy (&deprecated_registers[REGISTER_BYTE (ii + 3)],
+	      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)],
 		      ((char *) VALUE_CONTENTS (arg)) + argbytes,
 		      (len - argbytes) > reg_size
 		        ? reg_size : len - argbytes);
@@ -1201,8 +1201,8 @@
 	{
 	  /* Argument can fit in one register.  No problem.  */
 	  int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
-	  memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
-	  memcpy ((char *)&deprecated_registers[REGISTER_BYTE (ii + 3)] + adj, 
+	  memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)], 0, reg_size);
+	  memcpy ((char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)] + adj, 
 	          VALUE_CONTENTS (arg), len);
 	}
       ++argno;
@@ -1276,7 +1276,7 @@
 		printf_unfiltered (
 				    "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 
-	      memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+	      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
 		      VALUE_CONTENTS (arg),
 		      len);
 	      ++f_argno;
@@ -1389,11 +1389,11 @@
 
       if (TYPE_LENGTH (valtype) > 4)	/* this is a double */
 	memcpy (valbuf,
-		&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)],
+		&regbuf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1)],
 		TYPE_LENGTH (valtype));
       else
 	{			/* float */
-	  memcpy (&dd, &regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], 8);
+	  memcpy (&dd, &regbuf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1)], 8);
 	  ff = (float) dd;
 	  memcpy (valbuf, &ff, sizeof (float));
 	}
@@ -1402,7 +1402,7 @@
            && TYPE_LENGTH (valtype) == 16
            && TYPE_VECTOR (valtype))
     {
-      memcpy (valbuf, regbuf + REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
+      memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
 	      TYPE_LENGTH (valtype));
     }
   else
@@ -1413,7 +1413,7 @@
 	offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
 
       memcpy (valbuf,
-	      regbuf + REGISTER_BYTE (3) + offset,
+	      regbuf + DEPRECATED_REGISTER_BYTE (3) + offset,
 	      TYPE_LENGTH (valtype));
     }
 }
@@ -2069,18 +2069,18 @@
        Say a double_double_double type could be returned in
        FPR1/FPR2/FPR3 triple.  */
 
-    deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM + 1), valbuf,
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1), valbuf,
 				     TYPE_LENGTH (type));
   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
     {
       if (TYPE_LENGTH (type) == 16
           && TYPE_VECTOR (type))
-	deprecated_write_register_bytes (REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
+	deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
 					 valbuf, TYPE_LENGTH (type));
     }
   else
     /* Everything else is returned in GPR3 and up.  */
-    deprecated_write_register_bytes (REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
 				     valbuf, TYPE_LENGTH (type));
 }
 
Index: s390-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/s390-tdep.c,v
retrieving revision 1.112
diff -u -r1.112 s390-tdep.c
--- s390-tdep.c	9 Sep 2003 04:41:32 -0000	1.112
+++ s390-tdep.c	14 Sep 2003 19:39:49 -0000
@@ -903,7 +903,7 @@
       /* We're definitely backtracing from a signal handler.  */
       CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
       CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
-                                 + REGISTER_BYTE (S390_GP0_REGNUM));
+                                 + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM));
       int reg;
 
       for (reg = 0; reg < S390_NUM_GPRS; reg++)
@@ -1833,7 +1833,7 @@
 	{
 	  /* read sigregs,regs.gprs[11 or 15] */
 	  prev_fp = read_memory_integer (sregs +
-					 REGISTER_BYTE (S390_GP0_REGNUM +
+					 DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM +
 							(prev_fextra_info.
 							 frame_pointer_saved_pc
 							 ? 11 : 15)),
@@ -1886,7 +1886,7 @@
   int len = TYPE_LENGTH (valtype);
 
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
-    memcpy (valbuf, &regbuf[REGISTER_BYTE (S390_FP0_REGNUM)], len);
+    memcpy (valbuf, &regbuf[DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM)], len);
   else
     {
       int offset = 0;
@@ -1894,7 +1894,7 @@
       if (TYPE_LENGTH (valtype) < S390_GPR_SIZE)
 	offset = S390_GPR_SIZE - TYPE_LENGTH (valtype);
       memcpy (valbuf,
-	      regbuf + REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
+	      regbuf + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
 	      TYPE_LENGTH (valtype));
     }
 }
@@ -1945,7 +1945,7 @@
     {
       if (TYPE_LENGTH (valtype) == 4
           || TYPE_LENGTH (valtype) == 8)
-        deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM),
+        deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM),
 					 valbuf, TYPE_LENGTH (valtype));
       else
         error ("GDB is unable to return `long double' values "
@@ -1956,7 +1956,7 @@
       value =
 	s390_promote_integer_argument (valtype, valbuf, reg_buff, &arglen);
       /* Everything else is returned in GPR2 and up. */
-      deprecated_write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM + 2),
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM + 2),
 				       value, arglen);
     }
 }
@@ -2363,7 +2363,7 @@
           {
             /* When we store a single-precision value in an FP register,
                it occupies the leftmost bits.  */
-            deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM + fr),
+            deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM + fr),
 					     VALUE_CONTENTS (arg),
 					     TYPE_LENGTH (type));
             fr += 2;
Index: sh64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh64-tdep.c,v
retrieving revision 1.4
diff -u -r1.4 sh64-tdep.c
--- sh64-tdep.c	14 Sep 2003 16:32:14 -0000	1.4
+++ sh64-tdep.c	14 Sep 2003 19:39:56 -0000
@@ -1292,7 +1292,7 @@
 	  if (raw_buffer)
 	    memcpy (raw_buffer,
 		    (deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
-		     + REGISTER_BYTE (regnum)),
+		     + DEPRECATED_REGISTER_BYTE (regnum)),
 		    REGISTER_RAW_SIZE (regnum));
 	  return;
 	}
@@ -1343,7 +1343,7 @@
   if (lval)			/* found it in a live register */
     *lval = lval_register;
   if (addrp)
-    *addrp = REGISTER_BYTE (live_regnum);
+    *addrp = DEPRECATED_REGISTER_BYTE (live_regnum);
   if (raw_buffer)
     deprecated_read_register_gen (live_regnum, raw_buffer);
 }
@@ -1351,7 +1351,7 @@
 static CORE_ADDR
 sh64_extract_struct_value_address (char *regbuf)
 {
-  return (extract_unsigned_integer ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)), 
+  return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)), 
 				    REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
 }
 
@@ -1673,7 +1673,7 @@
 	{
 	  /* Return value stored in FP0_REGNUM */
 	  return_register = FP0_REGNUM;
-	  offset = REGISTER_BYTE (return_register);
+	  offset = DEPRECATED_REGISTER_BYTE (return_register);
 	  memcpy (valbuf, (char *) regbuf + offset, len); 
 	}
       else if (len == 8)
@@ -1682,7 +1682,7 @@
 	  DOUBLEST val;
 
 	  return_register = DR0_REGNUM;
-	  offset = REGISTER_BYTE (return_register);
+	  offset = DEPRECATED_REGISTER_BYTE (return_register);
 	  
 	  if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
 	    floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
@@ -1701,10 +1701,10 @@
 	     at the most significant end. */
 	  return_register = DEFAULT_RETURN_REGNUM;
 	  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	    offset = REGISTER_BYTE (return_register) +
+	    offset = DEPRECATED_REGISTER_BYTE (return_register) +
 	      REGISTER_RAW_SIZE (return_register) - len;
 	  else
-	    offset = REGISTER_BYTE (return_register);
+	    offset = DEPRECATED_REGISTER_BYTE (return_register);
 	  memcpy (valbuf, (char *) regbuf + offset, len);
 	}
       else
Index: sparc-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-nat.c,v
retrieving revision 1.19
diff -u -r1.19 sparc-nat.c
--- sparc-nat.c	7 Jul 2003 15:56:03 -0000	1.19
+++ sparc-nat.c	14 Sep 2003 19:39:57 -0000
@@ -101,16 +101,16 @@
 		       (PTRACE_ARG3_TYPE) & inferior_registers, 0))
 	perror ("ptrace_getregs");
 
-      deprecated_registers[REGISTER_BYTE (0)] = 0;
-      memcpy (&deprecated_registers[REGISTER_BYTE (1)],
+      deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (1)],
 	      &inferior_registers.r_g1, 15 * REGISTER_RAW_SIZE (G0_REGNUM));
-      *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
 	= inferior_registers.r_ps;
-      *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)]
 	= inferior_registers.r_pc;
-      *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)]
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (NPC_REGNUM)]
 	= inferior_registers.r_npc;
-      *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
 
       for (i = G0_REGNUM; i <= O7_REGNUM; i++)
 	deprecated_register_valid[i] = 1;
@@ -134,9 +134,9 @@
 		       (PTRACE_ARG3_TYPE) & inferior_fp_registers,
 		       0))
 	perror ("ptrace_getfpregs");
-      memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	      &inferior_fp_registers, sizeof inferior_fp_registers.fpu_fr);
-      memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 	      &inferior_fp_registers.Fpu_fsr, sizeof (FPU_FSR_TYPE));
       for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
 	deprecated_register_valid[i] = 1;
@@ -147,19 +147,19 @@
      all (16 ptrace calls!) if we really need them.  */
   if (regno == -1)
     {
-      CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
-      target_read_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+      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));
       for (i = L0_REGNUM; i <= I7_REGNUM; i++)
 	deprecated_register_valid[i] = 1;
     }
   else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
     {
-      CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
-      i = REGISTER_BYTE (regno);
+      CORE_ADDR sp = *(unsigned int *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
+      i = DEPRECATED_REGISTER_BYTE (regno);
       if (deprecated_register_valid[regno])
 	printf_unfiltered ("register %d valid and read\n", regno);
-      target_read_memory (sp + i - REGISTER_BYTE (L0_REGNUM),
+      target_read_memory (sp + i - DEPRECATED_REGISTER_BYTE (L0_REGNUM),
 			  &deprecated_registers[i], REGISTER_RAW_SIZE (regno));
       deprecated_register_valid[regno] = 1;
     }
@@ -226,22 +226,22 @@
 
   if (wanna_store & STACK_REGS)
     {
-      CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
+      CORE_ADDR sp = *(unsigned int *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
 
       if (regno < 0 || regno == SP_REGNUM)
 	{
 	  if (!deprecated_register_valid[L0_REGNUM + 5])
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	  target_write_memory (sp,
-			       &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+			       &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 			       16 * REGISTER_RAW_SIZE (L0_REGNUM));
 	}
       else
 	{
 	  if (!deprecated_register_valid[regno])
 	    internal_error (__FILE__, __LINE__, "failed internal consistency check");
-	  target_write_memory (sp + REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM),
-			       &deprecated_registers[REGISTER_BYTE (regno)],
+	  target_write_memory (sp + DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM),
+			       &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 			       REGISTER_RAW_SIZE (regno));
 	}
 
@@ -253,17 +253,17 @@
 	internal_error (__FILE__, __LINE__, "failed internal consistency check");
 
       memcpy (&inferior_registers.r_g1,
-	      &deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
+	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
 	      15 * REGISTER_RAW_SIZE (G1_REGNUM));
 
       inferior_registers.r_ps =
-	*(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
+	*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)];
       inferior_registers.r_pc =
-	*(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
+	*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)];
       inferior_registers.r_npc =
-	*(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)];
+	*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (NPC_REGNUM)];
       inferior_registers.r_y =
-	*(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)];
+	*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)];
 
       if (0 != ptrace (PTRACE_SETREGS, store_pid,
 		       (PTRACE_ARG3_TYPE) & inferior_registers, 0))
@@ -275,10 +275,10 @@
       if (!deprecated_register_valid[FP0_REGNUM + 9])
 	internal_error (__FILE__, __LINE__, "failed internal consistency check");
       memcpy (&inferior_fp_registers,
-	      &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	      sizeof inferior_fp_registers.fpu_fr);
       memcpy (&inferior_fp_registers.Fpu_fsr,
-	      &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+	      &deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 	      sizeof (FPU_FSR_TYPE));
       if (0 !=
 	  ptrace (PTRACE_SETFPREGS, store_pid,
@@ -311,15 +311,15 @@
 
 #define gregs ((struct regs *)core_reg_sect)
       /* G0 *always* holds 0.  */
-      *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
 
       /* The globals and output registers.  */
-      memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
 	      15 * REGISTER_RAW_SIZE (G1_REGNUM));
-      *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
-      *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
-      *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
-      *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
+      *(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 (NPC_REGNUM)] = gregs->r_npc;
+      *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
 
       /* My best guess at where to get the locals and input
          registers is exactly where they usually are, right above
@@ -329,9 +329,9 @@
       {
 	int sp;
 
-	sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
+	sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
 	if (0 != target_read_memory (sp,
-				     &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
+				     &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
 				     16 * REGISTER_RAW_SIZE (L0_REGNUM)))
 	  {
 	    /* fprintf_unfiltered so user can still use gdb */
@@ -348,9 +348,9 @@
 #define fpuregs  ((struct fpu *) core_reg_sect)
       if (core_reg_size >= sizeof (struct fpu))
 	{
-	  memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 		  fpuregs->fpu_regs, sizeof (fpuregs->fpu_regs));
-	  memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
+	  memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)],
 		  &fpuregs->fpu_fsr, sizeof (FPU_FSR_TYPE));
 	}
       else
Index: sparc-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-tdep.c,v
retrieving revision 1.125
diff -u -r1.125 sparc-tdep.c
--- sparc-tdep.c	14 Sep 2003 16:32:14 -0000	1.125
+++ sparc-tdep.c	14 Sep 2003 19:39:58 -0000
@@ -936,7 +936,7 @@
     {
       if (lval != NULL)
 	*lval = lval_register;
-      addr = REGISTER_BYTE (regnum);
+      addr = DEPRECATED_REGISTER_BYTE (regnum);
       if (raw_buffer != NULL)
 	deprecated_read_register_gen (regnum, raw_buffer);
     }
@@ -972,10 +972,10 @@
   if (GDB_TARGET_IS_SPARC64)
     {
       /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
-      deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM),
+      deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM),
 				      &register_temp[0],
 				      REGISTER_RAW_SIZE (PC_REGNUM) * 7);
-      deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM), 
+      deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM), 
 				      &register_temp[7 * SPARC_INTREG_SIZE],
 				      REGISTER_RAW_SIZE (PSTATE_REGNUM));
       /* FIXME: not sure what needs to be saved here.  */
@@ -983,21 +983,21 @@
   else
     {
       /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
-      deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM),
+      deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM),
 				      &register_temp[0],
 				      REGISTER_RAW_SIZE (Y_REGNUM) * 8);
     }
 
-  deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM),
+  deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM),
 				  &register_temp[8 * SPARC_INTREG_SIZE],
 				  SPARC_INTREG_SIZE * 8);
 
-  deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM),
+  deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (G0_REGNUM),
 				  &register_temp[16 * SPARC_INTREG_SIZE],
 				  SPARC_INTREG_SIZE * 8);
 
   if (SPARC_HAS_FPU)
-    deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+    deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),
 				    &register_temp[24 * SPARC_INTREG_SIZE],
 				    FP_REGISTER_BYTES);
 
@@ -1224,7 +1224,7 @@
       if (fsr[FP0_REGNUM])
 	{
 	  read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
-	  deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+	  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),
 					   raw_buffer, FP_REGISTER_BYTES);
 	}
       if (!(GDB_TARGET_IS_SPARC64))
@@ -1244,7 +1244,7 @@
   if (fsr[G1_REGNUM])
     {
       read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
-      deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM), raw_buffer,
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (G1_REGNUM), raw_buffer,
 				       7 * SPARC_INTREG_SIZE);
     }
 
@@ -1297,10 +1297,10 @@
 
       /* Restore the out registers.
          Among other things this writes the new stack pointer.  */
-      deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), raw_buffer,
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM), raw_buffer,
 				       SPARC_INTREG_SIZE * 8);
 
-      deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM), reg_temp,
+      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (L0_REGNUM), reg_temp,
 				       SPARC_INTREG_SIZE * 16);
     }
 
@@ -1711,7 +1711,7 @@
     {
       if ((regno == -1) || (regno == regi))
 	{
-	  from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+	  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));
 	}
@@ -1720,7 +1720,7 @@
   if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
     if ((regno == -1) || (regno == FPS_REGNUM))
       {
-	from = (char *)&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)];
+	from = (char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)];
 	to = (char *) &fpregsetp->pr_fsr;
 	memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
       }
@@ -2416,7 +2416,7 @@
       deprecated_write_register_gen (regno, buffer);
     }
   else
-    deprecated_write_register_bytes (REGISTER_BYTE (regno), valbuf,
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regno), valbuf,
 				     TYPE_LENGTH (type));
 }
 
@@ -2693,7 +2693,7 @@
 	      default:
 		internal_error (__FILE__, __LINE__, "bad switch");
 	      }
-	      deprecated_write_register_bytes (REGISTER_BYTE (fpreg),
+	      deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (fpreg),
 					       VALUE_CONTENTS (args[i]),
 					       len);
 	    }
@@ -2726,7 +2726,7 @@
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     {
-      memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM)], typelen);
+      memcpy (valbuf, &regbuf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], typelen);
       return;
     }
 
Index: sun3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/sun3-nat.c,v
retrieving revision 1.10
diff -u -r1.10 sun3-nat.c
--- sun3-nat.c	14 Nov 2002 20:37:29 -0000	1.10
+++ sun3-nat.c	14 Sep 2003 19:40:00 -0000
@@ -47,13 +47,13 @@
 
   memcpy (deprecated_registers, &inferior_registers, 16 * 4);
   if (FP0_REGNUM >= 0)
-    memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+    memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	    &inferior_fp_registers, sizeof inferior_fp_registers.fps_regs);
 
-  *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
-  *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+  *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
   if (FP0_REGNUM >= 0)
-    memcpy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+    memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 	    &inferior_fp_registers.fps_control,
 	    sizeof inferior_fp_registers - 
 	    sizeof inferior_fp_registers.fps_regs);
@@ -72,15 +72,15 @@
   memcpy (&inferior_registers, deprecated_registers, 16 * 4);
   if (FP0_REGNUM >= 0)
     memcpy (&inferior_fp_registers,
-	    &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	    &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 	    sizeof inferior_fp_registers.fps_regs);
 
-  inferior_registers.r_ps = *(int *) &&deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
-  inferior_registers.r_pc = *(int *) &&deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
+  inferior_registers.r_ps = *(int *) &&deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)];
+  inferior_registers.r_pc = *(int *) &&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)];
 
   if (FP0_REGNUM >= 0)
     memcpy (&inferior_fp_registers.fps_control,
-	    &&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+	    &&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 	    sizeof inferior_fp_registers - 
 	    sizeof inferior_fp_registers.fps_regs);
 
@@ -131,10 +131,10 @@
 	{
 	  if (FP0_REGNUM >= 0)
 	    {
-	      memcpy (&&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
+	      memcpy (&&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
 		      fpustruct->f_fpstatus.fps_regs,
 		      sizeof fpustruct->f_fpstatus.fps_regs);
-	      memcpy (&&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
+	      memcpy (&&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPC_REGNUM)],
 		      &fpustruct->f_fpstatus.fps_control,
 		      sizeof fpustruct->f_fpstatus -
 		      sizeof fpustruct->f_fpstatus.fps_regs);
Index: v850-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/v850-tdep.c,v
retrieving revision 1.72
diff -u -r1.72 v850-tdep.c
--- v850-tdep.c	9 Sep 2003 06:34:54 -0000	1.72
+++ v850-tdep.c	14 Sep 2003 19:40:00 -0000
@@ -1065,7 +1065,7 @@
       /* Scalar return values of <= 8 bytes are returned in 
          E_V0_REGNUM to E_V1_REGNUM. */
       memcpy (valbuf,
-	      &regbuf[REGISTER_BYTE (E_V0_REGNUM)],
+	      &regbuf[DEPRECATED_REGISTER_BYTE (E_V0_REGNUM)],
 	      TYPE_LENGTH (type));
     }
   else
@@ -1073,7 +1073,7 @@
       /* Aggregates and return values > 8 bytes are returned in memory,
          pointed to by R6. */
       return_buffer =
-	extract_unsigned_integer (regbuf + REGISTER_BYTE (E_V0_REGNUM),
+	extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM),
 				  REGISTER_RAW_SIZE (E_V0_REGNUM));
 
       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
@@ -1101,7 +1101,7 @@
   CORE_ADDR return_buffer;
 
   if (!v850_use_struct_convention (0, type))
-    deprecated_write_register_bytes (REGISTER_BYTE (E_V0_REGNUM), valbuf,
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_V0_REGNUM), valbuf,
 				     TYPE_LENGTH (type));
   else
     {
Index: v850ice.c
===================================================================
RCS file: /cvs/src/src/gdb/v850ice.c,v
retrieving revision 1.15
diff -u -r1.15 v850ice.c
--- v850ice.c	18 Jan 2003 15:55:53 -0000	1.15
+++ v850ice.c	14 Sep 2003 19:40:00 -0000
@@ -560,7 +560,7 @@
       return;
     }
 
-  regval = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (regno)],
+  regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 				     REGISTER_RAW_SIZE (regno));
   strcpy (cmd, "reg ");
   if (!convert_register (regno, &cmd[4]))
Index: vax-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/vax-tdep.c,v
retrieving revision 1.61
diff -u -r1.61 vax-tdep.c
--- vax-tdep.c	14 Sep 2003 16:32:14 -0000	1.61
+++ vax-tdep.c	14 Sep 2003 19:40:00 -0000
@@ -267,7 +267,7 @@
 static void
 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 {
-  memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
+  memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (valtype));
 }
 
 static void
@@ -279,7 +279,7 @@
 static CORE_ADDR
 vax_extract_struct_value_address (char *regbuf)
 {
-  return (extract_unsigned_integer (regbuf + REGISTER_BYTE (0),
+  return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0),
 				    REGISTER_RAW_SIZE (0)));
 }
 
Index: xstormy16-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/xstormy16-tdep.c,v
retrieving revision 1.62
diff -u -r1.62 xstormy16-tdep.c
--- xstormy16-tdep.c	11 Sep 2003 15:17:17 -0000	1.62
+++ xstormy16-tdep.c	14 Sep 2003 19:40:08 -0000
@@ -221,7 +221,7 @@
       /* Scalar return values of <= 12 bytes are returned in 
          E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */
       memcpy (valbuf,
-	      &regbuf[REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
+	      &regbuf[DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
 	      TYPE_LENGTH (type));
     }
   else
@@ -229,7 +229,7 @@
       /* Aggregates and return values > 12 bytes are returned in memory,
          pointed to by R2. */
       return_buffer =
-	extract_unsigned_integer (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM),
+	extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM),
 				  REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
 
       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
@@ -393,7 +393,7 @@
     }
   else if (xstormy16_type_is_scalar (type) &&
 	   TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
-    deprecated_write_register_bytes (REGISTER_BYTE (E_1ST_ARG_REGNUM),
+    deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM),
 				     valbuf, TYPE_LENGTH (type));
   else
     {
Index: config/m68k/tm-cisco.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m68k/tm-cisco.h,v
retrieving revision 1.4
diff -u -r1.4 tm-cisco.h
--- config/m68k/tm-cisco.h	6 Mar 2001 08:21:30 -0000	1.4
+++ config/m68k/tm-cisco.h	14 Sep 2003 19:40:10 -0000
@@ -51,5 +51,5 @@
 
 /* BFD handles finding the registers in the core file, so they are at
    the start of the BFD .reg section.  */
-#define REGISTER_U_ADDR(addr,blockend,regno) (addr = REGISTER_BYTE (regno))
+#define REGISTER_U_ADDR(addr,blockend,regno) (addr = DEPRECATED_REGISTER_BYTE (regno))
 #define KERNEL_U_ADDR 0
Index: config/m68k/tm-delta68.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m68k/tm-delta68.h,v
retrieving revision 1.12
diff -u -r1.12 tm-delta68.h
--- config/m68k/tm-delta68.h	26 Jun 2003 17:18:42 -0000	1.12
+++ config/m68k/tm-delta68.h	14 Sep 2003 19:40:10 -0000
@@ -50,7 +50,7 @@
 #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF)		\
   if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)				\
     DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM, TYPE,			\
-				 &REGBUF[REGISTER_BYTE (FP0_REGNUM)],	\
+				 &REGBUF[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],	\
 				 VALBUF);				\
   else									\
     memcpy ((VALBUF),							\
@@ -70,7 +70,7 @@
       {									\
 	char raw_buf[REGISTER_RAW_SIZE (FP0_REGNUM)];			\
 	DEPRECATED_REGISTER_CONVERT_TO_RAW (TYPE, FP0_REGNUM, VALBUF, raw_buf);	\
-	deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),		\
+	deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),		\
 			      raw_buf, REGISTER_RAW_SIZE (FP0_REGNUM)); \
       }									\
   else									\
Index: config/pa/nm-hppah.h
===================================================================
RCS file: /cvs/src/src/gdb/config/pa/nm-hppah.h,v
retrieving revision 1.16
diff -u -r1.16 nm-hppah.h
--- config/pa/nm-hppah.h	4 Sep 2003 18:04:25 -0000	1.16
+++ config/pa/nm-hppah.h	14 Sep 2003 19:40:10 -0000
@@ -25,7 +25,7 @@
 
 /* What a coincidence! */
 #define REGISTER_U_ADDR(addr, blockend, regno)				\
-{ addr = (int)(blockend) + REGISTER_BYTE (regno);}
+{ addr = (int)(blockend) + DEPRECATED_REGISTER_BYTE (regno);}
 
 /* This isn't really correct, because ptrace is actually a 32-bit
    interface.  However, the modern HP-UX targets all really use
Index: mi/mi-main.c
===================================================================
RCS file: /cvs/src/src/gdb/mi/mi-main.c,v
retrieving revision 1.52
diff -u -r1.52 mi-main.c
--- mi/mi-main.c	11 Sep 2003 02:34:00 -0000	1.52
+++ mi/mi-main.c	14 Sep 2003 19:40:12 -0000
@@ -405,13 +405,13 @@
   if (! frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
     return -1;
 
-  if (memcmp (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
+  if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
 	      REGISTER_RAW_SIZE (regnum)) == 0)
     return 0;
 
   /* Found a changed register. Return 1. */
 
-  memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
+  memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
 	  REGISTER_RAW_SIZE (regnum));
 
   return 1;
@@ -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 (REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
+	  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
 	  /* Free the buffer.  */
 	  do_cleanups (old_chain);
 	}

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