* defs.h (extract_signed_integer, extract_unsigned_integer,

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

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 59d6f9f29a27a9b07e6dd8357f4834007b9806ca..bf711f0e6dddaac6f5f04d0cb7f522cfeebd2cbc 100644 (file)
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -1,12 +1,13 @@
 /* Target-dependent code for SPARC.
 
 /* Target-dependent code for SPARC.
 

-   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
+   Free Software Foundation, Inc.

 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "arch-utils.h"
 
 #include "defs.h"
 #include "arch-utils.h"


@@ -100,7 +99,7 @@ sparc_fetch_instruction (CORE_ADDR pc)
   int i;
 
   /* If we can't read the instruction at PC, return zero.  */
   int i;
 
   /* If we can't read the instruction at PC, return zero.  */

-  if (read_memory_nobpt (pc, buf, sizeof (buf)))
+  if (target_read_memory (pc, buf, sizeof (buf)))

     return 0;
 
   insn = 0;
     return 0;
 
   insn = 0;


@@ -153,8 +152,9 @@ sparc_is_unimp_insn (CORE_ADDR pc)
 /* Fetch StackGhost Per-Process XOR cookie.  */
 
 ULONGEST
 /* Fetch StackGhost Per-Process XOR cookie.  */
 
 ULONGEST

-sparc_fetch_wcookie (void)
+sparc_fetch_wcookie (struct gdbarch *gdbarch)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   struct target_ops *ops = &current_target;
   gdb_byte buf[8];
   int len;
   struct target_ops *ops = &current_target;
   gdb_byte buf[8];
   int len;


@@ -166,7 +166,7 @@ sparc_fetch_wcookie (void)
   /* We should have either an 32-bit or an 64-bit cookie.  */
   gdb_assert (len == 4 || len == 8);
 
   /* We should have either an 32-bit or an 64-bit cookie.  */
   gdb_assert (len == 4 || len == 8);
 

-  return extract_unsigned_integer (buf, len);
+  return extract_unsigned_integer (buf, len, byte_order);

 }
 \f
 
 }
 \f
 


@@ -273,7 +273,7 @@ static const char *sparc32_pseudo_register_names[] =
 /* Return the name of register REGNUM.  */
 
 static const char *
 /* Return the name of register REGNUM.  */
 
 static const char *

-sparc32_register_name (int regnum)
+sparc32_register_name (struct gdbarch *gdbarch, int regnum)

 {
   if (regnum >= 0 && regnum < SPARC32_NUM_REGS)
     return sparc32_register_names[regnum];
 {
   if (regnum >= 0 && regnum < SPARC32_NUM_REGS)
     return sparc32_register_names[regnum];


@@ -284,46 +284,61 @@ sparc32_register_name (int regnum)
   return NULL;
 }
 \f
   return NULL;
 }
 \f

