PR ld/12380

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

diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 36565b2fed92bbd5b73c080fcba13047bb969d61..24d132dfb8265ce43e30cc681e3a7bc1e7b9cf77 100644 (file)
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for UltraSPARC.
 
 /* Target-dependent code for UltraSPARC.
 

-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011

    Free Software Foundation, Inc.
 
    This file is part of GDB.
    Free Software Foundation, Inc.
 
    This file is part of GDB.


@@ -103,7 +103,11 @@ sparc64_floating_p (const struct type *type)
   return 0;
 }
 
   return 0;
 }
 

-/* Check whether TYPE is "Structure or Union".  */
+/* Check whether TYPE is "Structure or Union".
+
+   In terms of Ada subprogram calls, arrays are treated the same as
+   struct and union types.  So this function also returns non-zero
+   for array types.  */

 
 static int
 sparc64_structure_or_union_p (const struct type *type)
 
 static int
 sparc64_structure_or_union_p (const struct type *type)


@@ -112,6 +116,7 @@ sparc64_structure_or_union_p (const struct type *type)
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:

+    case TYPE_CODE_ARRAY:

       return 1;
     default:
       break;
       return 1;
     default:
       break;


@@ -121,61 +126,89 @@ sparc64_structure_or_union_p (const struct type *type)
 }
 \f
 
 }
 \f
 

-/* Type for %pstate.  */
-struct type *sparc64_pstate_type;
+/* Construct types for ISA-specific registers.  */

 
 

-/* Type for %fsr.  */
-struct type *sparc64_fsr_type;
+static struct type *
+sparc64_pstate_type (struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-/* Type for %fprs.  */
-struct type *sparc64_fprs_type;
+  if (!tdep->sparc64_pstate_type)
+    {
+      struct type *type;
+
+      type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 8);
+      append_flags_type_flag (type, 0, "AG");
+      append_flags_type_flag (type, 1, "IE");
+      append_flags_type_flag (type, 2, "PRIV");
+      append_flags_type_flag (type, 3, "AM");
+      append_flags_type_flag (type, 4, "PEF");
+      append_flags_type_flag (type, 5, "RED");
+      append_flags_type_flag (type, 8, "TLE");
+      append_flags_type_flag (type, 9, "CLE");
+      append_flags_type_flag (type, 10, "PID0");
+      append_flags_type_flag (type, 11, "PID1");
+
+      tdep->sparc64_pstate_type = type;
+    }

 
 

-/* Construct types for ISA-specific registers.  */
+  return tdep->sparc64_pstate_type;
+}

 
 

