2003-10-06 Andrew Cagney <cagney@redhat.com>

[deliverable/binutils-gdb.git] / gdb / sparc-tdep.c

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index b3081cd40edbe9d8ce4798a5e669b3cbef925c63..c32d3029b54d5663135d9cde6fd0f0d0957aba27 100644 (file)
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -33,6 +33,9 @@
 #include "gdb_string.h"
 #include "regcache.h"
 #include "osabi.h"
 #include "gdb_string.h"
 #include "regcache.h"
 #include "osabi.h"

+#include "dis-asm.h"
+
+#include "sparc-tdep.h"

 
 #ifdef USE_PROC_FS
 #include <sys/procfs.h>
 
 #ifdef USE_PROC_FS
 #include <sys/procfs.h>


@@ -49,12 +52,6 @@
  * Some local macros that have multi-arch and non-multi-arch versions:
  */
 
  * Some local macros that have multi-arch and non-multi-arch versions:
  */
 

-#if (GDB_MULTI_ARCH > 0)
-
-#if 0
-// OBSOLETE /* Does the target have Floating Point registers?  */
-// OBSOLETE #define SPARC_HAS_FPU     (gdbarch_tdep (current_gdbarch)->has_fpu)
-#endif

 #define SPARC_HAS_FPU 1
 /* Number of bytes devoted to Floating Point registers: */
 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
 #define SPARC_HAS_FPU 1
 /* Number of bytes devoted to Floating Point registers: */
 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)


@@ -65,54 +62,8 @@
 /* Offset within the call dummy stack of the saved registers.  */
 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
 
 /* Offset within the call dummy stack of the saved registers.  */
 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
 

-#else /* non-multi-arch */
-
-
-/* Does the target have Floating Point registers?  */
-#if 0
-// OBSOLETE #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
-// OBSOLETE #define SPARC_HAS_FPU 0
-// OBSOLETE #else
-// OBSOLETE #define SPARC_HAS_FPU 1
-// OBSOLETE #endif
-#endif
-#define SPARC_HAS_FPU 1
-
-/* Number of bytes devoted to Floating Point registers: */
-#if (GDB_TARGET_IS_SPARC64)
-#define FP_REGISTER_BYTES (64 * 4)
-#else
-#if (SPARC_HAS_FPU)
-#define FP_REGISTER_BYTES (32 * 4)
-#else
-#define FP_REGISTER_BYTES 0
-#endif
-#endif
-
-/* Highest numbered Floating Point register.  */
-#if (GDB_TARGET_IS_SPARC64)
-#define FP_MAX_REGNUM (FP0_REGNUM + 48)
-#else
-#define FP_MAX_REGNUM (FP0_REGNUM + 32)
-#endif
-
-/* Size of a general (integer) register: */
-#define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
-
-/* Offset within the call dummy stack of the saved registers.  */
-#if (GDB_TARGET_IS_SPARC64)
-#define DUMMY_REG_SAVE_OFFSET (128 + 16)
-#else
-#define DUMMY_REG_SAVE_OFFSET 0x60
-#endif
-
-#endif /* GDB_MULTI_ARCH */
-

 struct gdbarch_tdep
   {
 struct gdbarch_tdep
   {

-#if 0
-    // OBSOLETE     int has_fpu;
-#endif

     int fp_register_bytes;
     int y_regnum;
     int fp_max_regnum;
     int fp_register_bytes;
     int y_regnum;
     int fp_max_regnum;


@@ -130,9 +81,6 @@ struct gdbarch_tdep
  *       TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
  */
 
  *       TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
  */
 

-/* From infrun.c */
-extern int stop_after_trap;
-

 /* We don't store all registers immediately when requested, since they
    get sent over in large chunks anyway.  Instead, we accumulate most
    of the changes and send them over once.  "deferred_stores" keeps
 /* We don't store all registers immediately when requested, since they
    get sent over in large chunks anyway.  Instead, we accumulate most
    of the changes and send them over once.  "deferred_stores" keeps


@@ -142,14 +90,13 @@ extern int stop_after_trap;
 int deferred_stores = 0;    /* Accumulated stores we want to do eventually. */
 
 
 int deferred_stores = 0;    /* Accumulated stores we want to do eventually. */
 
 

-#if 0
-// OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
-// OBSOLETE    where instructions are big-endian and data are little-endian.
-// OBSOLETE    This flag is set when we detect that the target is of this type. */
-// OBSOLETE 
-// OBSOLETE int bi_endian = 0;
-#endif
-
+const unsigned char *
+sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
+{
+  static const char breakpoint[] = {0x91, 0xd0, 0x20, 0x01};
+  (*len) = sizeof (breakpoint);
+  return breakpoint;
+}

 
 /* Fetch a single instruction.  Even on bi-endian machines
    such as sparc86x, instructions are always big-endian.  */
 
 /* Fetch a single instruction.  Even on bi-endian machines
    such as sparc86x, instructions are always big-endian.  */


@@ -205,7 +152,7 @@ typedef enum
    Beihl (beihl@mcc.com).  */
 
 /* npc4 and next_pc describe the situation at the time that the
    Beihl (beihl@mcc.com).  */
 
 /* npc4 and next_pc describe the situation at the time that the

-   step-breakpoint was set, not necessary the current value of NPC_REGNUM.  */
+   step-breakpoint was set, not necessary the current value of DEPRECATED_NPC_REGNUM.  */

 static CORE_ADDR next_pc, npc4, target;
 static int brknpc4, brktrg;
 typedef char binsn_quantum[BREAKPOINT_MAX];
 static CORE_ADDR next_pc, npc4, target;
 static int brknpc4, brktrg;
 typedef char binsn_quantum[BREAKPOINT_MAX];


@@ -232,7 +179,7 @@ sparc_software_single_step (enum target_signal ignore,      /* pid, but we don't need
   if (insert_breakpoints_p)
     {
       /* Always set breakpoint for NPC.  */
   if (insert_breakpoints_p)
     {
       /* Always set breakpoint for NPC.  */

-      next_pc = read_register (NPC_REGNUM);
+      next_pc = read_register (DEPRECATED_NPC_REGNUM);

       npc4 = next_pc + 4;      /* branch not taken */
 
       target_insert_breakpoint (next_pc, break_mem[0]);
       npc4 = next_pc + 4;      /* branch not taken */
 
       target_insert_breakpoint (next_pc, break_mem[0]);


@@ -317,9 +264,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
      deprecated_read_fp() to create_new_frame.  */
   if (get_next_frame (fi))
     {
      deprecated_read_fp() to create_new_frame.  */
   if (get_next_frame (fi))
     {

-      char *buf;
-
-      buf = alloca (MAX_REGISTER_RAW_SIZE);
+      char buf[MAX_REGISTER_SIZE];

 
       /* Compute ->frame as if not flat.  If it is flat, we'll change
          it later.  */
 
       /* Compute ->frame as if not flat.  If it is flat, we'll change
          it later.  */


@@ -338,7 +283,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
        {
          /* Should we adjust for stack bias here? */
          ULONGEST tmp;
        {
          /* Should we adjust for stack bias here? */
          ULONGEST tmp;

-         frame_read_unsigned_register (fi, DEPRECATED_FP_REGNUM, &tmp);
+         tmp = get_frame_register_unsigned (fi, DEPRECATED_FP_REGNUM);

          deprecated_update_frame_base_hack (fi, tmp);
          if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
            deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
          deprecated_update_frame_base_hack (fi, tmp);
          if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
            deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);


@@ -368,9 +313,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
              && X_OP3 (insn) == 4
              && X_RS1 (insn) == 14)
            {
              && X_OP3 (insn) == 4
              && X_RS1 (insn) == 14)
            {

-             char *buf;
-             
-             buf = alloca (MAX_REGISTER_RAW_SIZE);
+             char buf[MAX_REGISTER_SIZE];

 
              /* We definitely have a flat frame now.  */
              get_frame_extra_info (fi)->flat = 1;
 
              /* We definitely have a flat frame now.  */
              get_frame_extra_info (fi)->flat = 1;


@@ -380,7 +323,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
              /* Overwrite the frame's address with the value in %i7.  */
              {
                ULONGEST tmp;
              /* Overwrite the frame's address with the value in %i7.  */
              {
                ULONGEST tmp;

-               frame_read_unsigned_register (fi, I7_REGNUM, &tmp);
+               tmp = get_frame_register_unsigned (fi, I7_REGNUM);

                deprecated_update_frame_base_hack (fi, tmp);
              }
 
                deprecated_update_frame_base_hack (fi, tmp);
              }
 


@@ -462,22 +405,14 @@ sparc_frame_chain (struct frame_info *frame)
   return ~ (CORE_ADDR) 0;
 }
 
   return ~ (CORE_ADDR) 0;
 }
 

-CORE_ADDR
-sparc_extract_struct_value_address (char *regbuf)
-{
-  return extract_address (regbuf + REGISTER_BYTE (O0_REGNUM),
-                         REGISTER_RAW_SIZE (O0_REGNUM));
-}
-

 /* Find the pc saved in frame FRAME.  */
 
 CORE_ADDR
 sparc_frame_saved_pc (struct frame_info *frame)
 {
 /* Find the pc saved in frame FRAME.  */
 
 CORE_ADDR
 sparc_frame_saved_pc (struct frame_info *frame)
 {

-  char *buf;
+  char buf[MAX_REGISTER_SIZE];

   CORE_ADDR addr;
 
   CORE_ADDR addr;
 

-  buf = alloca (MAX_REGISTER_RAW_SIZE);

   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
     {
       /* This is the signal trampoline frame.
   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
     {
       /* This is the signal trampoline frame.


@@ -504,7 +439,7 @@ sparc_frame_saved_pc (struct frame_info *frame)
       /* The sigcontext address is contained in register O2.  */
       {
        ULONGEST tmp;
       /* The sigcontext address is contained in register O2.  */
       {
        ULONGEST tmp;

-       frame_read_unsigned_register (frame, O0_REGNUM + 2, &tmp);
+       tmp = get_frame_register_unsigned (frame, O0_REGNUM + 2);

        sigcontext_addr = tmp;
       }
 
        sigcontext_addr = tmp;
       }
 


@@ -512,7 +447,7 @@ sparc_frame_saved_pc (struct frame_info *frame)
          stack layout has changed or the stack is corrupt.  */
       target_read_memory (sigcontext_addr + saved_pc_offset,
                          scbuf, sizeof (scbuf));
          stack layout has changed or the stack is corrupt.  */
       target_read_memory (sigcontext_addr + saved_pc_offset,
                          scbuf, sizeof (scbuf));

-      return extract_address (scbuf, sizeof (scbuf));
+      return extract_unsigned_integer (scbuf, sizeof (scbuf));

     }
   else if (get_frame_extra_info (frame)->in_prologue ||
           (get_next_frame (frame) != NULL &&
     }
   else if (get_frame_extra_info (frame)->in_prologue ||
           (get_next_frame (frame) != NULL &&


@@ -523,7 +458,7 @@ sparc_frame_saved_pc (struct frame_info *frame)
       /* A frameless function interrupted by a signal did not save
          the PC, it is still in %o7.  */
       ULONGEST tmp;
       /* A frameless function interrupted by a signal did not save
          the PC, it is still in %o7.  */
       ULONGEST tmp;

-      frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
+      tmp = get_frame_register_unsigned (frame, O7_REGNUM);

       return PC_ADJUST (tmp);
     }
   if (get_frame_extra_info (frame)->flat)
       return PC_ADJUST (tmp);
     }
   if (get_frame_extra_info (frame)->flat)


@@ -538,7 +473,7 @@ sparc_frame_saved_pc (struct frame_info *frame)
     return PC_ADJUST (read_register (O7_REGNUM));
 
   read_memory (addr, buf, SPARC_INTREG_SIZE);
     return PC_ADJUST (read_register (O7_REGNUM));
 
   read_memory (addr, buf, SPARC_INTREG_SIZE);

-  return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
+  return PC_ADJUST (extract_unsigned_integer (buf, SPARC_INTREG_SIZE));

 }
 
 /* Since an individual frame in the frame cache is defined by two
 }
 
 /* Since an individual frame in the frame cache is defined by two


@@ -864,7 +799,7 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
       if (raw_buffer != NULL)
        {
          /* Put it back in target format.  */
       if (raw_buffer != NULL)
        {
          /* Put it back in target format.  */

-         store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
+         store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));

        }
       if (addrp != NULL)
        *addrp = 0;
        }
       if (addrp != NULL)
        *addrp = 0;


@@ -972,20 +907,20 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
          if (raw_buffer != NULL)
            {
              /* Put it back in target format.  */
          if (raw_buffer != NULL)
            {
              /* Put it back in target format.  */

-             store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
+             store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), addr);

            }
          if (addrp != NULL)
            *addrp = 0;
          return;
        }
       if (raw_buffer != NULL)
            }
          if (addrp != NULL)
            *addrp = 0;
          return;
        }
       if (raw_buffer != NULL)

