2003-09-30 Andrew Cagney <cagney@redhat.com>

	* mi-main.c: Rename REGISTER_VIRTUAL_SIZE to
	DEPRECATED_REGISTER_VIRTUAL_SIZE.

2003-09-30  Andrew Cagney  <cagney@redhat.com>

	* gdbarch.sh (DEPRECATED_REGISTER_VIRTUAL_SIZE): Rename
	REGISTER_VIRTUAL_SIZE.
	* gdbarch.h, gdbarch.c: Regenerate.
	* vax-tdep.h, sparc-tdep.c, regcache.h: Update.
	* regcache.c, mn10300-tdep.c, mips-tdep.c: Update.
	* infcmd.c, frame.c, findvar.c, cris-tdep.c: Update.

2003-09-30  Andrew Cagney  <cagney@redhat.com>

	* gdbint.texinfo (Target Architecture Definition): Rename
	REGISTER_VIRTUAL_SIZE to DEPRECATED_REGISTER_VIRTUAL_SIZE.
	(Target Architecture Definition):

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index e5e9775..0ecd4c2 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,12 @@
+2003-09-30  Andrew Cagney  <cagney@redhat.com>
+
+       * gdbarch.sh (DEPRECATED_REGISTER_VIRTUAL_SIZE): Rename
+       REGISTER_VIRTUAL_SIZE.
+       * gdbarch.h, gdbarch.c: Regenerate.
+       * vax-tdep.h, sparc-tdep.c, regcache.h: Update.
+       * regcache.c, mn10300-tdep.c, mips-tdep.c: Update.
+       * infcmd.c, frame.c, findvar.c, cris-tdep.c: Update.
+
 2003-09-29  Andrew Cagney  <cagney@redhat.com>
 
        * gdbarch.sh (DEPRECATED_REGISTER_VIRTUAL_TYPE): Rename

diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index e42b24b..846cef8 100644 (file)
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -4245,7 +4245,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* The length of the registers in the program's representation.  */
   set_gdbarch_deprecated_register_virtual_size (gdbarch, cris_register_size);
   
-  /* The largest value REGISTER_VIRTUAL_SIZE can have.  */
+  /* The largest value DEPRECATED_REGISTER_VIRTUAL_SIZE can have.  */
   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 32);
 
   set_gdbarch_deprecated_register_virtual_type (gdbarch, cris_register_virtual_type);

diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index 1099574..bdc1b3c 100644 (file)
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,6 +1,10 @@
 2003-09-30  Andrew Cagney  <cagney@redhat.com>
 
        * gdbint.texinfo (Target Architecture Definition): Rename
+       REGISTER_VIRTUAL_SIZE to DEPRECATED_REGISTER_VIRTUAL_SIZE.
+       (Target Architecture Definition): 
+
+       * gdbint.texinfo (Target Architecture Definition): Rename
        REGISTER_VIRTUAL_TYPE to DEPRECATED_REGISTER_VIRTUAL_TYPE.
 
 2003-09-29  Andrew Cagney  <cagney@redhat.com>

diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo
index 844ef06..9e26a11 100644 (file)
--- a/gdb/doc/gdbint.texinfo
+++ b/gdb/doc/gdbint.texinfo
@@ -2772,7 +2772,7 @@ of bytes the register will occupy in @code{registers}, or in a @value{GDBN}
 remote protocol packet.
 @end deftypefn
 
-@deftypefn {Target Macro} int REGISTER_VIRTUAL_SIZE (int @var{reg})
+@deftypefn {Target Macro} int DEPRECATED_REGISTER_VIRTUAL_SIZE (int @var{reg})
 The size of register number @var{reg}'s value, in its virtual format.
 This is the size a @code{struct value}'s buffer will have, holding that
 register's value.
@@ -3533,8 +3533,8 @@ floating-point.  @samp{float_reggroup}.
 Any register with a valid name.
 @end table
 
-@item REGISTER_VIRTUAL_SIZE (@var{reg})
-@findex REGISTER_VIRTUAL_SIZE
+@item DEPRECATED_REGISTER_VIRTUAL_SIZE (@var{reg})
+@findex DEPRECATED_REGISTER_VIRTUAL_SIZE
 Return the virtual size of @var{reg}; defaults to the size of the
 register's virtual type.
 Return the virtual size of @var{reg}.