-static void
-sparc64_init_types (void)
+static struct type *
+sparc64_fsr_type (struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  if (!tdep->sparc64_fsr_type)
+    {
+      struct type *type;
+
+      type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 8);
+      append_flags_type_flag (type, 0, "NXA");
+      append_flags_type_flag (type, 1, "DZA");
+      append_flags_type_flag (type, 2, "UFA");
+      append_flags_type_flag (type, 3, "OFA");
+      append_flags_type_flag (type, 4, "NVA");
+      append_flags_type_flag (type, 5, "NXC");
+      append_flags_type_flag (type, 6, "DZC");
+      append_flags_type_flag (type, 7, "UFC");
+      append_flags_type_flag (type, 8, "OFC");
+      append_flags_type_flag (type, 9, "NVC");
+      append_flags_type_flag (type, 22, "NS");
+      append_flags_type_flag (type, 23, "NXM");
+      append_flags_type_flag (type, 24, "DZM");
+      append_flags_type_flag (type, 25, "UFM");
+      append_flags_type_flag (type, 26, "OFM");
+      append_flags_type_flag (type, 27, "NVM");
+
+      tdep->sparc64_fsr_type = type;
+    }
+
+  return tdep->sparc64_fsr_type;
+}
+
+static struct type *
+sparc64_fprs_type (struct gdbarch *gdbarch)

 {
 {

-  struct type *type;
-
-  type = init_flags_type ("builtin_type_sparc64_pstate", 8);
-  append_flags_type_flag (type, 0, "AG");
-  append_flags_type_flag (type, 1, "IE");
-  append_flags_type_flag (type, 2, "PRIV");
-  append_flags_type_flag (type, 3, "AM");
-  append_flags_type_flag (type, 4, "PEF");
-  append_flags_type_flag (type, 5, "RED");
-  append_flags_type_flag (type, 8, "TLE");
-  append_flags_type_flag (type, 9, "CLE");
-  append_flags_type_flag (type, 10, "PID0");
-  append_flags_type_flag (type, 11, "PID1");
-  sparc64_pstate_type = type;
-
-  type = init_flags_type ("builtin_type_sparc64_fsr", 8);
-  append_flags_type_flag (type, 0, "NXA");
-  append_flags_type_flag (type, 1, "DZA");
-  append_flags_type_flag (type, 2, "UFA");
-  append_flags_type_flag (type, 3, "OFA");
-  append_flags_type_flag (type, 4, "NVA");
-  append_flags_type_flag (type, 5, "NXC");
-  append_flags_type_flag (type, 6, "DZC");
-  append_flags_type_flag (type, 7, "UFC");
-  append_flags_type_flag (type, 8, "OFC");
-  append_flags_type_flag (type, 9, "NVC");
-  append_flags_type_flag (type, 22, "NS");
-  append_flags_type_flag (type, 23, "NXM");
-  append_flags_type_flag (type, 24, "DZM");
-  append_flags_type_flag (type, 25, "UFM");
-  append_flags_type_flag (type, 26, "OFM");
-  append_flags_type_flag (type, 27, "NVM");
-  sparc64_fsr_type = type;
-
-  type = init_flags_type ("builtin_type_sparc64_fprs", 8);
-  append_flags_type_flag (type, 0, "DL");
-  append_flags_type_flag (type, 1, "DU");
-  append_flags_type_flag (type, 2, "FEF");
-  sparc64_fprs_type = type;
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  if (!tdep->sparc64_fprs_type)
+    {
+      struct type *type;
+
+      type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 8);
+      append_flags_type_flag (type, 0, "DL");
+      append_flags_type_flag (type, 1, "DU");
+      append_flags_type_flag (type, 2, "FEF");
+
+      tdep->sparc64_fprs_type = type;
+    }
+
+  return tdep->sparc64_fprs_type;

 }
 
 }
 

+

 /* Register information.  */
 
 static const char *sparc64_register_names[] =
 /* Register information.  */
 
 static const char *sparc64_register_names[] =


@@ -239,7 +272,7 @@ sparc64_register_name (struct gdbarch *gdbarch, int regnum)
 }
 
 /* Return the GDB type object for the "standard" data type of data in
 }
 
 /* Return the GDB type object for the "standard" data type of data in

-   register REGNUM. */
+   register REGNUM.  */

 
 static struct type *
 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
 
 static struct type *
 sparc64_register_type (struct gdbarch *gdbarch, int regnum)


@@ -247,42 +280,42 @@ sparc64_register_type (struct gdbarch *gdbarch, int regnum)
   /* Raw registers.  */
 
   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
   /* Raw registers.  */
 
   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)

-    return builtin_type_void_data_ptr;
+    return builtin_type (gdbarch)->builtin_data_ptr;

   if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
   if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)

-    return builtin_type_float;
+    return builtin_type (gdbarch)->builtin_float;

   if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
   if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)

-    return builtin_type_double;
+    return builtin_type (gdbarch)->builtin_double;

   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)

-    return builtin_type_void_func_ptr;
+    return builtin_type (gdbarch)->builtin_func_ptr;

   /* This raw register contains the contents of %cwp, %pstate, %asi
      and %ccr as laid out in a %tstate register.  */
   if (regnum == SPARC64_STATE_REGNUM)
   /* This raw register contains the contents of %cwp, %pstate, %asi
      and %ccr as laid out in a %tstate register.  */
   if (regnum == SPARC64_STATE_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

   if (regnum == SPARC64_FSR_REGNUM)
   if (regnum == SPARC64_FSR_REGNUM)

-    return sparc64_fsr_type;
+    return sparc64_fsr_type (gdbarch);

   if (regnum == SPARC64_FPRS_REGNUM)
   if (regnum == SPARC64_FPRS_REGNUM)

-    return sparc64_fprs_type;
+    return sparc64_fprs_type (gdbarch);

   /* "Although Y is a 64-bit register, its high-order 32 bits are
      reserved and always read as 0."  */
   if (regnum == SPARC64_Y_REGNUM)
   /* "Although Y is a 64-bit register, its high-order 32 bits are
      reserved and always read as 0."  */
   if (regnum == SPARC64_Y_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

 
   /* Pseudo registers.  */
 
   if (regnum == SPARC64_CWP_REGNUM)
 
   /* Pseudo registers.  */
 
   if (regnum == SPARC64_CWP_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

   if (regnum == SPARC64_PSTATE_REGNUM)
   if (regnum == SPARC64_PSTATE_REGNUM)

-    return sparc64_pstate_type;
+    return sparc64_pstate_type (gdbarch);

   if (regnum == SPARC64_ASI_REGNUM)
   if (regnum == SPARC64_ASI_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

   if (regnum == SPARC64_CCR_REGNUM)
   if (regnum == SPARC64_CCR_REGNUM)

-    return builtin_type_int64;
+    return builtin_type (gdbarch)->builtin_int64;

   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)

-    return builtin_type_double;
+    return builtin_type (gdbarch)->builtin_double;

   if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
   if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)

-    return builtin_type_long_double;
+    return builtin_type (gdbarch)->builtin_long_double;

 
   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 }
 
   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 }