+/* Construct types for ISA-specific registers.  */
+
+static struct type *
+sparc_psr_type (struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-/* Type for %psr.  */
-struct type *sparc_psr_type;
+  if (!tdep->sparc_psr_type)
+    {
+      struct type *type;

 
 

-/* Type for %fsr.  */
-struct type *sparc_fsr_type;
+      type = arch_flags_type (gdbarch, "builtin_type_sparc_psr", 4);
+      append_flags_type_flag (type, 5, "ET");
+      append_flags_type_flag (type, 6, "PS");
+      append_flags_type_flag (type, 7, "S");
+      append_flags_type_flag (type, 12, "EF");
+      append_flags_type_flag (type, 13, "EC");

 
 

-/* Construct types for ISA-specific registers.  */
+      tdep->sparc_psr_type = type;
+    }

 
 

-static void
-sparc_init_types (void)
+  return tdep->sparc_psr_type;
+}
+
+static struct type *
+sparc_fsr_type (struct gdbarch *gdbarch)

 {
 {

-  struct type *type;
-
-  type = init_flags_type ("builtin_type_sparc_psr", 4);
-  append_flags_type_flag (type, 5, "ET");
-  append_flags_type_flag (type, 6, "PS");
-  append_flags_type_flag (type, 7, "S");
-  append_flags_type_flag (type, 12, "EF");
-  append_flags_type_flag (type, 13, "EC");
-  sparc_psr_type = type;
-
-  type = init_flags_type ("builtin_type_sparc_fsr", 4);
-  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");
-  sparc_fsr_type = type;
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  if (!tdep->sparc_fsr_type)
+    {
+      struct type *type;
+
+      type = arch_flags_type (gdbarch, "builtin_type_sparc_fsr", 4);
+      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->sparc_fsr_type = type;
+    }
+
+  return tdep->sparc_fsr_type;

 }
 
 /* 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


@@ -333,24 +348,24 @@ static struct type *
 sparc32_register_type (struct gdbarch *gdbarch, int regnum)
 {
   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
 sparc32_register_type (struct gdbarch *gdbarch, int regnum)
 {
   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)

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

 
   if (regnum >= SPARC32_D0_REGNUM && regnum <= SPARC32_D30_REGNUM)
 
   if (regnum >= SPARC32_D0_REGNUM && regnum <= SPARC32_D30_REGNUM)

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

 
   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
 
   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)

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

 
   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
 
   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)

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

 
   if (regnum == SPARC32_PSR_REGNUM)
 
   if (regnum == SPARC32_PSR_REGNUM)

-    return sparc_psr_type;
+    return sparc_psr_type (gdbarch);

 
   if (regnum == SPARC32_FSR_REGNUM)
 
   if (regnum == SPARC32_FSR_REGNUM)

-    return sparc_fsr_type;
+    return sparc_fsr_type (gdbarch);

 
 

-  return builtin_type_int32;
+  return builtin_type (gdbarch)->builtin_int32;

 }
 
 static void
 }
 
 static void


@@ -380,21 +395,24 @@ sparc32_pseudo_register_write (struct gdbarch *gdbarch,
 
 static CORE_ADDR
 sparc32_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
 
 static CORE_ADDR
 sparc32_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,

-                        CORE_ADDR funcaddr, int using_gcc,
+                        CORE_ADDR funcaddr,

                         struct value **args, int nargs,
                         struct type *value_type,
                         CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
                         struct regcache *regcache)
 {
                         struct value **args, int nargs,
                         struct type *value_type,
                         CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
                         struct regcache *regcache)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+

   *bp_addr = sp - 4;
   *real_pc = funcaddr;
 
   *bp_addr = sp - 4;
   *real_pc = funcaddr;
 

-  if (using_struct_return (value_type, using_gcc))
+  if (using_struct_return (gdbarch, NULL, value_type))

     {
       gdb_byte buf[4];
 
       /* This is an UNIMP instruction.  */
     {
       gdb_byte buf[4];
 
       /* This is an UNIMP instruction.  */

-      store_unsigned_integer (buf, 4, TYPE_LENGTH (value_type) & 0x1fff);
+      store_unsigned_integer (buf, 4, byte_order,
+                             TYPE_LENGTH (value_type) & 0x1fff);

       write_memory (sp - 8, buf, 4);
       return sp - 8;
     }
       write_memory (sp - 8, buf, 4);
       return sp - 8;
     }


@@ -407,6 +425,8 @@ sparc32_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);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

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


@@ -443,7 +463,8 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
          gdb_assert (sparc_integral_or_pointer_p (type));
 
          if (len < 4)
          gdb_assert (sparc_integral_or_pointer_p (type));
 
          if (len < 4)

-           args[i] = value_cast (builtin_type_int32, args[i]);
+           args[i] = value_cast (builtin_type (gdbarch)->builtin_int32,
+                                 args[i]);

          num_elements += ((len + 3) / 4);
        }
     }
          num_elements += ((len + 3) / 4);
        }
     }


@@ -488,7 +509,7 @@ sparc32_store_arguments (struct regcache *regcache, int nargs,
     {
       gdb_byte buf[4];
 
     {
       gdb_byte buf[4];
 

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

       write_memory (sp, buf, 4);
     }
 
       write_memory (sp, buf, 4);
     }
 


@@ -530,7 +551,7 @@ sparc32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
    location for inserting the breakpoint.  */
    
 static const gdb_byte *
    location for inserting the breakpoint.  */
    
 static const gdb_byte *

-sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
+sparc_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)

 {
   static const gdb_byte break_insn[] = { 0x91, 0xd0, 0x20, 0x01 };
 
 {
   static const gdb_byte break_insn[] = { 0x91, 0xd0, 0x20, 0x01 };
 


@@ -712,10 +733,10 @@ sparc_skip_stack_check (const CORE_ADDR start_pc)
 }
 
 CORE_ADDR
 }
 
 CORE_ADDR