diff --git a/gdb/findvar.c b/gdb/findvar.c
index f4f3ead..1e83942 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -289,7 +289,7 @@ value_of_register (int regnum, struct frame_info *frame)
       DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
                                              raw_buffer, VALUE_CONTENTS_RAW (reg_val));
     }
-  else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
+  else if (REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
            REGISTER_RAW_SIZE (regnum));
   else
@@ -298,7 +298,7 @@ value_of_register (int regnum, struct frame_info *frame)
                    REGISTER_NAME (regnum),
                    regnum,
                    REGISTER_RAW_SIZE (regnum),
-                   REGISTER_VIRTUAL_SIZE (regnum));
+                   DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
   VALUE_LVAL (reg_val) = lval;
   VALUE_ADDRESS (reg_val) = addr;
   VALUE_REGNO (reg_val) = regnum;

diff --git a/gdb/frame.c b/gdb/frame.c
index b3d1c4b..02daf54 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -629,7 +629,7 @@ frame_unwind_register_signed (struct frame_info *frame, int regnum)
 {
   char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
-  return extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
+  return extract_signed_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
 }
 
 LONGEST
@@ -643,7 +643,7 @@ frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
 {
   char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
-  return extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
+  return extract_unsigned_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
 }
 
 ULONGEST
@@ -658,7 +658,7 @@ frame_unwind_signed_register (struct frame_info *frame, int regnum,
 {
   char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
-  (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
+  (*val) = extract_signed_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
 }
 
 void
@@ -667,7 +667,7 @@ frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
 {
   char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
-  (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
+  (*val) = extract_unsigned_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
 }
 
 void

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 9683f8f..b0be6ab 100644 (file)
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -1532,6 +1532,25 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
                       DEPRECATED_REGISTER_SIZE);
 #endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_REGISTER_VIRTUAL_SIZE_P()",
+                      XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE_P() = %d\n",
+                      DEPRECATED_REGISTER_VIRTUAL_SIZE_P ());
+#endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_REGISTER_VIRTUAL_SIZE(reg_nr)",
+                      XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr)));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
+                      (long) current_gdbarch->deprecated_register_virtual_size
+                      /*DEPRECATED_REGISTER_VIRTUAL_SIZE ()*/);
+#endif
 #ifdef DEPRECATED_REGISTER_VIRTUAL_TYPE_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2115,25 +2134,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
   fprintf_unfiltered (file,
                       "gdbarch_dump: register_type = 0x%08lx\n",
                       (long) current_gdbarch->register_type);
-#ifdef REGISTER_VIRTUAL_SIZE_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "REGISTER_VIRTUAL_SIZE_P()",
-                      XSTRING (REGISTER_VIRTUAL_SIZE_P ()));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_VIRTUAL_SIZE_P() = %d\n",
-                      REGISTER_VIRTUAL_SIZE_P ());
-#endif
-#ifdef REGISTER_VIRTUAL_SIZE
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "REGISTER_VIRTUAL_SIZE(reg_nr)",
-                      XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
-                      (long) current_gdbarch->deprecated_register_virtual_size
-                      /*REGISTER_VIRTUAL_SIZE ()*/);
-#endif
   fprintf_unfiltered (file,
                       "gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n",
                       (long) current_gdbarch->remote_translate_xfer_address);

diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index b005f1e..82e5d76 100644 (file)
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -569,29 +569,29 @@ extern void set_gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, g
    DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted.  See: maint print
    registers. */
 
-#if defined (REGISTER_VIRTUAL_SIZE)
-/* Legacy for systems yet to multi-arch REGISTER_VIRTUAL_SIZE */
-#if !defined (REGISTER_VIRTUAL_SIZE_P)
-#define REGISTER_VIRTUAL_SIZE_P() (1)
+#if defined (DEPRECATED_REGISTER_VIRTUAL_SIZE)
+/* Legacy for systems yet to multi-arch DEPRECATED_REGISTER_VIRTUAL_SIZE */
+#if !defined (DEPRECATED_REGISTER_VIRTUAL_SIZE_P)
+#define DEPRECATED_REGISTER_VIRTUAL_SIZE_P() (1)
 #endif
 #endif
 
 extern int gdbarch_deprecated_register_virtual_size_p (struct gdbarch *gdbarch);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_VIRTUAL_SIZE_P)