@@ -292,6 +325,7 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch,
                              struct regcache *regcache,
                              int regnum, gdb_byte *buf)
 {
                              struct regcache *regcache,
                              int regnum, gdb_byte *buf)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   gdb_assert (regnum >= SPARC64_NUM_REGS);
 
   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
   gdb_assert (regnum >= SPARC64_NUM_REGS);
 
   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)


@@ -342,7 +376,7 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch,
          state = (state >> 32) & ((1 << 8) - 1);
          break;
        }
          state = (state >> 32) & ((1 << 8) - 1);
          break;
        }

-      store_unsigned_integer (buf, 8, state);
+      store_unsigned_integer (buf, 8, byte_order, state);

     }
 }
 
     }
 }
 


@@ -351,6 +385,7 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch,
                               struct regcache *regcache,
                               int regnum, const gdb_byte *buf)
 {
                               struct regcache *regcache,
                               int regnum, const gdb_byte *buf)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   gdb_assert (regnum >= SPARC64_NUM_REGS);
 
   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
   gdb_assert (regnum >= SPARC64_NUM_REGS);
 
   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)


@@ -386,7 +421,7 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch,
       ULONGEST state, bits;
 
       regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
       ULONGEST state, bits;
 
       regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);

-      bits = extract_unsigned_integer (buf, 8);
+      bits = extract_unsigned_integer (buf, 8, byte_order);

       switch (regnum)
        {
        case SPARC64_CWP_REGNUM:
       switch (regnum)
        {
        case SPARC64_CWP_REGNUM:


@@ -435,17 +470,17 @@ sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 /* Normal frames.  */
 
 static struct sparc_frame_cache *
 /* Normal frames.  */
 
 static struct sparc_frame_cache *

-sparc64_frame_cache (struct frame_info *next_frame, void **this_cache)
+sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)

 {
 {

-  return sparc_frame_cache (next_frame, this_cache);
+  return sparc_frame_cache (this_frame, this_cache);

 }
 
 static void
 }
 
 static void

-sparc64_frame_this_id (struct frame_info *next_frame, void **this_cache,
+sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,

                       struct frame_id *this_id)
 {
   struct sparc_frame_cache *cache =
                       struct frame_id *this_id)
 {
   struct sparc_frame_cache *cache =

-    sparc64_frame_cache (next_frame, this_cache);
+    sparc64_frame_cache (this_frame, this_cache);

 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)


@@ -454,52 +489,35 @@ sparc64_frame_this_id (struct frame_info *next_frame, void **this_cache,
   (*this_id) = frame_id_build (cache->base, cache->pc);
 }
 
   (*this_id) = frame_id_build (cache->base, cache->pc);
 }
 