-       read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+       read_memory (addr, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));

     }
   else
     {
       if (lval != NULL)
        *lval = lval_register;
     }
   else
     {
       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);
     }
       if (raw_buffer != NULL)
        deprecated_read_register_gen (regnum, raw_buffer);
     }


@@ -1021,32 +956,32 @@ sparc_push_dummy_frame (void)
   if (GDB_TARGET_IS_SPARC64)
     {
       /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
   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_temp[0],

-                                     REGISTER_RAW_SIZE (PC_REGNUM) * 7);
-      deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM), 
+                                     DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM) * 7);
+      deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM), 

                                      &register_temp[7 * SPARC_INTREG_SIZE],
                                      &register_temp[7 * SPARC_INTREG_SIZE],

-                                     REGISTER_RAW_SIZE (PSTATE_REGNUM));
+                                     DEPRECATED_REGISTER_RAW_SIZE (PSTATE_REGNUM));

       /* FIXME: not sure what needs to be saved here.  */
     }
   else
     {
       /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
       /* FIXME: not sure what needs to be saved here.  */
     }
   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_temp[0],

-                                     REGISTER_RAW_SIZE (Y_REGNUM) * 8);
+                                     DEPRECATED_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);
 
                                  &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)
                                  &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);
 
                                    &register_temp[24 * SPARC_INTREG_SIZE],
                                    FP_REGISTER_BYTES);
 


@@ -1142,7 +1077,7 @@ static void sparc_frame_find_saved_regs (struct frame_info *, CORE_ADDR *);
 static void
 sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
 {
 static void
 sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
 {

-  register int regnum;
+  int regnum;

   CORE_ADDR frame_addr = get_frame_base (fi);
 
   gdb_assert (fi != NULL);
   CORE_ADDR frame_addr = get_frame_base (fi);
 
   gdb_assert (fi != NULL);


@@ -1259,21 +1194,21 @@ sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
 void
 sparc_pop_frame (void)
 {
 void
 sparc_pop_frame (void)
 {

-  register struct frame_info *frame = get_current_frame ();
-  register CORE_ADDR pc;
+  struct frame_info *frame = get_current_frame ();
+  CORE_ADDR pc;

   CORE_ADDR *fsr;
   char *raw_buffer;
   int regnum;
 
   fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));
   CORE_ADDR *fsr;
   char *raw_buffer;
   int regnum;
 
   fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));

-  raw_buffer = alloca (REGISTER_BYTES);
+  raw_buffer = alloca (DEPRECATED_REGISTER_BYTES);

   sparc_frame_find_saved_regs (frame, &fsr[0]);
   if (SPARC_HAS_FPU)
     {
       if (fsr[FP0_REGNUM])
        {
          read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
   sparc_frame_find_saved_regs (frame, &fsr[0]);
   if (SPARC_HAS_FPU)
     {
       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))
                                           raw_buffer, FP_REGISTER_BYTES);
        }
       if (!(GDB_TARGET_IS_SPARC64))


@@ -1293,7 +1228,7 @@ sparc_pop_frame (void)
   if (fsr[G1_REGNUM])
     {
       read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
   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);
     }
 
                                       7 * SPARC_INTREG_SIZE);
     }
 