-#error "Non multi-arch definition of REGISTER_VIRTUAL_SIZE"
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_VIRTUAL_SIZE_P)
+#error "Non multi-arch definition of DEPRECATED_REGISTER_VIRTUAL_SIZE"
 #endif
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_SIZE_P)
-#define REGISTER_VIRTUAL_SIZE_P() (gdbarch_deprecated_register_virtual_size_p (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_REGISTER_VIRTUAL_SIZE_P)
+#define DEPRECATED_REGISTER_VIRTUAL_SIZE_P() (gdbarch_deprecated_register_virtual_size_p (current_gdbarch))
 #endif
 
 typedef int (gdbarch_deprecated_register_virtual_size_ftype) (int reg_nr);
 extern int gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, int reg_nr);
 extern void set_gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, gdbarch_deprecated_register_virtual_size_ftype *deprecated_register_virtual_size);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_VIRTUAL_SIZE)
-#error "Non multi-arch definition of REGISTER_VIRTUAL_SIZE"
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_VIRTUAL_SIZE)
+#error "Non multi-arch definition of DEPRECATED_REGISTER_VIRTUAL_SIZE"
 #endif
-#if !defined (REGISTER_VIRTUAL_SIZE)
-#define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_deprecated_register_virtual_size (current_gdbarch, reg_nr))
+#if !defined (DEPRECATED_REGISTER_VIRTUAL_SIZE)
+#define DEPRECATED_REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_deprecated_register_virtual_size (current_gdbarch, reg_nr))
 #endif
 
 /* DEPRECATED_MAX_REGISTER_RAW_SIZE can be deleted.  It has been

diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 85d8d47..b9b0298 100755 (executable)
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -491,7 +491,7 @@ F:2:REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generi
 # sizes agree with the value computed from REGISTER_TYPE,
 # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted.  See: maint print
 # registers.
-F:2:REGISTER_VIRTUAL_SIZE:int:deprecated_register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
+F:2:DEPRECATED_REGISTER_VIRTUAL_SIZE:int:deprecated_register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
 # DEPRECATED_MAX_REGISTER_RAW_SIZE can be deleted.  It has been
 # replaced by the constant MAX_REGISTER_SIZE.
 V:2:DEPRECATED_MAX_REGISTER_RAW_SIZE:int:deprecated_max_register_raw_size

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 4c74894..f232fd5 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1545,7 +1545,7 @@ default_print_registers_info (struct gdbarch *gdbarch,
       else
        {
          memcpy (virtual_buffer, raw_buffer,
-                 REGISTER_VIRTUAL_SIZE (i));
+                 DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
        }
 
       /* If virtual format is floating, print it that way, and in raw

diff --git a/gdb/mi/ChangeLog b/gdb/mi/ChangeLog
index 2fd239a..a745585 100644 (file)
--- a/gdb/mi/ChangeLog
+++ b/gdb/mi/ChangeLog
@@ -1,6 +1,7 @@
-2003-09-20  Andrew Cagney  <cagney@redhat.com>
+2003-09-30  Andrew Cagney  <cagney@redhat.com>
 
-       * mi-main.c (get_register): 
+       * mi-main.c: Rename REGISTER_VIRTUAL_SIZE to
+       DEPRECATED_REGISTER_VIRTUAL_SIZE.
 
 2003-09-17  Andrew Cagney  <cagney@redhat.com>
 

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 590da42..51130a3 100644 (file)
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -544,7 +544,7 @@ get_register (int regnum, int format)
                                   raw_buffer, virtual_buffer);
     }
   else
-    memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (regnum));
+    memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
 
   if (format == 'r')
     {

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 1968b60..5a4ea24 100644 (file)
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -656,7 +656,7 @@ mips_register_raw_size (int regnum)
         (FP_REGISTER_DOUBLE).  Also, GDB's protocol is defined by a
         combination of REGISTER_RAW_SIZE and DEPRECATED_REGISTER_BYTE.  */
       if (mips64_transfers_32bit_regs_p)