-static void
-sparc64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
-                            int regnum, int *optimizedp,
-                            enum lval_type *lvalp, CORE_ADDR *addrp,
-                            int *realnump, gdb_byte *valuep)
+static struct value *
+sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+                            int regnum)

 {
 {

+  struct gdbarch *gdbarch = get_frame_arch (this_frame);

   struct sparc_frame_cache *cache =
   struct sparc_frame_cache *cache =

-    sparc64_frame_cache (next_frame, this_cache);
+    sparc64_frame_cache (this_frame, this_cache);

 
   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
     {
 
   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
     {

-      *optimizedp = 0;
-      *lvalp = not_lval;
-      *addrp = 0;
-      *realnump = -1;
-      if (valuep)
-       {
-         CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
+      CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;

 
 

-         regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
-         pc += frame_unwind_register_unsigned (next_frame, regnum) + 8;
-         store_unsigned_integer (valuep, 8, pc);
-       }
-      return;
+      regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
+      pc += get_frame_register_unsigned (this_frame, regnum) + 8;
+      return frame_unwind_got_constant (this_frame, regnum, pc);

     }
 
   /* Handle StackGhost.  */
   {
     }
 
   /* Handle StackGhost.  */
   {

-    ULONGEST wcookie = sparc_fetch_wcookie ();
+    ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);

 
     if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
       {
 
     if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
       {

-       *optimizedp = 0;
-       *lvalp = not_lval;
-       *addrp = 0;
-       *realnump = -1;
-       if (valuep)
-         {
-           CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
-           ULONGEST i7;
-
-           /* Read the value in from memory.  */
-           i7 = get_frame_memory_unsigned (next_frame, addr, 8);
-           store_unsigned_integer (valuep, 8, i7 ^ wcookie);
-         }
-       return;
+        CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
+        ULONGEST i7;
+
+        /* Read the value in from memory.  */
+        i7 = get_frame_memory_unsigned (this_frame, addr, 8);
+        return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);

       }
   }
 
       }
   }
 


@@ -508,18 +526,9 @@ sparc64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
   if (!cache->frameless_p
       && regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)
     {
   if (!cache->frameless_p
       && regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)
     {

-      *optimizedp = 0;
-      *lvalp = lval_memory;
-      *addrp = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
-      *realnump = -1;
-      if (valuep)
-       {
-         struct gdbarch *gdbarch = get_frame_arch (next_frame);
+      CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;

 
 

-         /* Read the value in from memory.  */
-         read_memory (*addrp, valuep, register_size (gdbarch, regnum));
-       }
-      return;
+      return frame_unwind_got_memory (this_frame, regnum, addr);

     }
 
   /* The previous frame's `out' registers are accessable as the
     }
 
   /* The previous frame's `out' registers are accessable as the


@@ -528,33 +537,24 @@ sparc64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
       && regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
     regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
 
       && regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
     regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
 

-  *optimizedp = 0;
-  *lvalp = lval_register;
-  *addrp = 0;
-  *realnump = regnum;
-  if (valuep)
-    frame_unwind_register (next_frame, regnum, valuep);
+  return frame_unwind_got_register (this_frame, regnum, regnum);

 }
 
 static const struct frame_unwind sparc64_frame_unwind =
 {
   NORMAL_FRAME,
   sparc64_frame_this_id,
 }
 
 static const struct frame_unwind sparc64_frame_unwind =
 {
   NORMAL_FRAME,
   sparc64_frame_this_id,

-  sparc64_frame_prev_register
+  sparc64_frame_prev_register,
+  NULL,
+  default_frame_sniffer

 };
 };

-
-static const struct frame_unwind *
-sparc64_frame_sniffer (struct frame_info *next_frame)
-{
-  return &sparc64_frame_unwind;
-}

 \f
 
 static CORE_ADDR
 \f
 
 static CORE_ADDR

-sparc64_frame_base_address (struct frame_info *next_frame, void **this_cache)
+sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)

 {
   struct sparc_frame_cache *cache =
 {
   struct sparc_frame_cache *cache =

-    sparc64_frame_cache (next_frame, this_cache);
+    sparc64_frame_cache (this_frame, this_cache);

 
   return cache->base;
 }
 
   return cache->base;
 }


@@ -723,6 +723,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
                         struct value **args, CORE_ADDR sp,
                         int struct_return, CORE_ADDR struct_addr)
 {
                         struct value **args, CORE_ADDR sp,
                         int struct_return, CORE_ADDR struct_addr)
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   /* Number of extended words in the "parameter array".  */
   int num_elements = 0;
   int element = 0;
   /* Number of extended words in the "parameter array".  */
   int num_elements = 0;
   int element = 0;


@@ -804,7 +805,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
             caller to an extended word according to the signed-ness
             of the argument type."  */
          if (len < 8)
             caller to an extended word according to the signed-ness
             of the argument type."  */
          if (len < 8)

-           args[i] = value_cast (builtin_type_int64, args[i]);
+           args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
+                                 args[i]);

          num_elements++;
        }
     }
          num_elements++;
        }
     }


@@ -935,6 +937,13 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
   return sp;
 }
 
   return sp;
 }
 