@@ -1346,10 +1281,10 @@ sparc_pop_frame (void)
 
       /* Restore the out registers.
          Among other things this writes the new stack pointer.  */
 
       /* 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);
 
                                       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);
     }
 
                                       SPARC_INTREG_SIZE * 16);
     }
 


@@ -1357,41 +1292,41 @@ sparc_pop_frame (void)
     if (fsr[PS_REGNUM])
       write_register (PS_REGNUM, 
                      read_memory_integer (fsr[PS_REGNUM], 
     if (fsr[PS_REGNUM])
       write_register (PS_REGNUM, 
                      read_memory_integer (fsr[PS_REGNUM], 

-                                          REGISTER_RAW_SIZE (PS_REGNUM)));
+                                          DEPRECATED_REGISTER_RAW_SIZE (PS_REGNUM)));

 
   if (fsr[Y_REGNUM])
     write_register (Y_REGNUM, 
                    read_memory_integer (fsr[Y_REGNUM], 
 
   if (fsr[Y_REGNUM])
     write_register (Y_REGNUM, 
                    read_memory_integer (fsr[Y_REGNUM], 

-                                        REGISTER_RAW_SIZE (Y_REGNUM)));
+                                        DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM)));

   if (fsr[PC_REGNUM])
     {
       /* Explicitly specified PC (and maybe NPC) -- just restore them. */
       write_register (PC_REGNUM, 
                      read_memory_integer (fsr[PC_REGNUM],
   if (fsr[PC_REGNUM])
     {
       /* Explicitly specified PC (and maybe NPC) -- just restore them. */
       write_register (PC_REGNUM, 
                      read_memory_integer (fsr[PC_REGNUM],

-                                          REGISTER_RAW_SIZE (PC_REGNUM)));
-      if (fsr[NPC_REGNUM])
-       write_register (NPC_REGNUM,
-                       read_memory_integer (fsr[NPC_REGNUM],
-                                            REGISTER_RAW_SIZE (NPC_REGNUM)));
+                                          DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));
+      if (fsr[DEPRECATED_NPC_REGNUM])
+       write_register (DEPRECATED_NPC_REGNUM,
+                       read_memory_integer (fsr[DEPRECATED_NPC_REGNUM],
+                                            DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM)));

     }
   else if (get_frame_extra_info (frame)->flat)
     {
       if (get_frame_extra_info (frame)->pc_addr)
        pc = PC_ADJUST ((CORE_ADDR)
                        read_memory_integer (get_frame_extra_info (frame)->pc_addr,
     }
   else if (get_frame_extra_info (frame)->flat)
     {
       if (get_frame_extra_info (frame)->pc_addr)
        pc = PC_ADJUST ((CORE_ADDR)
                        read_memory_integer (get_frame_extra_info (frame)->pc_addr,

-                                            REGISTER_RAW_SIZE (PC_REGNUM)));
+                                            DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));

       else
        {
          /* I think this happens only in the innermost frame, if so then
             it is a complicated way of saying
             "pc = read_register (O7_REGNUM);".  */
          ULONGEST tmp;
       else
        {
          /* I think this happens only in the innermost frame, if so then
             it is a complicated way of saying
             "pc = read_register (O7_REGNUM);".  */
          ULONGEST tmp;

-         frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
+         tmp = get_frame_register_unsigned (frame, O7_REGNUM);

          pc = PC_ADJUST (tmp);
        }
 
       write_register (PC_REGNUM, pc);
          pc = PC_ADJUST (tmp);
        }
 
       write_register (PC_REGNUM, pc);

-      write_register (NPC_REGNUM, pc + 4);
+      write_register (DEPRECATED_NPC_REGNUM, pc + 4);

     }
   else if (fsr[I7_REGNUM])
     {
     }
   else if (fsr[I7_REGNUM])
     {


@@ -1399,7 +1334,7 @@ sparc_pop_frame (void)
       pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
                                                       SPARC_INTREG_SIZE));
       write_register (PC_REGNUM, pc);
       pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
                                                       SPARC_INTREG_SIZE));
       write_register (PC_REGNUM, pc);

-      write_register (NPC_REGNUM, pc + 4);
+      write_register (DEPRECATED_NPC_REGNUM, pc + 4);

     }
   flush_cached_frames ();
 }
     }
   flush_cached_frames ();
 }


@@ -1528,7 +1463,7 @@ supply_gregset (gdb_gregset_t *gregsetp)
 
   /* These require a bit more care.  */
   supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);
 
   /* These require a bit more care.  */
   supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);

-  supply_register (NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
+  supply_register (DEPRECATED_NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);

   supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
 
   if (GDB_TARGET_IS_SPARC64)
   supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
 
   if (GDB_TARGET_IS_SPARC64)


@@ -1647,8 +1582,8 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
   if ((regno == -1) || (regno == PC_REGNUM))
     deprecated_read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
 
   if ((regno == -1) || (regno == PC_REGNUM))
     deprecated_read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
 

-  if ((regno == -1) || (regno == NPC_REGNUM))
-    deprecated_read_register_gen (NPC_REGNUM, (char *) (regp + R_nPC) + offset);
+  if ((regno == -1) || (regno == DEPRECATED_NPC_REGNUM))
+    deprecated_read_register_gen (DEPRECATED_NPC_REGNUM, (char *) (regp + R_nPC) + offset);

 
   if ((regno == -1) || (regno == Y_REGNUM))
     deprecated_read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);
 
   if ((regno == -1) || (regno == Y_REGNUM))
     deprecated_read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);


@@ -1711,7 +1646,7 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
 void
 supply_fpregset (gdb_fpregset_t *fpregsetp)
 {
 void
 supply_fpregset (gdb_fpregset_t *fpregsetp)
 {

-  register int regi;
+  int regi;

   char *from;
 
   if (!SPARC_HAS_FPU)
   char *from;
 
   if (!SPARC_HAS_FPU)


@@ -1760,18 +1695,18 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
     {
       if ((regno == -1) || (regno == regi))
        {
     {
       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];
          to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];

-         memcpy (to, from, REGISTER_RAW_SIZE (regi));
+         memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));

        }
     }
 
   if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
     if ((regno == -1) || (regno == FPS_REGNUM))
       {
        }
     }
 
   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;
        to = (char *) &fpregsetp->pr_fsr;

-       memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
+       memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (FPS_REGNUM));

       }
 }
 
       }
 }
 


@@ -1800,7 +1735,7 @@ get_longjmp_target (CORE_ADDR *pc)
                          LONGJMP_TARGET_SIZE))
     return 0;
 
                          LONGJMP_TARGET_SIZE))
     return 0;
 

-  *pc = extract_address (buf, LONGJMP_TARGET_SIZE);
+  *pc = extract_unsigned_integer (buf, LONGJMP_TARGET_SIZE);

 
   return 1;
 }
 
   return 1;
 }


@@ -2070,8 +2005,8 @@ sparc_print_registers (struct gdbarch *gdbarch,
 {
   int i;
   const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
 {
   int i;
   const int numregs = NUM_REGS + NUM_PSEUDO_REGS;

-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
-  char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];

 
   for (i = 0; i < numregs; i++)
     {
 
   for (i = 0; i < numregs; i++)
     {


@@ -2081,9 +2016,9 @@ sparc_print_registers (struct gdbarch *gdbarch,
        {
          if (!print_all)
            {
        {
          if (!print_all)
            {

-             if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
+             if (TYPE_CODE (DEPRECATED_REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)

                continue;
                continue;

-             if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)))
+             if (TYPE_VECTOR (DEPRECATED_REGISTER_VIRTUAL_TYPE (i)))

                continue;
            }
        }
                continue;
            }
        }


@@ -2108,38 +2043,25 @@ sparc_print_registers (struct gdbarch *gdbarch,
          continue;
        }
 
          continue;
        }
 

-      /* FIXME: cagney/2002-08-03: This code shouldn't be necessary.
-         The function frame_register_read() should have returned the
-         pre-cooked register so no conversion is necessary.  */
-      /* Convert raw data to virtual format if necessary.  */
-      if (REGISTER_CONVERTIBLE (i))
-       {
-         REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
-                                      raw_buffer, virtual_buffer);
-       }
-      else
-       {
-         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.  */
 
       /* If virtual format is floating, print it that way, and in raw
          hex.  */

-      if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
+      if (TYPE_CODE (DEPRECATED_REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)

        {
          int j;
 
        {
          int j;
 

-         val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
+         val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,

                     file, 0, 1, 0, Val_pretty_default);
 
          fprintf_filtered (file, "\t(raw 0x");
                     file, 0, 1, 0, Val_pretty_default);
 
          fprintf_filtered (file, "\t(raw 0x");

-         for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+         for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++)

            {
              int idx;
              if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
                idx = j;
              else
            {
              int idx;
              if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
                idx = j;
              else

-               idx = REGISTER_RAW_SIZE (i) - 1 - j;
+               idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j;

              fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
            }
          fprintf_filtered (file, ")");
              fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
            }
          fprintf_filtered (file, ")");


@@ -2147,14 +2069,14 @@ sparc_print_registers (struct gdbarch *gdbarch,
       else
        {
          /* Print the register in hex.  */
       else
        {
          /* Print the register in hex.  */

-         val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
+         val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,

                     file, 'x', 1, 0, Val_pretty_default);
           /* If not a vector register, print it also according to its
              natural format.  */
                     file, 'x', 1, 0, Val_pretty_default);
           /* If not a vector register, print it also according to its
              natural format.  */

-         if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)) == 0)
+         if (TYPE_VECTOR (DEPRECATED_REGISTER_VIRTUAL_TYPE (i)) == 0)

            {
              fprintf_filtered (file, "\t");
            {
              fprintf_filtered (file, "\t");

-             val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
+             val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,

                         file, 0, 1, 0, Val_pretty_default);
            }
        }
                         file, 0, 1, 0, Val_pretty_default);
            }
        }