-       return REGISTER_VIRTUAL_SIZE (regnum);
+       return DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
       else if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32
               && FP_REGISTER_DOUBLE)
        /* For MIPS_ABI_N32 (for example) we need 8 byte floating point
@@ -717,7 +717,7 @@ mips_register_convertible (int reg_nr)
   if (mips64_transfers_32bit_regs_p)
     return 0;
   else
-    return (REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
+    return (REGISTER_RAW_SIZE (reg_nr) > DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr));
 }
 
 static void
@@ -4229,7 +4229,7 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
     fprintf_filtered (file, ": ");
 
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    offset = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+    offset = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
   else
     offset = 0;
 
@@ -4297,16 +4297,16 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
       if (!frame_register_read (frame, regnum, raw_buffer))
        error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
       /* pad small registers */
-      for (byte = 0; byte < (MIPS_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
+      for (byte = 0; byte < (MIPS_REGSIZE - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); byte++)
        printf_filtered ("  ");
       /* Now print the register value in hex, endian order. */
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-       for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+       for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
             byte < REGISTER_RAW_SIZE (regnum);
             byte++)
          fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]);
       else
-       for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
+       for (byte = DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum) - 1;
             byte >= 0;
             byte--)
          fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]);

diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index 1820b1d..0cbff1d 100644 (file)
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -1039,14 +1039,14 @@ mn10300_print_register (const char *name, int regnum, int reg_width)
       int byte;
       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
        {
-         for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
+         for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
               byte < REGISTER_RAW_SIZE (regnum);
               byte++)
            printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
        }
       else
        {
-         for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
+         for (byte = DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum) - 1;
               byte >= 0;
               byte--)
            printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 42280ff..a36cd1e 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -114,7 +114,7 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
       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));
+      gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
     }
 
   /* Compute the real size of the register buffer.  Start out by
@@ -243,7 +243,7 @@ init_regcache_descr (struct gdbarch *gdbarch)
        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));
+      gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
 #endif
     }
   /* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i));  */
@@ -1553,7 +1553,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
          if ((regcache->descr->sizeof_register[regnum]
               != REGISTER_RAW_SIZE (regnum))
              || (regcache->descr->sizeof_register[regnum]
-                 != REGISTER_VIRTUAL_SIZE (regnum))
+                 != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
              || (regcache->descr->sizeof_register[regnum]
                  != TYPE_LENGTH (register_type (regcache->descr->gdbarch,
                                                 regnum)))
@@ -1623,7 +1623,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
              regcache_cooked_read (regcache, regnum, buf);
              fprintf_unfiltered (file, "0x");
              dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
-                                REGISTER_VIRTUAL_SIZE (regnum));
+                                DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
            }
        }
 

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 69ed4e6..9a341c3 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -147,8 +147,8 @@ extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 
    Anyway, the up-shot is that, until that mess is fixed, core code
    can end up being very confused - should the RAW or VIRTUAL size be
-   used?  As a rule of thumb, use REGISTER_VIRTUAL_SIZE in cooked
-   code, but with the comment:
+   used?  As a rule of thumb, use DEPRECATED_REGISTER_VIRTUAL_SIZE in
+   cooked code, but with the comment:
 
    OK: REGISTER_VIRTUAL_SIZE
 

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 6062a67..a9417d9 100644 (file)
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -2059,7 +2059,7 @@ sparc_print_registers (struct gdbarch *gdbarch,
          continue;
        }
 
-      memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
+      memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
 
       /* If virtual format is floating, print it that way, and in raw
          hex.  */

diff --git a/gdb/vax-tdep.h b/gdb/vax-tdep.h
index 7529e57..e81caed 100644 (file)
--- a/gdb/vax-tdep.h
+++ b/gdb/vax-tdep.h
@@ -36,7 +36,7 @@
 /* Largest value REGISTER_RAW_SIZE can have.  */
 #define VAX_MAX_REGISTER_RAW_SIZE 4
 
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+/* Largest value DEPRECATED_REGISTER_VIRTUAL_SIZE can have.  */
 #define VAX_MAX_REGISTER_VIRTUAL_SIZE 4
 
 /* Register numbers of various important registers.