-sparc_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
-                       struct sparc_frame_cache *cache)
+sparc_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
+                       CORE_ADDR current_pc, struct sparc_frame_cache *cache)

 {
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   unsigned long insn;
   int offset = 0;
   int dest = -1;
   unsigned long insn;
   int offset = 0;
   int dest = -1;


@@ -769,17 +790,17 @@ sparc_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
 }
 
 static CORE_ADDR
 }
 
 static CORE_ADDR

-sparc_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+sparc_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)

 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

-  return frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
+  return frame_unwind_register_unsigned (this_frame, tdep->pc_regnum);

 }
 
 /* Return PC of first real instruction of the function starting at
    START_PC.  */
 
 static CORE_ADDR
 }
 
 /* Return PC of first real instruction of the function starting at
    START_PC.  */
 
 static CORE_ADDR

-sparc32_skip_prologue (CORE_ADDR start_pc)
+sparc32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)

 {
   struct symtab_and_line sal;
   CORE_ADDR func_start, func_end;
 {
   struct symtab_and_line sal;
   CORE_ADDR func_start, func_end;


@@ -796,7 +817,7 @@ sparc32_skip_prologue (CORE_ADDR start_pc)
        return sal.end;
     }
 
        return sal.end;
     }
 

-  start_pc = sparc_analyze_prologue (start_pc, 0xffffffffUL, &cache);
+  start_pc = sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffUL, &cache);

 
   /* The psABI says that "Although the first 6 words of arguments
      reside in registers, the standard stack frame reserves space for
 
   /* The psABI says that "Although the first 6 words of arguments
      reside in registers, the standard stack frame reserves space for


@@ -831,7 +852,7 @@ sparc32_skip_prologue (CORE_ADDR start_pc)
 /* Normal frames.  */
 
 struct sparc_frame_cache *
 /* Normal frames.  */
 
 struct sparc_frame_cache *

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

 {
   struct sparc_frame_cache *cache;
 
 {
   struct sparc_frame_cache *cache;
 


@@ -841,9 +862,10 @@ sparc_frame_cache (struct frame_info *next_frame, void **this_cache)
   cache = sparc_alloc_frame_cache ();
   *this_cache = cache;
 
   cache = sparc_alloc_frame_cache ();
   *this_cache = cache;
 

-  cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
+  cache->pc = get_frame_func (this_frame);

   if (cache->pc != 0)
   if (cache->pc != 0)

-    sparc_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache);
+    sparc_analyze_prologue (get_frame_arch (this_frame), cache->pc,
+                           get_frame_pc (this_frame), cache);

 
   if (cache->frameless_p)
     {
 
   if (cache->frameless_p)
     {


@@ -851,14 +873,14 @@ sparc_frame_cache (struct frame_info *next_frame, void **this_cache)
          pointer for our calling frame.  Use %sp (%o6) as this frame's
          base address.  */
       cache->base =
          pointer for our calling frame.  Use %sp (%o6) as this frame's
          base address.  */
       cache->base =

-       frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
+        get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);

     }
   else
     {
       /* For normal frames, %fp (%i6) holds the frame pointer, the
          base address for the current stack frame.  */
       cache->base =
     }
   else
     {
       /* For normal frames, %fp (%i6) holds the frame pointer, the
          base address for the current stack frame.  */
       cache->base =

-       frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
+       get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);

     }
 
   if (cache->base & 1)
     }
 
   if (cache->base & 1)