@@ -2184,33 +2106,123 @@ sparc_do_registers_info (int regnum, int all)
                              regnum, all);
 }
 
                              regnum, all);
 }
 

-#if 0
-// OBSOLETE static void
-// OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
-// OBSOLETE                           struct ui_file *file,
-// OBSOLETE                           struct frame_info *frame,
-// OBSOLETE                           int regnum, int print_all)
-// OBSOLETE {
-// OBSOLETE   sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
-// OBSOLETE }
-// OBSOLETE 
-// OBSOLETE void
-// OBSOLETE sparclet_do_registers_info (int regnum, int all)
-// OBSOLETE {
-// OBSOLETE   sparclet_print_registers_info (current_gdbarch, gdb_stdout,
-// OBSOLETE                             deprecated_selected_frame, regnum, all);
-// OBSOLETE }
-#endif
+#define SPARC_F0_REGNUM                FP0_REGNUM      /* %f0 */
+#define SPARC_F1_REGNUM                (FP0_REGNUM + 1)/* %f1 */
+#define SPARC_O0_REGNUM                O0_REGNUM       /* %o0 */
+#define SPARC_O1_REGNUM                O1_REGNUM       /* %o1 */

 
 

-\f
-int
-gdb_print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
+/* Push the arguments onto the stack and into the appropriate registers.  */
+
+static CORE_ADDR
+sparc32_do_push_arguments (struct regcache *regcache, int nargs,
+                          struct value **args, CORE_ADDR sp)

 {
 {

-  /* It's necessary to override mach again because print_insn messes it up. */
-  info->mach = TARGET_ARCHITECTURE->mach;
-  return print_insn_sparc (memaddr, info);
+  CORE_ADDR *addr;
+  int size = 0;
+  int i;
+
+  /* Structure, union and quad-precision arguments are passed by
+     reference.  We allocate space for these arguments on the stack
+     and record their addresses in an array.  Array elements for
+     arguments that are passed by value will be set to zero.*/
+  addr = alloca (nargs * sizeof (CORE_ADDR));
+
+  for (i = nargs - 1; i >= 0; i--)
+    {
+      struct type *type = VALUE_ENCLOSING_TYPE (args[i]);
+      enum type_code code = TYPE_CODE (type);
+      int len = TYPE_LENGTH (type);
+
+      /* Push the contents of structure, union and quad-precision
+        arguments on the stack.  */
+      if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION || len > 8)
+       {
+         /* Keep the stack doubleword aligned.  */
+         sp -= (len + 7) & ~7;
+         write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
+         addr[i] = sp;
+         size += 4;
+       }
+      else
+       {
+         addr[i] = 0;
+         size += (len > 4) ? 8 : 4;
+       }
+    }
+
+  /* The needed space for outgoing arguments should be a multiple of 4.  */
+  gdb_assert (size % 4 == 0);
+
+  /* Make sure we reserve space for the first six words of arguments
+     in the stack frame, even if we don't need them.  */
+  if (size < 24)
+    sp -= (24 - size);
+
+  /* Make sure we end up with a doubleword aligned stack in the end.
+     Reserve an extra word if necessary in order to accomplish this.  */
+  if ((sp - size) % 8 == 0)
+    sp -= 4;
+
+  /* Now push the arguments onto the stack.  */
+  for (i = nargs - 1; i >=0; i--)
+    {
+      char buf[8];
+      int len;
+
+      if (addr[i])
+       {
+         store_unsigned_integer (buf, 4, addr[i]);
+         len = 4;
+       }
+      else
+       {
+         struct value *arg = args[i];
+
+         len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
+
+         /* Expand signed and unsigned bytes and halfwords as needed.  */
+         if (len < 4)
+           {
+             arg = value_cast (builtin_type_long, arg);
+             len = 4;
+           }
+         else if (len > 4 && len < 8)
+           {
+             arg = value_cast (builtin_type_long_long, arg);
+             len = 4;
+           }
+
+         gdb_assert (len == 4 || len == 8);
+         memcpy (buf, VALUE_CONTENTS_ALL (arg), len);
+       }
+
+      /* We always write the argument word on the stack.  */
+      sp -= len;
+      write_memory (sp, buf, len);
+
+      /* If this argument occupies one of the first 6 words, write it
+         into the appropriate register too.  */
+      size -= len;
+      if (size < 24)
+       {
+         int regnum = SPARC_O0_REGNUM + (size / 4);
+
+         regcache_cooked_write (regcache, regnum, buf);
+         if (len == 8 && size < 20)
+           regcache_cooked_write (regcache, regnum + 1, buf + 4);
+       }
+    }
+
+  /* Reserve space for the struct/union return value pointer.  */
+  sp -= 4;
+
+  /* Stack should be doubleword aligned at this point.  */
+  gdb_assert (sp % 8 == 0);
+
+  /* Return the adjusted stack pointer.  */
+  return sp;

 }
 }

-\f
+

 /* The SPARC passes the arguments on the stack; arguments smaller
    than an int are promoted to an int.  The first 6 words worth of 
    args are also passed in registers o0 - o5.  */
 /* The SPARC passes the arguments on the stack; arguments smaller
    than an int are promoted to an int.  The first 6 words worth of 
    args are also passed in registers o0 - o5.  */