+static CORE_ADDR
+sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
+{
+  /* The ABI requires 16-byte alignment.  */
+  return address & ~0xf;
+}
+

 static CORE_ADDR
 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                         struct regcache *regcache, CORE_ADDR bp_addr,
 static CORE_ADDR
 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                         struct regcache *regcache, CORE_ADDR bp_addr,


@@ -1086,7 +1095,7 @@ sparc64_return_value (struct gdbarch *gdbarch, struct type *func_type,
 static void
 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
                               struct dwarf2_frame_state_reg *reg,
 static void
 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
                               struct dwarf2_frame_state_reg *reg,

-                              struct frame_info *next_frame)
+                              struct frame_info *this_frame)

 {
   switch (regnum)
     {
 {
   switch (regnum)
     {


@@ -1134,6 +1143,7 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
   set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
 
   /* Call dummy code.  */
   set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
 
   /* Call dummy code.  */

+  set_gdbarch_frame_align (gdbarch, sparc64_frame_align);

   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
   set_gdbarch_push_dummy_code (gdbarch, NULL);
   set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
   set_gdbarch_push_dummy_code (gdbarch, NULL);
   set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);


@@ -1149,7 +1159,7 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
   /* FIXME: kettenis/20050423: Don't enable the unwinder until the
      StackGhost issues have been resolved.  */
 
   /* FIXME: kettenis/20050423: Don't enable the unwinder until the
      StackGhost issues have been resolved.  */
 

-  frame_unwind_append_sniffer (gdbarch, sparc64_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);

   frame_base_set_default (gdbarch, &sparc64_frame_base);
 }
 \f
   frame_base_set_default (gdbarch, &sparc64_frame_base);
 }
 \f


@@ -1172,7 +1182,9 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
                        struct regcache *regcache,
                        int regnum, const void *gregs)
 {
                        struct regcache *regcache,
                        int regnum, const void *gregs)
 {

-  int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);

   const gdb_byte *regs = gregs;
   int i;
 
   const gdb_byte *regs = gregs;
   int i;
 


@@ -1184,10 +1196,10 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
          ULONGEST tstate, psr;
          gdb_byte buf[4];
 
          ULONGEST tstate, psr;
          gdb_byte buf[4];
 

-         tstate = extract_unsigned_integer (regs + offset, 8);
+         tstate = extract_unsigned_integer (regs + offset, 8, byte_order);

          psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
                 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
          psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
                 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);

-         store_unsigned_integer (buf, 4, psr);
+         store_unsigned_integer (buf, 4, byte_order, psr);

          regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
        }
 
          regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
        }
 


@@ -1286,7 +1298,9 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
                         const struct regcache *regcache,
                         int regnum, void *gregs)
 {
                         const struct regcache *regcache,
                         int regnum, void *gregs)
 {

-  int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);

   gdb_byte *regs = gregs;
   int i;
 
   gdb_byte *regs = gregs;
   int i;
 


@@ -1298,13 +1312,13 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
          ULONGEST tstate, psr;
          gdb_byte buf[8];
 
          ULONGEST tstate, psr;
          gdb_byte buf[8];
 

-         tstate = extract_unsigned_integer (regs + offset, 8);
+         tstate = extract_unsigned_integer (regs + offset, 8, byte_order);

          regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
          regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);

-         psr = extract_unsigned_integer (buf, 4);
+         psr = extract_unsigned_integer (buf, 4, byte_order);

          tstate |= (psr & PSR_ICC) << 12;
          if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
            tstate |= (psr & PSR_XCC) << 20;
          tstate |= (psr & PSR_ICC) << 12;
          if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
            tstate |= (psr & PSR_XCC) << 20;

-         store_unsigned_integer (buf, 8, tstate);
+         store_unsigned_integer (buf, 8, byte_order, tstate);

          memcpy (regs + offset, buf, 8);
        }
 
          memcpy (regs + offset, buf, 8);
        }
 


@@ -1459,13 +1473,3 @@ sparc64_collect_fpregset (const struct regcache *regcache,
     }
 }
 
     }
 }
 

-
-/* Provide a prototype to silence -Wmissing-prototypes.  */
-void _initialize_sparc64_tdep (void);
-
-void
-_initialize_sparc64_tdep (void)
-{
-  /* Initialize the UltraSPARC-specific register types.  */
-  sparc64_init_types();
-}