@@ -885,7 +907,7 @@ sparc32_struct_return_from_sym (struct symbol *sym)
 }
 
 struct sparc_frame_cache *
 }
 
 struct sparc_frame_cache *

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

 {
   struct sparc_frame_cache *cache;
   struct symbol *sym;
 {
   struct sparc_frame_cache *cache;
   struct symbol *sym;


@@ -893,7 +915,7 @@ sparc32_frame_cache (struct frame_info *next_frame, void **this_cache)
   if (*this_cache)
     return *this_cache;
 
   if (*this_cache)
     return *this_cache;
 

-  cache = sparc_frame_cache (next_frame, this_cache);
+  cache = sparc_frame_cache (this_frame, this_cache);

 
   sym = find_pc_function (cache->pc);
   if (sym)
 
   sym = find_pc_function (cache->pc);
   if (sym)


@@ -911,7 +933,7 @@ sparc32_frame_cache (struct frame_info *next_frame, void **this_cache)
       CORE_ADDR pc;
       int regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
 
       CORE_ADDR pc;
       int regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
 

-      pc = frame_unwind_register_unsigned (next_frame, regnum) + 8;
+      pc = get_frame_register_unsigned (this_frame, regnum) + 8;

       if (sparc_is_unimp_insn (pc))
         cache->struct_return_p = 1;
     }
       if (sparc_is_unimp_insn (pc))
         cache->struct_return_p = 1;
     }


@@ -920,11 +942,11 @@ sparc32_frame_cache (struct frame_info *next_frame, void **this_cache)
 }
 
 static void
 }
 
 static void

-sparc32_frame_this_id (struct frame_info *next_frame, void **this_cache,
+sparc32_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 =

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

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


@@ -933,58 +955,41 @@ sparc32_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
-sparc32_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 *
+sparc32_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 =

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

 
   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
     {
 
   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
     {

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

 
 

-         /* If this functions has a Structure, Union or
-             Quad-Precision return value, we have to skip the UNIMP
-             instruction that encodes the size of the structure.  */
-         if (cache->struct_return_p)
-           pc += 4;
+      /* If this functions has a Structure, Union or Quad-Precision
+        return value, we have to skip the UNIMP instruction that encodes
+        the size of the structure.  */
+      if (cache->struct_return_p)
+       pc += 4;

 
 

-         regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
-         pc += frame_unwind_register_unsigned (next_frame, regnum) + 8;
-         store_unsigned_integer (valuep, 4, 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) * 4;
-           ULONGEST i7;
-
-           /* Read the value in from memory.  */
-           i7 = get_frame_memory_unsigned (next_frame, addr, 4);
-           store_unsigned_integer (valuep, 4, i7 ^ wcookie);
-         }
-       return;
+        CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 4;
+        ULONGEST i7;
+
+        /* Read the value in from memory.  */
+        i7 = get_frame_memory_unsigned (this_frame, addr, 4);
+        return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);

       }
   }
 
       }
   }
 


@@ -993,53 +998,35 @@ sparc32_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) * 4;
-      *realnump = -1;
-      if (valuep)
-       {
-         struct gdbarch *gdbarch = get_frame_arch (next_frame);
+      CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 4;

 
 

-         /* 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 accessible as the

      current frame's `in' registers.  */
   if (!cache->frameless_p
       && regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
     regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
 
      current frame's `in' registers.  */
   if (!cache->frameless_p
       && 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, (*realnump), valuep);
+  return frame_unwind_got_register (this_frame, regnum, regnum);

 }
 
 static const struct frame_unwind sparc32_frame_unwind =
 {
   NORMAL_FRAME,
   sparc32_frame_this_id,
 }
 
 static const struct frame_unwind sparc32_frame_unwind =
 {
   NORMAL_FRAME,
   sparc32_frame_this_id,

-  sparc32_frame_prev_register
+  sparc32_frame_prev_register,
+  NULL,
+  default_frame_sniffer

 };
 };

-
-static const struct frame_unwind *
-sparc32_frame_sniffer (struct frame_info *next_frame)
-{
-  return &sparc32_frame_unwind;
-}

 \f
 
 static CORE_ADDR
 \f
 
 static CORE_ADDR

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

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

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

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


@@ -1053,19 +1040,19 @@ static const struct frame_base sparc32_frame_base =
 };
 
 static struct frame_id
 };
 
 static struct frame_id