@@ -2219,101 +2231,139 @@ CORE_ADDR
 sparc32_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                        int struct_return, CORE_ADDR struct_addr)
 {
 sparc32_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                        int struct_return, CORE_ADDR struct_addr)
 {

-  int i, j, oregnum;
-  int accumulate_size = 0;
-  struct sparc_arg
+  sp = sparc32_do_push_arguments (current_regcache, nargs, args, sp);
+
+  /* FIXME: kettenis/20030525: We don't let this function set the
+     struct/union return pointer just yet.  */
+#if 0
+  if (struct_return)

     {
     {

-      char *contents;
-      int len;
-      int offset;
-    };
-  struct sparc_arg *sparc_args =
-    (struct sparc_arg *) alloca (nargs * sizeof (struct sparc_arg));
-  struct sparc_arg *m_arg;
-
-  /* Promote arguments if necessary, and calculate their stack offsets
-     and sizes. */
-  for (i = 0, m_arg = sparc_args; i < nargs; i++, m_arg++)
-    {
-      struct value *arg = args[i];
-      struct type *arg_type = check_typedef (VALUE_TYPE (arg));
-      /* Cast argument to long if necessary as the compiler does it too.  */
-      switch (TYPE_CODE (arg_type))
-       {
-       case TYPE_CODE_INT:
-       case TYPE_CODE_BOOL:
-       case TYPE_CODE_CHAR:
-       case TYPE_CODE_RANGE:
-       case TYPE_CODE_ENUM:
-         if (TYPE_LENGTH (arg_type) < TYPE_LENGTH (builtin_type_long))
-           {
-             arg_type = builtin_type_long;
-             arg = value_cast (arg_type, arg);
-           }
-         break;
-       default:
-         break;
-       }
-      m_arg->len = TYPE_LENGTH (arg_type);
-      m_arg->offset = accumulate_size;
-      accumulate_size = (accumulate_size + m_arg->len + 3) & ~3;
-      m_arg->contents = VALUE_CONTENTS (arg);
+      char buf[4];
+
+      /* The space for the struct/union return value pointer has
+         already been reserved.  */
+      store_unsigned_integer (buf, 4, struct_addr);
+      write (sp, buf, 4);

     }
 
     }
 

-  /* Make room for the arguments on the stack.  */
-  accumulate_size += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
-  sp = ((sp - accumulate_size) & ~7) + DEPRECATED_CALL_DUMMY_STACK_ADJUST;
+  return sp;
+#else
+  return sp + 4;
+#endif
+}
+
+/* Extract from REGCACHE a function return value of type TYPE and copy
+   that into VALBUF.

 
 

-  /* `Push' arguments on the stack.  */
-  for (i = 0, oregnum = 0, m_arg = sparc_args; 
-       i < nargs;
-       i++, m_arg++)
+   Note that REGCACHE specifies the register values for the frame of
+   the calling function.  This means that we need to fetch the value
+   form %o0 and %o1, which correspond to %i0 and %i1 in the frame of
+   the called function.  */
+
+void
+sparc32_extract_return_value (struct type *type, struct regcache *regcache,
+                             void *valbuf)
+{
+  int len = TYPE_LENGTH (type);
+  char buf[8];
+
+  if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)

     {
     {

-      write_memory (sp + m_arg->offset, m_arg->contents, m_arg->len);
-      for (j = 0; 
-          j < m_arg->len && oregnum < 6; 
-          j += SPARC_INTREG_SIZE, oregnum++)
-       deprecated_write_register_gen (O0_REGNUM + oregnum, m_arg->contents + j);
+      if (len == 4 || len == 8)
+       {
+         regcache_cooked_read (regcache, SPARC_F0_REGNUM, buf);
+         regcache_cooked_read (regcache, SPARC_F1_REGNUM, buf + 4);
+         memcpy (valbuf, buf, len);
+         return;
+       }
+      else
+       internal_error (__FILE__, __LINE__, "\
+Cannot extract floating-point return value of %d bytes long.", len);

     }
 
     }
 

-  return sp;
+  if (len <= 4)
+    {
+      regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
+      memcpy (valbuf, buf + 4 - len, len);
+    }
+  else if (len <= 8)
+    {
+      regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
+      regcache_cooked_read (regcache, SPARC_O1_REGNUM, buf + 4);
+      memcpy (valbuf, buf + 8 - len, len);
+    }
+  else
+    internal_error (__FILE__, __LINE__,
+                   "Cannot extract return value of %d bytes long.", len);

 }
 
 }
 

-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  */
+/* Write into REGBUF a function return value VALBUF of type TYPE.  */

 
 void
 
 void

-sparc32_extract_return_value (struct type *type, char *regbuf, char *valbuf)
+sparc32_store_return_value (struct type *type, struct regcache *regcache,
+                           const void *valbuf)

 {
 {

-  int typelen = TYPE_LENGTH (type);
-  int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
+  int len = TYPE_LENGTH (type);
+  char buf[8];

 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)

-    memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM)], typelen);
+    {
+      const char *buf = valbuf;
+
+      if (len == 4)
+       {
+         regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
+         return;
+       }
+      else if (len == 8)
+       {
+         regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
+         regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4);
+         return;
+       }
+      else
+       internal_error (__FILE__, __LINE__, "\
+Cannot extract floating-point return value of %d bytes long.", len);
+    }
+
+  /* Add leading zeros to the value.  */
+  memset (buf, 0, sizeof buf);
+
+  if (len <= 4)
+    {
+      memcpy (buf + 4 - len, valbuf, len);
+      regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
+    }
+  else if (len <= 8)
+    {
+      memcpy (buf + 8 - len, valbuf, len);
+      regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
+      regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf);
+    }

   else
   else

-    memcpy (valbuf,
-           &regbuf[O0_REGNUM * regsize +
-                   (typelen >= regsize
-                    || TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE ? 0
-                    : regsize - typelen)],
-           typelen);
+    internal_error (__FILE__, __LINE__,
+                   "Cannot extract return value of %d bytes long.", len);

 }
 
 }
 

+/* Extract from REGCACHE the address in which a function should return
+   its structure value.  */

 
 

-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  On SPARCs with FPUs,
-   float values are returned in %f0 (and %f1).  In all other cases,
-   values are returned in register %o0.  */
+CORE_ADDR
+sparc_extract_struct_value_address (struct regcache *regcache)
+{
+  ULONGEST addr;

 
 

-void
+  regcache_cooked_read_unsigned (regcache, SPARC_O0_REGNUM, &addr);
+  return addr;
+}
+
+/* FIXME: kettenis/2003/05/24: Still used for sparc64.  */
+
+static void

 sparc_store_return_value (struct type *type, char *valbuf)
 {
   int regno;
 sparc_store_return_value (struct type *type, char *valbuf)
 {
   int regno;

-  char *buffer;
-
-  buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char buffer[MAX_REGISTER_SIZE];

 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     /* Floating-point values are returned in the register pair */
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     /* Floating-point values are returned in the register pair */


@@ -2324,29 +2374,18 @@ sparc_store_return_value (struct type *type, char *valbuf)
     regno = O0_REGNUM;
 
   /* Add leading zeros to the value. */
     regno = O0_REGNUM;
 
   /* Add leading zeros to the value. */

-  if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno))
+  if (TYPE_LENGTH (type) < DEPRECATED_REGISTER_RAW_SIZE (regno))

     {
     {

-      memset (buffer, 0, REGISTER_RAW_SIZE (regno));
-      memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
+      memset (buffer, 0, DEPRECATED_REGISTER_RAW_SIZE (regno));
+      memcpy (buffer + DEPRECATED_REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,

              TYPE_LENGTH (type));
       deprecated_write_register_gen (regno, buffer);
     }
   else
              TYPE_LENGTH (type));
       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));
 }
 
                                     TYPE_LENGTH (type));
 }
 

-#if 0
-// OBSOLETE extern void
-// OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
-// OBSOLETE {
-// OBSOLETE   /* Other values are returned in register %o0.  */
-// OBSOLETE   deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
-// OBSOLETE                               TYPE_LENGTH (type));
-// OBSOLETE }
-#endif
-
-

 #ifndef CALL_DUMMY_CALL_OFFSET
 #define CALL_DUMMY_CALL_OFFSET \
      (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
 #ifndef CALL_DUMMY_CALL_OFFSET
 #define CALL_DUMMY_CALL_OFFSET \
      (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)


@@ -2357,9 +2396,10 @@ sparc_store_return_value (struct type *type, char *valbuf)
 
    For structs and unions, if the function was compiled with Sun cc,
    it expects 'unimp' after the call.  But gcc doesn't use that
 
    For structs and unions, if the function was compiled with Sun cc,
    it expects 'unimp' after the call.  But gcc doesn't use that

-   (twisted) convention.  So leave a nop there for gcc (FIX_CALL_DUMMY
-   can assume it is operating on a pristine CALL_DUMMY, not one that
-   has already been customized for a different function).  */
+   (twisted) convention.  So leave a nop there for gcc
+   (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
+   CALL_DUMMY, not one that has already been customized for a
+   different function).  */

 
 void
 sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
 
 void
 sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,


@@ -2392,10 +2432,10 @@ sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
     {
       store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
                              TYPE_LENGTH (value_type) & 0x1fff);
     {
       store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
                              TYPE_LENGTH (value_type) & 0x1fff);

-      set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);

     }
   else
     }
   else

-    set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
+    set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);

 
   if (!(GDB_TARGET_IS_SPARC64))
     {
 
   if (!(GDB_TARGET_IS_SPARC64))
     {


@@ -2410,45 +2450,8 @@ sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
            store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
        }
     }
            store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
        }
     }

-
-#if 0
-// OBSOLETE   /* If this is a bi-endian target, GDB has written the call dummy
-// OBSOLETE      in little-endian order.  We must byte-swap it back to big-endian. */
-// OBSOLETE   if (bi_endian)
-// OBSOLETE     {
-// OBSOLETE       for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
-// OBSOLETE    {
-// OBSOLETE      char tmp = dummy[i];
-// OBSOLETE      dummy[i] = dummy[i + 3];
-// OBSOLETE      dummy[i + 3] = tmp;
-// OBSOLETE      tmp = dummy[i + 1];
-// OBSOLETE      dummy[i + 1] = dummy[i + 2];
-// OBSOLETE      dummy[i + 2] = tmp;
-// OBSOLETE    }
-// OBSOLETE     }
-#endif

 }
 
 }
 