-sparc_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+sparc_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)

 {
   CORE_ADDR sp;
 
 {
   CORE_ADDR sp;
 

-  sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
+  sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);

   if (sp & 1)
     sp += BIAS;
   if (sp & 1)
     sp += BIAS;

-  return frame_id_build (sp, frame_pc_unwind (next_frame));
+  return frame_id_build (sp, get_frame_pc (this_frame));

 }
 \f
 
 }
 \f
 

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

 
 static void
 sparc32_extract_return_value (struct type *type, struct regcache *regcache,
 
 static void
 sparc32_extract_return_value (struct type *type, struct regcache *regcache,


@@ -1106,8 +1093,8 @@ sparc32_extract_return_value (struct type *type, struct regcache *regcache,
     }
 }
 
     }
 }
 

-/* Write into the appropriate registers a function return value stored
-   in VALBUF of type TYPE.  */
+/* Store the function return value of type TYPE from VALBUF into
+   REGCACHE.  */

 
 static void
 sparc32_store_return_value (struct type *type, struct regcache *regcache,
 
 static void
 sparc32_store_return_value (struct type *type, struct regcache *regcache,


@@ -1148,10 +1135,12 @@ sparc32_store_return_value (struct type *type, struct regcache *regcache,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention

-sparc32_return_value (struct gdbarch *gdbarch, struct type *type,
-                     struct regcache *regcache, gdb_byte *readbuf,
-                     const gdb_byte *writebuf)
+sparc32_return_value (struct gdbarch *gdbarch, struct type *func_type,
+                     struct type *type, struct regcache *regcache,
+                     gdb_byte *readbuf, const gdb_byte *writebuf)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+

   /* The psABI says that "...every stack frame reserves the word at
      %fp+64.  If a function returns a structure, union, or
      quad-precision value, this word should hold the address of the
   /* The psABI says that "...every stack frame reserves the word at
      %fp+64.  If a function returns a structure, union, or
      quad-precision value, this word should hold the address of the


@@ -1168,7 +1157,7 @@ sparc32_return_value (struct gdbarch *gdbarch, struct type *type,
          CORE_ADDR addr;
 
          regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
          CORE_ADDR addr;
 
          regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);

-         addr = read_memory_unsigned_integer (sp + 64, 4);
+         addr = read_memory_unsigned_integer (sp + 64, 4, byte_order);

          read_memory (addr, readbuf, TYPE_LENGTH (type));
        }
 
          read_memory (addr, readbuf, TYPE_LENGTH (type));
        }
 


@@ -1191,9 +1180,9 @@ sparc32_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 }
 
 static int
 }
 
 static int

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

 {
 {

-  CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+  CORE_ADDR pc = get_frame_address_in_block (this_frame);

   struct symbol *sym = find_pc_function (pc);
 
   if (sym)
   struct symbol *sym = find_pc_function (pc);
 
   if (sym)


@@ -1204,7 +1193,7 @@ sparc32_dwarf2_struct_return_p (struct frame_info *next_frame)
 static void
 sparc32_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
                               struct dwarf2_frame_state_reg *reg,
 static void
 sparc32_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)

 {
   int off;
 
 {
   int off;
 


@@ -1223,7 +1212,7 @@ sparc32_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
     case SPARC32_NPC_REGNUM:
       reg->how = DWARF2_FRAME_REG_RA_OFFSET;
       off = 8;
     case SPARC32_NPC_REGNUM:
       reg->how = DWARF2_FRAME_REG_RA_OFFSET;
       off = 8;

-      if (sparc32_dwarf2_struct_return_p (next_frame))
+      if (sparc32_dwarf2_struct_return_p (this_frame))

        off += 4;
       if (regnum == SPARC32_NPC_REGNUM)
        off += 4;
        off += 4;
       if (regnum == SPARC32_NPC_REGNUM)
        off += 4;


@@ -1333,10 +1322,10 @@ sparc_software_single_step (struct frame_info *frame)
   /* Analyze the instruction at PC.  */
   nnpc = sparc_analyze_control_transfer (frame, pc, &npc);
   if (npc != 0)
   /* Analyze the instruction at PC.  */
   nnpc = sparc_analyze_control_transfer (frame, pc, &npc);
   if (npc != 0)

-    insert_single_step_breakpoint (npc);
+    insert_single_step_breakpoint (arch, npc);

 
   if (nnpc != 0)
 
   if (nnpc != 0)

-    insert_single_step_breakpoint (nnpc);
+    insert_single_step_breakpoint (arch, nnpc);

 
   /* Assert that we have set at least one breakpoint, and that
      they're not set at the same spot - unless we're going
 
   /* Assert that we have set at least one breakpoint, and that
      they're not set at the same spot - unless we're going


@@ -1348,50 +1337,19 @@ sparc_software_single_step (struct frame_info *frame)
 }
 
 static void
 }
 
 static void

-sparc_write_pc (CORE_ADDR pc, ptid_t ptid)
+sparc_write_pc (struct regcache *regcache, CORE_ADDR pc)

 {
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

 
 

-  write_register_pid (tdep->pc_regnum, pc, ptid);
-  write_register_pid (tdep->npc_regnum, pc + 4, ptid);
-}
-\f
-/* Unglobalize NAME.  */
-
-char *
-sparc_stabs_unglobalize_name (char *name)
-{
-  /* The Sun compilers (Sun ONE Studio, Forte Developer, Sun WorkShop,
-     SunPRO) convert file static variables into global values, a
-     process known as globalization.  In order to do this, the
-     compiler will create a unique prefix and prepend it to each file
-     static variable.  For static variables within a function, this
-     globalization prefix is followed by the function name (nested
-     static variables within a function are supposed to generate a
-     warning message, and are left alone).  The procedure is
-     documented in the Stabs Interface Manual, which is distrubuted
-     with the compilers, although version 4.0 of the manual seems to
-     be incorrect in some places, at least for SPARC.  The
-     globalization prefix is encoded into an N_OPT stab, with the form
-     "G=<prefix>".  The globalization prefix always seems to start
-     with a dollar sign '$'; a dot '.' is used as a seperator.  So we
-     simply strip everything up until the last dot.  */
-
-  if (name[0] == '$')
-    {
-      char *p = strrchr (name, '.');
-      if (p)
-       return p + 1;
-    }
-
-  return name;
+  regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
+  regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);

 }
 \f
 
 /* Return the appropriate register set for the core section identified
    by SECT_NAME and SECT_SIZE.  */
 
 }
 \f
 
 /* Return the appropriate register set for the core section identified
    by SECT_NAME and SECT_SIZE.  */
 

-const struct regset *
+static const struct regset *

 sparc_regset_from_core_section (struct gdbarch *gdbarch,
                                const char *sect_name, size_t sect_size)
 {
 sparc_regset_from_core_section (struct gdbarch *gdbarch,
                                const char *sect_name, size_t sect_size)
 {


@@ -1469,7 +1427,7 @@ sparc32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_software_single_step (gdbarch, sparc_software_single_step);
   set_gdbarch_write_pc (gdbarch, sparc_write_pc);
 
   set_gdbarch_software_single_step (gdbarch, sparc_software_single_step);
   set_gdbarch_write_pc (gdbarch, sparc_write_pc);
 

-  set_gdbarch_unwind_dummy_id (gdbarch, sparc_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, sparc_dummy_id);

 
   set_gdbarch_unwind_pc (gdbarch, sparc_unwind_pc);
 
 
   set_gdbarch_unwind_pc (gdbarch, sparc_unwind_pc);
 


@@ -1483,7 +1441,7 @@ sparc32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Hook in ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);
 
   /* Hook in ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);
 

-  frame_unwind_append_sniffer (gdbarch, sparc32_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &sparc32_frame_unwind);

 
   /* If we have register sets, enable the generic core file support.  */
   if (tdep->gregset)
 
   /* If we have register sets, enable the generic core file support.  */
   if (tdep->gregset)


@@ -1498,6 +1456,8 @@ sparc32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 void
 sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
 {
 void
 sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int offset = 0;
   gdb_byte buf[8];
   int i;
   int offset = 0;
   gdb_byte buf[8];
   int i;


@@ -1516,10 +1476,12 @@ sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {

-                 ULONGEST wcookie = sparc_fetch_wcookie ();
-                 ULONGEST i7 = extract_unsigned_integer (buf + offset, 8);
+                 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
+                 ULONGEST i7;

 
 

-                 store_unsigned_integer (buf + offset, 8, i7 ^ wcookie);
+                 i7 = extract_unsigned_integer (buf + offset, 8, byte_order);
+                 store_unsigned_integer (buf + offset, 8, byte_order,
+                                         i7 ^ wcookie);

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


@@ -1534,7 +1496,7 @@ sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
 
       /* Clear out the top half of the temporary buffer, and put the
         register value in the bottom half if we're in 64-bit mode.  */
 
       /* Clear out the top half of the temporary buffer, and put the
         register value in the bottom half if we're in 64-bit mode.  */

-      if (gdbarch_ptr_bit (current_gdbarch) == 64)
+      if (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 64)

        {
          memset (buf, 0, 4);
          offset = 4;
        {
          memset (buf, 0, 4);
          offset = 4;


@@ -1550,10 +1512,12 @@ sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {

-                 ULONGEST wcookie = sparc_fetch_wcookie ();
-                 ULONGEST i7 = extract_unsigned_integer (buf + offset, 4);
+                 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
+                 ULONGEST i7;

 
 

-                 store_unsigned_integer (buf + offset, 4, i7 ^ wcookie);
+                 i7 = extract_unsigned_integer (buf + offset, 4, byte_order);
+                 store_unsigned_integer (buf + offset, 4, byte_order,
+                                         i7 ^ wcookie);

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


@@ -1566,6 +1530,8 @@ void
 sparc_collect_rwindow (const struct regcache *regcache,
                       CORE_ADDR sp, int regnum)
 {
 sparc_collect_rwindow (const struct regcache *regcache,
                       CORE_ADDR sp, int regnum)
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int offset = 0;
   gdb_byte buf[8];
   int i;
   int offset = 0;
   gdb_byte buf[8];
   int i;


@@ -1584,10 +1550,11 @@ sparc_collect_rwindow (const struct regcache *regcache,
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {

-                 ULONGEST wcookie = sparc_fetch_wcookie ();
-                 ULONGEST i7 = extract_unsigned_integer (buf + offset, 8);
+                 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
+                 ULONGEST i7;

 
 

-                 store_unsigned_integer (buf, 8, i7 ^ wcookie);
+                 i7 = extract_unsigned_integer (buf + offset, 8, byte_order);
+                 store_unsigned_integer (buf, 8, byte_order, i7 ^ wcookie);

                }
 
              target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 8), buf, 8);
                }
 
              target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 8), buf, 8);


@@ -1601,7 +1568,7 @@ sparc_collect_rwindow (const struct regcache *regcache,
       sp &= 0xffffffffUL;
 
       /* Only use the bottom half if we're in 64-bit mode.  */
       sp &= 0xffffffffUL;
 
       /* Only use the bottom half if we're in 64-bit mode.  */

-      if (gdbarch_ptr_bit (current_gdbarch) == 64)
+      if (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 64)

        offset = 4;
 
       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
        offset = 4;
 
       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)


@@ -1613,10 +1580,12 @@ sparc_collect_rwindow (const struct regcache *regcache,
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {
              /* Handle StackGhost.  */
              if (i == SPARC_I7_REGNUM)
                {

-                 ULONGEST wcookie = sparc_fetch_wcookie ();
-                 ULONGEST i7 = extract_unsigned_integer (buf + offset, 4);
+                 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
+                 ULONGEST i7;

 
 

-                 store_unsigned_integer (buf + offset, 4, i7 ^ wcookie);
+                 i7 = extract_unsigned_integer (buf + offset, 4, byte_order);
+                 store_unsigned_integer (buf + offset, 4, byte_order,
+                                         i7 ^ wcookie);

                }
 
              target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 4),
                }
 
              target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 4),


@@ -1805,7 +1774,4 @@ void
 _initialize_sparc_tdep (void)
 {
   register_gdbarch_init (bfd_arch_sparc, sparc32_gdbarch_init);
 _initialize_sparc_tdep (void)
 {
   register_gdbarch_init (bfd_arch_sparc, sparc32_gdbarch_init);

-
-  /* Initialize the SPARC-specific register types.  */
-  sparc_init_types();

 }
 }