-
-#if 0
-// OBSOLETE /* Set target byte order based on machine type. */
-// OBSOLETE 
-// OBSOLETE static int
-// OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
-// OBSOLETE {
-// OBSOLETE   int i, j;
-// OBSOLETE 
-// OBSOLETE   if (ap->mach == bfd_mach_sparc_sparclite_le)
-// OBSOLETE     {
-// OBSOLETE       target_byte_order = BFD_ENDIAN_LITTLE;
-// OBSOLETE       bi_endian = 1;
-// OBSOLETE     }
-// OBSOLETE   else
-// OBSOLETE     bi_endian = 0;
-// OBSOLETE   return 1;
-// OBSOLETE }
-#endif
-

 /*
  * Module "constructor" function. 
  */
 /*
  * Module "constructor" function. 
  */


@@ -2457,21 +2460,19 @@ static struct gdbarch * sparc_gdbarch_init (struct gdbarch_info info,
                                            struct gdbarch_list *arches);
 static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
 
                                            struct gdbarch_list *arches);
 static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
 

+extern initialize_file_ftype _initialize_sparc_tdep; /* -Wmissing-prototypes */
+

 void
 _initialize_sparc_tdep (void)
 {
   /* Hook us into the gdbarch mechanism.  */
   gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
 void
 _initialize_sparc_tdep (void)
 {
   /* Hook us into the gdbarch mechanism.  */
   gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);

-
-  deprecated_tm_print_insn = gdb_print_insn_sparc;
-  deprecated_tm_print_insn_info.mach = TM_PRINT_INSN_MACH;             /* Selects sparc/sparclite */
-  /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */

 }
 
 /* Compensate for stack bias. Note that we currently don't handle
    mixed 32/64 bit code. */
 
 }
 
 /* Compensate for stack bias. Note that we currently don't handle
    mixed 32/64 bit code. */
 

-CORE_ADDR
+static CORE_ADDR

 sparc64_read_sp (void)
 {
   CORE_ADDR sp = read_register (SP_REGNUM);
 sparc64_read_sp (void)
 {
   CORE_ADDR sp = read_register (SP_REGNUM);


@@ -2481,7 +2482,7 @@ sparc64_read_sp (void)
   return sp;
 }
 
   return sp;
 }
 

-CORE_ADDR
+static CORE_ADDR

 sparc64_read_fp (void)
 {
   CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
 sparc64_read_fp (void)
 {
   CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);


@@ -2491,7 +2492,7 @@ sparc64_read_fp (void)
   return fp;
 }
 
   return fp;
 }
 

-void
+static void

 sparc64_write_sp (CORE_ADDR val)
 {
   CORE_ADDR oldsp = read_register (SP_REGNUM);
 sparc64_write_sp (CORE_ADDR val)
 {
   CORE_ADDR oldsp = read_register (SP_REGNUM);


@@ -2515,7 +2516,7 @@ sparc64_write_sp (CORE_ADDR val)
    for both; this means that if the arguments alternate between
    int and float, we will waste every other register of both types.  */
 
    for both; this means that if the arguments alternate between
    int and float, we will waste every other register of both types.  */
 

-CORE_ADDR
+static CORE_ADDR

 sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                        int struct_return, CORE_ADDR struct_retaddr)
 {
 sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                        int struct_return, CORE_ADDR struct_retaddr)
 {


@@ -2608,7 +2609,7 @@ sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
              default:
                internal_error (__FILE__, __LINE__, "bad switch");
              }
              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);
            }
                                               VALUE_CONTENTS (args[i]),
                                               len);
            }


@@ -2632,16 +2633,16 @@ sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
    returned in f0-f3). */
 
 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
    returned in f0-f3). */
 

-void
+static void

 sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
                           int bitoffset)
 {
   int typelen = TYPE_LENGTH (type);
 sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
                           int bitoffset)
 {
   int typelen = TYPE_LENGTH (type);

-  int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
+  int regsize = DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM);

 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     {
 
   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;
     }
 
       return;
     }
 


@@ -2689,33 +2690,19 @@ sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
     }
 }
 
     }
 }
 

-extern void
+static void

 sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 {
   sp64_extract_return_value (type, regbuf, valbuf, 0);
 }
 
 sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 {
   sp64_extract_return_value (type, regbuf, valbuf, 0);
 }
 

-#if 0
-// OBSOLETE extern void 
-// OBSOLETE sparclet_extract_return_value (struct type *type,
-// OBSOLETE                           char *regbuf, 
-// OBSOLETE                           char *valbuf)
-// OBSOLETE {
-// OBSOLETE   regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
-// OBSOLETE   if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
-// OBSOLETE     regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
-// OBSOLETE 
-// OBSOLETE   memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
-// OBSOLETE }
-#endif
-

 extern CORE_ADDR
 sparc32_stack_align (CORE_ADDR addr)
 {
   return ((addr + 7) & -8);
 }
 
 extern CORE_ADDR
 sparc32_stack_align (CORE_ADDR addr)
 {
   return ((addr + 7) & -8);
 }
 

-extern CORE_ADDR
+static CORE_ADDR

 sparc64_stack_align (CORE_ADDR addr)
 {
   return ((addr + 15) & -16);
 sparc64_stack_align (CORE_ADDR addr)
 {
   return ((addr + 15) & -16);


@@ -2730,8 +2717,6 @@ sparc_print_extra_frame_info (struct frame_info *fi)
                     paddr_nz (get_frame_extra_info (fi)->fp_addr));
 }
 
                     paddr_nz (get_frame_extra_info (fi)->fp_addr));
 }
 

-/* MULTI_ARCH support */
-

 static const char *
 sparc32_register_name (int regno)
 {
 static const char *
 sparc32_register_name (int regno)
 {


@@ -2788,72 +2773,7 @@ sparc64_register_name (int regno)
     return register_names[regno];
 }
 
     return register_names[regno];
 }
 

-#if 0
-// OBSOLETE static const char *
-// OBSOLETE sparclite_register_name (int regno)
-// OBSOLETE {
-// OBSOLETE   static char *register_names[] = 
-// OBSOLETE   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
-// OBSOLETE     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
-// OBSOLETE     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
-// OBSOLETE     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
-// OBSOLETE 
-// OBSOLETE     "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
-// OBSOLETE     "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
-// OBSOLETE     "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
-// OBSOLETE     "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
-// OBSOLETE 
-// OBSOLETE     "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
-// OBSOLETE     "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr" 
-// OBSOLETE   };
-// OBSOLETE 
-// OBSOLETE   if (regno < 0 ||
-// OBSOLETE       regno >= (sizeof (register_names) / sizeof (register_names[0])))
-// OBSOLETE     return NULL;
-// OBSOLETE   else
-// OBSOLETE     return register_names[regno];
-// OBSOLETE }
-#endif
-
-#if 0
-// OBSOLETE static const char *
-// OBSOLETE sparclet_register_name (int regno)
-// OBSOLETE {
-// OBSOLETE   static char *register_names[] = 
-// OBSOLETE   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
-// OBSOLETE     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
-// OBSOLETE     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
-// OBSOLETE     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
-// OBSOLETE 
-// OBSOLETE     "", "", "", "", "", "", "", "", /* no floating point registers */
-// OBSOLETE     "", "", "", "", "", "", "", "",
-// OBSOLETE     "", "", "", "", "", "", "", "",
-// OBSOLETE     "", "", "", "", "", "", "", "",
-// OBSOLETE 
-// OBSOLETE     "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
-// OBSOLETE     "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "", 
-// OBSOLETE 
-// OBSOLETE     /*       ASR15                 ASR19 (don't display them) */    
-// OBSOLETE     "asr1",  "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
-// OBSOLETE     /* None of the rest get displayed */
-// OBSOLETE #if 0
-// OBSOLETE     "awr0",  "awr1",  "awr2",  "awr3",  "awr4",  "awr5",  "awr6",  "awr7",  
-// OBSOLETE     "awr8",  "awr9",  "awr10", "awr11", "awr12", "awr13", "awr14", "awr15", 
-// OBSOLETE     "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23", 
-// OBSOLETE     "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31", 
-// OBSOLETE     "apsr"
-// OBSOLETE #endif /* 0 */
-// OBSOLETE   };
-// OBSOLETE 
-// OBSOLETE   if (regno < 0 ||
-// OBSOLETE       regno >= (sizeof (register_names) / sizeof (register_names[0])))
-// OBSOLETE     return NULL;
-// OBSOLETE   else
-// OBSOLETE     return register_names[regno];
-// OBSOLETE }
-#endif
-
-CORE_ADDR
+static CORE_ADDR

 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
 {
   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
 {
   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)


@@ -2867,8 +2787,10 @@ sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
         This address will actually be the program's entry point.  
         There will be a special call_dummy breakpoint there.  */
 
         This address will actually be the program's entry point.  
         There will be a special call_dummy breakpoint there.  */
 

-      write_register (O7_REGNUM, 
-                     CALL_DUMMY_ADDRESS () - 8);
+      if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
+       write_register (O7_REGNUM, DEPRECATED_CALL_DUMMY_ADDRESS () - 8);
+      else
+       write_register (O7_REGNUM, entry_point_address () - 8);

     }
 
   return sp;
     }
 
   return sp;


@@ -3012,19 +2934,6 @@ sparc_saved_pc_after_call (struct frame_info *fi)
   return sparc_pc_adjust (read_register (RP_REGNUM));
 }
 
   return sparc_pc_adjust (read_register (RP_REGNUM));
 }
 

-/* Convert registers between 'raw' and 'virtual' formats.
-   They are the same on sparc, so there's nothing to do.  */
-
-static void
-sparc_convert_to_virtual (int regnum, struct type *type, char *from, char *to)
-{      /* do nothing (should never be called) */
-}
-
-static void
-sparc_convert_to_raw (struct type *type, int regnum, char *from, char *to)
-{      /* do nothing (should never be called) */
-}
-

 /* Init saved regs: nothing to do, just a place-holder function.  */
 
 static void
 /* Init saved regs: nothing to do, just a place-holder function.  */
 
 static void


@@ -3049,12 +2958,13 @@ sparc_gdbarch_fix_call_dummy (char *dummy,
     sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
 }
 
     sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
 }
 

-/* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy.  */
+/* DEPRECATED_CALL_DUMMY_ADDRESS: fetch the breakpoint address for a
+   call dummy.  */

 
 static CORE_ADDR
 sparc_call_dummy_address (void)
 {
 
 static CORE_ADDR
 sparc_call_dummy_address (void)
 {

-  return (CALL_DUMMY_START_OFFSET) + CALL_DUMMY_BREAKPOINT_OFFSET;
+  return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;

 }
 
 /* Supply the Y register number to those that need it.  */
 }
 
 /* Supply the Y register number to those that need it.  */


@@ -3090,6 +3000,16 @@ sparc_return_value_on_stack (struct type *type)
     return 0;
 }
 
     return 0;
 }
 

+/* Get the ith function argument for the current function.  */
+static CORE_ADDR
+sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
+                             struct type *type)
+{
+  CORE_ADDR addr;
+  get_frame_register (frame, O0_REGNUM + argi, &addr);
+  return addr;
+}
+

 /*
  * Gdbarch "constructor" function.
  */
 /*
  * Gdbarch "constructor" function.
  */


@@ -3159,17 +3079,17 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* First set settings that are common for all sparc architectures.  */
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 
   /* First set settings that are common for all sparc architectures.  */
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);

-  set_gdbarch_breakpoint_from_pc (gdbarch, memory_breakpoint_from_pc);
+  set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);

   set_gdbarch_decr_pc_after_break (gdbarch, 0);
   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_decr_pc_after_break (gdbarch, 0);
   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);

-  set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sparc_extract_struct_value_address);
-  set_gdbarch_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
+  set_gdbarch_extract_struct_value_address (gdbarch,
+                                          sparc_extract_struct_value_address);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);

   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
   set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
   set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);

-  set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);

   set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
   set_gdbarch_frameless_function_invocation (gdbarch, 
                                             frameless_look_for_prologue);
   set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
   set_gdbarch_frameless_function_invocation (gdbarch, 
                                             frameless_look_for_prologue);


@@ -3184,13 +3104,8 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
   set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
   set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
   set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);

-  set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
-  set_gdbarch_register_convert_to_raw (gdbarch, sparc_convert_to_raw);
-  set_gdbarch_register_convert_to_virtual (gdbarch, 
-                                          sparc_convert_to_virtual);
-  set_gdbarch_register_convertible (gdbarch, 
-                                   generic_register_convertible_not);
-  set_gdbarch_reg_struct_has_addr (gdbarch, sparc_reg_struct_has_addr);
+  set_gdbarch_deprecated_reg_struct_has_addr
+    (gdbarch, sparc_reg_struct_has_addr);

   set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
   set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
   set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
   set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);


@@ -3200,6 +3115,9 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
 
   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
 

+  /* Helper for function argument information.  */
+  set_gdbarch_fetch_pointer_argument (gdbarch, sparc_fetch_pointer_argument);
+

   /*
    * Settings that depend only on 32/64 bit word size 
    */
   /*
    * Settings that depend only on 32/64 bit word size 
    */


@@ -3207,22 +3125,15 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_sparc:
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_sparc:

-#if 0
-      // OBSOLETE     case bfd_mach_sparc_sparclet:
-      // OBSOLETE     case bfd_mach_sparc_sparclite:
-#endif

     case bfd_mach_sparc_v8plus:
     case bfd_mach_sparc_v8plusa:
     case bfd_mach_sparc_v8plus:
     case bfd_mach_sparc_v8plusa:

-#if 0
-      // OBSOLETE     case bfd_mach_sparc_sparclite_le:
-#endif

       /* 32-bit machine types: */
 
 #ifdef SPARC32_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
       /* 32-bit machine types: */
 
 #ifdef SPARC32_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);

-      set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
-      set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0x30);
-      set_gdbarch_call_dummy_length (gdbarch, 0x38);
+      set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
+      set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);

 
       /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
         architecture method, it is now possible to implement a
 
       /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
         architecture method, it is now possible to implement a


@@ -3276,38 +3187,36 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
         are explained in Appendix D.3.  */
 
       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
         are explained in Appendix D.3.  */
 
       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);

-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);

 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);

-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);

 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
       set_gdbarch_frame_args_skip (gdbarch, 68);
       set_gdbarch_function_start_offset (gdbarch, 0);
       set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
       set_gdbarch_frame_args_skip (gdbarch, 68);
       set_gdbarch_function_start_offset (gdbarch, 0);
       set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);

-      set_gdbarch_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
+      set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);

       set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
       set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);

-      set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
-
-      set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
-      set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
-      set_gdbarch_register_size (gdbarch, 4);
-      set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
-      set_gdbarch_register_virtual_type (gdbarch, 
-                                        sparc32_register_virtual_type);
+
+      set_gdbarch_deprecated_register_byte (gdbarch, sparc32_register_byte);
+      set_gdbarch_deprecated_register_raw_size (gdbarch, sparc32_register_size);
+      set_gdbarch_deprecated_register_size (gdbarch, 4);
+      set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc32_register_size);
+      set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc32_register_virtual_type);

 #ifdef SPARC32_CALL_DUMMY_ON_STACK
 #ifdef SPARC32_CALL_DUMMY_ON_STACK

-      set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));

 #else
 #else

-      set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);

 #endif
 #endif

-      set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
+      set_gdbarch_deprecated_stack_align (gdbarch, sparc32_stack_align);

       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
       set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
       set_gdbarch_use_struct_convention (gdbarch, 
                                         generic_use_struct_convention);
       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
       set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
       set_gdbarch_use_struct_convention (gdbarch, 
                                         generic_use_struct_convention);

-      set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
+      set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);

       tdep->y_regnum = SPARC32_Y_REGNUM;
       tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
       tdep->intreg_size = 4;
       tdep->y_regnum = SPARC32_Y_REGNUM;
       tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
       tdep->intreg_size = 4;


@@ -3322,21 +3231,21 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
 #ifdef SPARC64_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 
 #ifdef SPARC64_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);

-      set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
-      set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
-      set_gdbarch_call_dummy_length (gdbarch, 192);
+      set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
+      set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);

       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);

-      set_gdbarch_call_dummy_start_offset (gdbarch, 148);
-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
+      set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);

 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);

-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);

 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
       set_gdbarch_frame_args_skip (gdbarch, 136);
       set_gdbarch_function_start_offset (gdbarch, 0);
       set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
       set_gdbarch_frame_args_skip (gdbarch, 136);
       set_gdbarch_function_start_offset (gdbarch, 0);
       set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);

-      set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
+      set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);

       set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
       set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
       set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
       set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);


@@ -3345,18 +3254,17 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
       /* Some of the registers aren't 64 bits, but it's a lot simpler just
         to assume they all are (since most of them are).  */
       set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
       /* Some of the registers aren't 64 bits, but it's a lot simpler just
         to assume they all are (since most of them are).  */

-      set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
-      set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
-      set_gdbarch_register_size (gdbarch, 8);
-      set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
-      set_gdbarch_register_virtual_type (gdbarch, 
-                                        sparc64_register_virtual_type);
+      set_gdbarch_deprecated_register_byte (gdbarch, sparc64_register_byte);
+      set_gdbarch_deprecated_register_raw_size (gdbarch, sparc64_register_size);
+      set_gdbarch_deprecated_register_size (gdbarch, 8);
+      set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc64_register_size);
+      set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc64_register_virtual_type);

 #ifdef SPARC64_CALL_DUMMY_ON_STACK
 #ifdef SPARC64_CALL_DUMMY_ON_STACK

-      set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));

 #else
 #else

-      set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);

 #endif
 #endif

-      set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
+      set_gdbarch_deprecated_stack_align (gdbarch, sparc64_stack_align);

       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
       set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
       set_gdbarch_use_struct_convention (gdbarch, 
       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
       set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
       set_gdbarch_use_struct_convention (gdbarch, 


@@ -3377,103 +3285,54 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_sparc:
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_sparc:

-      set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);

       set_gdbarch_num_regs (gdbarch, 72);
       set_gdbarch_num_regs (gdbarch, 72);

-      set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+      set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);

       set_gdbarch_register_name (gdbarch, sparc32_register_name);
       set_gdbarch_register_name (gdbarch, sparc32_register_name);

-      set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
-#if 0
-      // OBSOLETE       tdep->has_fpu = 1;     /* (all but sparclet and sparclite) */
-#endif

       tdep->fp_register_bytes = 32 * 4;
       tdep->print_insn_mach = bfd_mach_sparc;
       break;
       tdep->fp_register_bytes = 32 * 4;
       tdep->print_insn_mach = bfd_mach_sparc;
       break;

-#if 0
-      // OBSOLETE     case bfd_mach_sparc_sparclet:
-      // OBSOLETE       set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
-      // OBSOLETE       set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
-      // OBSOLETE       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
-      // OBSOLETE       set_gdbarch_register_name (gdbarch, sparclet_register_name);
-      // OBSOLETE       set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
-      // OBSOLETE       tdep->has_fpu = 0;     /* (all but sparclet and sparclite) */
-      // OBSOLETE       tdep->fp_register_bytes = 0;
-      // OBSOLETE       tdep->print_insn_mach = bfd_mach_sparc_sparclet;
-      // OBSOLETE       break;
-#endif
-#if 0
-      // OBSOLETE     case bfd_mach_sparc_sparclite:
-      // OBSOLETE       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
-      // OBSOLETE       set_gdbarch_num_regs (gdbarch, 80);
-      // OBSOLETE       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
-      // OBSOLETE       set_gdbarch_register_name (gdbarch, sparclite_register_name);
-      // OBSOLETE       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
-      // OBSOLETE       tdep->has_fpu = 0;     /* (all but sparclet and sparclite) */
-      // OBSOLETE       tdep->fp_register_bytes = 0;
-      // OBSOLETE       tdep->print_insn_mach = bfd_mach_sparc_sparclite;
-      // OBSOLETE       break;
-#endif

     case bfd_mach_sparc_v8plus:
     case bfd_mach_sparc_v8plus:

-      set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);

       set_gdbarch_num_regs (gdbarch, 72);
       set_gdbarch_num_regs (gdbarch, 72);

-      set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+      set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);

       set_gdbarch_register_name (gdbarch, sparc32_register_name);
       set_gdbarch_register_name (gdbarch, sparc32_register_name);

-      set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);

       tdep->print_insn_mach = bfd_mach_sparc;
       tdep->fp_register_bytes = 32 * 4;
       tdep->print_insn_mach = bfd_mach_sparc;
       tdep->fp_register_bytes = 32 * 4;

-#if 0
-      // OBSOLETE       tdep->has_fpu = 1;     /* (all but sparclet and sparclite) */
-#endif

       break;
     case bfd_mach_sparc_v8plusa:
       break;
     case bfd_mach_sparc_v8plusa:

-      set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+      set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);

       set_gdbarch_num_regs (gdbarch, 72);
       set_gdbarch_num_regs (gdbarch, 72);

-      set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+      set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);

       set_gdbarch_register_name (gdbarch, sparc32_register_name);
       set_gdbarch_register_name (gdbarch, sparc32_register_name);

-      set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
-#if 0
-      // OBSOLETE       tdep->has_fpu = 1;     /* (all but sparclet and sparclite) */
-#endif

       tdep->fp_register_bytes = 32 * 4;
       tdep->print_insn_mach = bfd_mach_sparc;
       break;
       tdep->fp_register_bytes = 32 * 4;
       tdep->print_insn_mach = bfd_mach_sparc;
       break;

-#if 0
-// OBSOLETE     case bfd_mach_sparc_sparclite_le:
-// OBSOLETE       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
-// OBSOLETE       set_gdbarch_num_regs (gdbarch, 80);
-// OBSOLETE       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
-// OBSOLETE       set_gdbarch_register_name (gdbarch, sparclite_register_name);
-// OBSOLETE       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
-// OBSOLETE       tdep->has_fpu = 0;   /* (all but sparclet and sparclite) */
-// OBSOLETE       tdep->fp_register_bytes = 0;
-// OBSOLETE       tdep->print_insn_mach = bfd_mach_sparc_sparclite;
-// OBSOLETE       break;
-#endif

     case bfd_mach_sparc_v9:
       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
       set_gdbarch_num_regs (gdbarch, 125);
     case bfd_mach_sparc_v9:
       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
       set_gdbarch_num_regs (gdbarch, 125);

-      set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
+      set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);

       set_gdbarch_register_name (gdbarch, sparc64_register_name);
       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
       set_gdbarch_register_name (gdbarch, sparc64_register_name);
       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);

-#if 0
-      // OBSOLETE       tdep->has_fpu = 1;     /* (all but sparclet and sparclite) */
-#endif

       tdep->fp_register_bytes = 64 * 4;
       tdep->print_insn_mach = bfd_mach_sparc_v9a;
       break;
     case bfd_mach_sparc_v9a:
       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
       set_gdbarch_num_regs (gdbarch, 125);
       tdep->fp_register_bytes = 64 * 4;
       tdep->print_insn_mach = bfd_mach_sparc_v9a;
       break;
     case bfd_mach_sparc_v9a:
       set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
       set_gdbarch_num_regs (gdbarch, 125);

-      set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
+      set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);

       set_gdbarch_register_name (gdbarch, sparc64_register_name);
       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
       set_gdbarch_register_name (gdbarch, sparc64_register_name);
       set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);

-#if 0
-      // OBSOLETE       tdep->has_fpu = 1;     /* (all but sparclet and sparclite) */
-#endif

       tdep->fp_register_bytes = 64 * 4;
       tdep->print_insn_mach = bfd_mach_sparc_v9a;
       break;
     }
 
       tdep->fp_register_bytes = 64 * 4;
       tdep->print_insn_mach = bfd_mach_sparc_v9a;
       break;
     }
 

+  set_gdbarch_print_insn (gdbarch, print_insn_sparc);
+

   /* Hook in OS ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);
 
   /* Hook in OS ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);
 


@@ -3488,10 +3347,6 @@ sparc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
   if (tdep == NULL)
     return;
 
   if (tdep == NULL)
     return;
 

-#if 0
-  // OBSOLETE   fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
-  // OBSOLETE                tdep->has_fpu);
-#endif

   fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
                      tdep->fp_register_bytes);
   fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",
   fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
                      tdep->fp_register_bytes);
   fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",