projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Workaround for gcc/45682.
[deliverable/binutils-gdb.git] / gdb / sh64-tdep.c
diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index 62b68259f20c9eab5ebd664788d83b532fc4bbf1..8a64f97eb77e166afcf15e1148d7d5193594e5f2 100644 (file)
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -1,13 +1,13 @@
 /* Target-dependent code for Renesas Super-H, for GDB.
 
    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
 /* Target-dependent code for Renesas Super-H, for GDB.
 
    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2007 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2007, 2008, 2009, 2010 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,
@@ -16,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/>.  */
 
 /*
    Contributed by Steve Chamberlain
 
 /*
    Contributed by Steve Chamberlain
@@ -42,6 +40,7 @@
 #include "arch-utils.h"
 #include "regcache.h"
 #include "osabi.h"
 #include "arch-utils.h"
 #include "regcache.h"
 #include "osabi.h"
+#include "valprint.h"
 
 #include "elf-bfd.h"
 
 
 #include "elf-bfd.h"
 
@@ -49,6 +48,7 @@
 #include "elf/sh.h"
 /* registers numbers shared with the simulator */
 #include "gdb/sim-sh.h"
 #include "elf/sh.h"
 /* registers numbers shared with the simulator */
 #include "gdb/sim-sh.h"
+#include "language.h"
 
 /* Information that is dependent on the processor variant.  */
 enum sh_abi
 
 /* Information that is dependent on the processor variant.  */
 enum sh_abi
@@ -95,7 +95,7 @@ enum
     DR0_REGNUM = 141,
     DR_LAST_REGNUM = 172,
     /* FPP stands for Floating Point Pair, to avoid confusion with
     DR0_REGNUM = 141,
     DR_LAST_REGNUM = 172,
     /* FPP stands for Floating Point Pair, to avoid confusion with
-       GDB's FP0_REGNUM, which is the number of the first Floating
+       GDB's gdbarch_fp0_regnum, which is the number of the first Floating
        point register. Unfortunately on the sh5, the floating point
        registers are called FR, and the floating point pairs are called FP.  */
     FPP0_REGNUM = 173,
        point register. Unfortunately on the sh5, the floating point
        registers are called FR, and the floating point pairs are called FP.  */
     FPP0_REGNUM = 173,
@@ -126,7 +126,7 @@ enum
   };
 
 static const char *
   };
 
 static const char *
-sh64_register_name (int reg_nr)
+sh64_register_name (struct gdbarch *gdbarch, int reg_nr)
 {
   static char *register_names[] =
   {
 {
   static char *register_names[] =
   {
@@ -206,14 +206,13 @@ sh64_register_name (int reg_nr)
    symbol that marks it as 32-bit function.  The MSB of the minimal
    symbol's "info" field is used for this purpose.
 
    symbol that marks it as 32-bit function.  The MSB of the minimal
    symbol's "info" field is used for this purpose.
 
-   ELF_MAKE_MSYMBOL_SPECIAL
-   tests whether an ELF symbol is "special", i.e. refers
-   to a 32-bit function, and sets a "special" bit in a 
+   gdbarch_elf_make_msymbol_special tests whether an ELF symbol is "special",
+   i.e. refers to a 32-bit function, and sets a "special" bit in a
    minimal symbol to mark it as a 32-bit function
    MSYMBOL_IS_SPECIAL   tests the "special" bit in a minimal symbol  */
 
 #define MSYMBOL_IS_SPECIAL(msym) \
    minimal symbol to mark it as a 32-bit function
    MSYMBOL_IS_SPECIAL   tests the "special" bit in a minimal symbol  */
 
 #define MSYMBOL_IS_SPECIAL(msym) \
-  (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
+  MSYMBOL_TARGET_FLAG_1 (msym)
 
 static void
 sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 
 static void
 sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
@@ -223,7 +222,7 @@ sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 
   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
     {
 
   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
     {
-      MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) | 0x80000000);
+      MSYMBOL_TARGET_FLAG_1 (msym) = 1;
       SYMBOL_VALUE_ADDRESS (msym) |= 1;
     }
 }
       SYMBOL_VALUE_ADDRESS (msym) |= 1;
     }
 }
@@ -255,7 +254,7 @@ pc_is_isa32 (bfd_vma memaddr)
 }
 
 static const unsigned char *
 }
 
 static const unsigned char *
-sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+sh64_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
   /* The BRK instruction for shmedia is 
      01101111 11110101 11111111 11110000
 {
   /* The BRK instruction for shmedia is 
      01101111 11110101 11111111 11110000
@@ -267,7 +266,7 @@ sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
      which translates in big endian mode to 0x0, 0x3b
      and in little endian mode to 0x3b, 0x0*/
 
      which translates in big endian mode to 0x0, 0x3b
      and in little endian mode to 0x3b, 0x0*/
 
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
     {
       if (pc_is_isa32 (*pcptr))
        {
     {
       if (pc_is_isa32 (*pcptr))
        {
@@ -482,8 +481,10 @@ after_prologue (CORE_ADDR pc)
 }
 
 static CORE_ADDR 
 }
 
 static CORE_ADDR 
-look_for_args_moves (CORE_ADDR start_pc, int media_mode)
+look_for_args_moves (struct gdbarch *gdbarch,
+                    CORE_ADDR start_pc, int media_mode)
 {
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR here, end;
   int w;
   int insn_size = (media_mode ? 4 : 2);
   CORE_ADDR here, end;
   int w;
   int insn_size = (media_mode ? 4 : 2);
@@ -492,7 +493,8 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
     {
       if (media_mode)
        {
     {
       if (media_mode)
        {
-         w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
+         w = read_memory_integer (UNMAKE_ISA32_ADDR (here),
+                                  insn_size, byte_order);
          here += insn_size;
          if (IS_MEDIA_IND_ARG_MOV (w))
            {
          here += insn_size;
          if (IS_MEDIA_IND_ARG_MOV (w))
            {
@@ -501,7 +503,7 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
                 the SP has been saved, unfortunately.  */
         
              int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
                 the SP has been saved, unfortunately.  */
         
              int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
-                                                  insn_size);
+                                                  insn_size, byte_order);
              here += insn_size;
              if (IS_MEDIA_MOV_TO_R14 (next_insn))
                start_pc = here;          
              here += insn_size;
              if (IS_MEDIA_MOV_TO_R14 (next_insn))
                start_pc = here;          
@@ -516,7 +518,7 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
        }
       else
        {
        }
       else
        {
-         w = read_memory_integer (here, insn_size);
+         w = read_memory_integer (here, insn_size, byte_order);
          w = w & 0xffff;
          here += insn_size;
          if (IS_COMPACT_IND_ARG_MOV (w))
          w = w & 0xffff;
          here += insn_size;
          if (IS_COMPACT_IND_ARG_MOV (w))
@@ -525,7 +527,8 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
                 is where the debug info says it is. This can happen after
                 the SP has been saved, unfortunately.  */
         
                 is where the debug info says it is. This can happen after
                 the SP has been saved, unfortunately.  */
         
-             int next_insn = 0xffff & read_memory_integer (here, insn_size);
+             int next_insn = 0xffff & read_memory_integer (here, insn_size,
+                                                           byte_order);
              here += insn_size;
              if (IS_COMPACT_MOV_TO_R14 (next_insn))
                start_pc = here;
              here += insn_size;
              if (IS_COMPACT_MOV_TO_R14 (next_insn))
                start_pc = here;
@@ -558,11 +561,13 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
              /* This must be followed by a JSR @r0 instruction and by
                  a NOP instruction. After these, the prologue is over!  */
         
              /* This must be followed by a JSR @r0 instruction and by
                  a NOP instruction. After these, the prologue is over!  */
         
-             int next_insn = 0xffff & read_memory_integer (here, insn_size);
+             int next_insn = 0xffff & read_memory_integer (here, insn_size,
+                                                           byte_order);
              here += insn_size;
              if (IS_JSR_R0 (next_insn))
                {
              here += insn_size;
              if (IS_JSR_R0 (next_insn))
                {
-                 next_insn = 0xffff & read_memory_integer (here, insn_size);
+                 next_insn = 0xffff & read_memory_integer (here, insn_size,
+                                                           byte_order);
                  here += insn_size;
 
                  if (IS_NOP (next_insn))
                  here += insn_size;
 
                  if (IS_NOP (next_insn))
@@ -578,8 +583,9 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode)
 }
 
 static CORE_ADDR
 }
 
 static CORE_ADDR
-sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
+sh64_skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 {
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR here, end;
   int updated_fp = 0;
   int insn_size = 4;
   CORE_ADDR here, end;
   int updated_fp = 0;
   int insn_size = 4;
@@ -599,7 +605,8 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
 
       if (media_mode)
        {
 
       if (media_mode)
        {
-         int w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
+         int w = read_memory_integer (UNMAKE_ISA32_ADDR (here),
+                                      insn_size, byte_order);
          here += insn_size;
          if (IS_STQ_R18_R14 (w) || IS_STQ_R18_R15 (w) || IS_STQ_R14_R15 (w)
              || IS_STL_R14_R15 (w) || IS_STL_R18_R15 (w)
          here += insn_size;
          if (IS_STQ_R18_R14 (w) || IS_STQ_R18_R15 (w) || IS_STQ_R14_R15 (w)
              || IS_STL_R14_R15 (w) || IS_STL_R18_R15 (w)
@@ -618,13 +625,14 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
                /* Don't bail out yet, we may have arguments stored in
                   registers here, according to the debug info, so that
                   gdb can print the frames correctly.  */
                /* Don't bail out yet, we may have arguments stored in
                   registers here, according to the debug info, so that
                   gdb can print the frames correctly.  */
-               start_pc = look_for_args_moves (here - insn_size, media_mode);
+               start_pc = look_for_args_moves (gdbarch,
+                                               here - insn_size, media_mode);
                break;
              }
        }
       else
        {
                break;
              }
        }
       else
        {
-         int w = 0xffff & read_memory_integer (here, insn_size);
+         int w = 0xffff & read_memory_integer (here, insn_size, byte_order);
          here += insn_size;
 
          if (IS_STS_R0 (w) || IS_STS_PR (w)
          here += insn_size;
 
          if (IS_STS_R0 (w) || IS_STS_PR (w)
@@ -644,7 +652,8 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
                /* Don't bail out yet, we may have arguments stored in
                   registers here, according to the debug info, so that
                   gdb can print the frames correctly.  */
                /* Don't bail out yet, we may have arguments stored in
                   registers here, according to the debug info, so that
                   gdb can print the frames correctly.  */
-               start_pc = look_for_args_moves (here - insn_size, media_mode);
+               start_pc = look_for_args_moves (gdbarch,
+                                               here - insn_size, media_mode);
                break;
              }
        }
                break;
              }
        }
@@ -654,7 +663,7 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
 }
 
 static CORE_ADDR
 }
 
 static CORE_ADDR
-sh64_skip_prologue (CORE_ADDR pc)
+sh64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   CORE_ADDR post_prologue_pc;
 
 {
   CORE_ADDR post_prologue_pc;
 
@@ -668,7 +677,7 @@ sh64_skip_prologue (CORE_ADDR pc)
   if (post_prologue_pc != 0)
     return max (pc, post_prologue_pc);
   else
   if (post_prologue_pc != 0)
     return max (pc, post_prologue_pc);
   else
-    return sh64_skip_prologue_hard_way (pc);
+    return sh64_skip_prologue_hard_way (gdbarch, pc);
 }
 
 /* Should call_function allocate stack space for a struct return?  */
 }
 
 /* Should call_function allocate stack space for a struct return?  */
@@ -678,44 +687,33 @@ sh64_use_struct_convention (struct type *type)
   return (TYPE_LENGTH (type) > 8);
 }
 
   return (TYPE_LENGTH (type) > 8);
 }
 
-/* Disassemble an instruction.  */
-static int
-gdb_print_insn_sh64 (bfd_vma memaddr, disassemble_info *info)
-{
-  info->endian = TARGET_BYTE_ORDER;
-  return print_insn_sh (memaddr, info);
-}
-
 /* For vectors of 4 floating point registers.  */
 static int
 /* For vectors of 4 floating point registers.  */
 static int
-sh64_fv_reg_base_num (int fv_regnum)
+sh64_fv_reg_base_num (struct gdbarch *gdbarch, int fv_regnum)
 {
   int fp_regnum;
 
 {
   int fp_regnum;
 
-  fp_regnum = FP0_REGNUM + 
-    (fv_regnum - FV0_REGNUM) * 4;
+  fp_regnum = gdbarch_fp0_regnum (gdbarch) + (fv_regnum - FV0_REGNUM) * 4;
   return fp_regnum;
 }
 
 /* For double precision floating point registers, i.e 2 fp regs.*/
 static int
   return fp_regnum;
 }
 
 /* For double precision floating point registers, i.e 2 fp regs.*/
 static int
-sh64_dr_reg_base_num (int dr_regnum)
+sh64_dr_reg_base_num (struct gdbarch *gdbarch, int dr_regnum)
 {
   int fp_regnum;
 
 {
   int fp_regnum;
 
-  fp_regnum = FP0_REGNUM + 
-    (dr_regnum - DR0_REGNUM) * 2;
+  fp_regnum = gdbarch_fp0_regnum (gdbarch) + (dr_regnum - DR0_REGNUM) * 2;
   return fp_regnum;
 }
 
 /* For pairs of floating point registers */
 static int
   return fp_regnum;
 }
 
 /* For pairs of floating point registers */
 static int
-sh64_fpp_reg_base_num (int fpp_regnum)
+sh64_fpp_reg_base_num (struct gdbarch *gdbarch, int fpp_regnum)
 {
   int fp_regnum;
 
 {
   int fp_regnum;
 
-  fp_regnum = FP0_REGNUM + 
-    (fpp_regnum - FPP0_REGNUM) * 2;
+  fp_regnum = gdbarch_fp0_regnum (gdbarch) + (fpp_regnum - FPP0_REGNUM) * 2;
   return fp_regnum;
 }
 
   return fp_regnum;
 }
 
@@ -782,7 +780,7 @@ sh64_fpp_reg_base_num (int fpp_regnum)
 */
 /* *INDENT-ON* */
 static int
 */
 /* *INDENT-ON* */
 static int
-sh64_compact_reg_base_num (int reg_nr)
+sh64_compact_reg_base_num (struct gdbarch *gdbarch, int reg_nr)
 {
   int base_regnum = reg_nr;
 
 {
   int base_regnum = reg_nr;
 
@@ -794,20 +792,22 @@ sh64_compact_reg_base_num (int reg_nr)
   /* floating point register N maps to floating point register N */
   else if (reg_nr >= FP0_C_REGNUM 
            && reg_nr <= FP_LAST_C_REGNUM)
   /* floating point register N maps to floating point register N */
   else if (reg_nr >= FP0_C_REGNUM 
            && reg_nr <= FP_LAST_C_REGNUM)
-    base_regnum = reg_nr - FP0_C_REGNUM + FP0_REGNUM;
+    base_regnum = reg_nr - FP0_C_REGNUM + gdbarch_fp0_regnum (gdbarch);
 
   /* double prec register N maps to base regnum for double prec register N */
   else if (reg_nr >= DR0_C_REGNUM 
            && reg_nr <= DR_LAST_C_REGNUM)
 
   /* double prec register N maps to base regnum for double prec register N */
   else if (reg_nr >= DR0_C_REGNUM 
            && reg_nr <= DR_LAST_C_REGNUM)
-    base_regnum = sh64_dr_reg_base_num (DR0_REGNUM + reg_nr - DR0_C_REGNUM);
+    base_regnum = sh64_dr_reg_base_num (gdbarch,
+                                       DR0_REGNUM + reg_nr - DR0_C_REGNUM);
 
   /* vector N maps to base regnum for vector register N */
   else if (reg_nr >= FV0_C_REGNUM 
            && reg_nr <= FV_LAST_C_REGNUM)
 
   /* vector N maps to base regnum for vector register N */
   else if (reg_nr >= FV0_C_REGNUM 
            && reg_nr <= FV_LAST_C_REGNUM)
-    base_regnum = sh64_fv_reg_base_num (FV0_REGNUM + reg_nr - FV0_C_REGNUM);
+    base_regnum = sh64_fv_reg_base_num (gdbarch,
+                                       FV0_REGNUM + reg_nr - FV0_C_REGNUM);
 
   else if (reg_nr == PC_C_REGNUM)
 
   else if (reg_nr == PC_C_REGNUM)
-    base_regnum = PC_REGNUM;
+    base_regnum = gdbarch_pc_regnum (gdbarch);
 
   else if (reg_nr == GBR_C_REGNUM) 
     base_regnum = 16;
 
   else if (reg_nr == GBR_C_REGNUM) 
     base_regnum = 16;
@@ -826,7 +826,7 @@ sh64_compact_reg_base_num (int reg_nr)
     base_regnum = FPSCR_REGNUM; /*???? this register is a mess.  */
 
   else if (reg_nr == FPUL_C_REGNUM) 
     base_regnum = FPSCR_REGNUM; /*???? this register is a mess.  */
 
   else if (reg_nr == FPUL_C_REGNUM) 
-    base_regnum = FP0_REGNUM + 32;
+    base_regnum = gdbarch_fp0_regnum (gdbarch) + 32;
   
   return base_regnum;
 }
   
   return base_regnum;
 }
@@ -855,6 +855,7 @@ sh64_analyze_prologue (struct gdbarch *gdbarch,
   int gdb_register_number;
   int register_number;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   int gdb_register_number;
   int register_number;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   
   cache->sp_offset = 0;
 
   
   cache->sp_offset = 0;
 
@@ -876,13 +877,14 @@ sh64_analyze_prologue (struct gdbarch *gdbarch,
     {
       insn = read_memory_integer (cache->media_mode ? UNMAKE_ISA32_ADDR (pc)
                                                    : pc,
     {
       insn = read_memory_integer (cache->media_mode ? UNMAKE_ISA32_ADDR (pc)
                                                    : pc,
-                                 insn_size);
+                                 insn_size, byte_order);
 
       if (!cache->media_mode)
        {
          if (IS_STS_PR (insn))
            {
 
       if (!cache->media_mode)
        {
          if (IS_STS_PR (insn))
            {
-             int next_insn = read_memory_integer (pc + insn_size, insn_size);
+             int next_insn = read_memory_integer (pc + insn_size,
+                                                  insn_size, byte_order);
              if (IS_MOV_TO_R15 (next_insn))
                {
                  cache->saved_regs[PR_REGNUM] =
              if (IS_MOV_TO_R15 (next_insn))
                {
                  cache->saved_regs[PR_REGNUM] =
@@ -962,17 +964,6 @@ sh64_analyze_prologue (struct gdbarch *gdbarch,
     cache->uses_fp = 1;
 }
 
     cache->uses_fp = 1;
 }
 
-static CORE_ADDR
-sh64_extract_struct_value_address (struct regcache *regcache)
-{
-  /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return
-     address regster is preserved across function calls?  Probably
-     not, making this function wrong.  */
-  ULONGEST val;
-  regcache_raw_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &val);
-  return val;
-}
-
 static CORE_ADDR
 sh64_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 {
 static CORE_ADDR
 sh64_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 {
@@ -1050,6 +1041,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
                      CORE_ADDR sp, int struct_return,
                      CORE_ADDR struct_addr)
 {
                      CORE_ADDR sp, int struct_return,
                      CORE_ADDR struct_addr)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int stack_offset, stack_alloc;
   int int_argreg;
   int float_argreg;
   int stack_offset, stack_alloc;
   int int_argreg;
   int float_argreg;
@@ -1088,7 +1080,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
      in eight registers available.  Loop thru args from first to last.  */
 
   int_argreg = ARG0_REGNUM;
      in eight registers available.  Loop thru args from first to last.  */
 
   int_argreg = ARG0_REGNUM;
-  float_argreg = FP0_REGNUM;
+  float_argreg = gdbarch_fp0_regnum (gdbarch);
   double_argreg = DR0_REGNUM;
 
   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
   double_argreg = DR0_REGNUM;
 
   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
@@ -1099,12 +1091,12 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
       
       if (TYPE_CODE (type) != TYPE_CODE_FLT)
        {
       
       if (TYPE_CODE (type) != TYPE_CODE_FLT)
        {
-         argreg_size = register_size (current_gdbarch, int_argreg);
+         argreg_size = register_size (gdbarch, int_argreg);
 
          if (len < argreg_size)
            {
              /* value gets right-justified in the register or stack word */
 
          if (len < argreg_size)
            {
              /* value gets right-justified in the register or stack word */
-             if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
                memcpy (valbuf + argreg_size - len,
                        (char *) value_contents (args[argnum]), len);
              else
                memcpy (valbuf + argreg_size - len,
                        (char *) value_contents (args[argnum]), len);
              else
@@ -1130,7 +1122,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
              if (int_argreg <= ARGLAST_REGNUM)
                {                       
                  /* there's room in a register */
              if (int_argreg <= ARGLAST_REGNUM)
                {                       
                  /* there's room in a register */
-                 regval = extract_unsigned_integer (val, argreg_size);
+                 regval = extract_unsigned_integer (val, argreg_size,
+                                                    byte_order);
                  regcache_cooked_write_unsigned (regcache, int_argreg, regval);
                }
              /* Store the value 8 bytes at a time.  This means that
                  regcache_cooked_write_unsigned (regcache, int_argreg, regval);
                }
              /* Store the value 8 bytes at a time.  This means that
@@ -1158,7 +1151,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
                {
                  /* Goes in FR0...FR11 */
                  regcache_cooked_write (regcache,
                {
                  /* Goes in FR0...FR11 */
                  regcache_cooked_write (regcache,
-                                        FP0_REGNUM + float_arg_index,
+                                        gdbarch_fp0_regnum (gdbarch)
+                                        + float_arg_index,
                                         val);
                  fp_args[float_arg_index] = 1;
                  /* Skip the corresponding general argument register.  */
                                         val);
                  fp_args[float_arg_index] = 1;
                  /* Skip the corresponding general argument register.  */
@@ -1202,7 +1196,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
 
   /* Update stack pointer.  */
-  regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
+  regcache_cooked_write_unsigned (regcache,
+                                 gdbarch_sp_regnum (gdbarch), sp);
 
   return sp;
 }
 
   return sp;
 }
@@ -1215,14 +1210,17 @@ static void
 sh64_extract_return_value (struct type *type, struct regcache *regcache,
                           void *valbuf)
 {
 sh64_extract_return_value (struct type *type, struct regcache *regcache,
                           void *valbuf)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int len = TYPE_LENGTH (type);
   int len = TYPE_LENGTH (type);
-  
+
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     {
       if (len == 4)
        {
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     {
       if (len == 4)
        {
-         /* Return value stored in FP0_REGNUM */
-         regcache_raw_read (regcache, FP0_REGNUM, valbuf);
+         /* Return value stored in gdbarch_fp0_regnum */
+         regcache_raw_read (regcache,
+                            gdbarch_fp0_regnum (gdbarch), valbuf);
        }
       else if (len == 8)
        {
        }
       else if (len == 8)
        {
@@ -1232,7 +1230,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
 
          regcache_cooked_read (regcache, DR0_REGNUM, buf);
          
 
          regcache_cooked_read (regcache, DR0_REGNUM, buf);
          
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+         if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
            floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
                                     buf, &val);
          else
            floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
                                     buf, &val);
          else
@@ -1251,8 +1249,8 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
             at the most significant end.  */
          regcache_raw_read (regcache, DEFAULT_RETURN_REGNUM, buf);
 
             at the most significant end.  */
          regcache_raw_read (regcache, DEFAULT_RETURN_REGNUM, buf);
 
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-           offset = register_size (current_gdbarch, DEFAULT_RETURN_REGNUM)
+         if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+           offset = register_size (gdbarch, DEFAULT_RETURN_REGNUM)
                     - len;
          else
            offset = 0;
                     - len;
          else
            offset = 0;
@@ -1274,14 +1272,15 @@ static void
 sh64_store_return_value (struct type *type, struct regcache *regcache,
                         const void *valbuf)
 {
 sh64_store_return_value (struct type *type, struct regcache *regcache,
                         const void *valbuf)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   char buf[64];        /* more than enough...  */
   int len = TYPE_LENGTH (type);
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     {
   char buf[64];        /* more than enough...  */
   int len = TYPE_LENGTH (type);
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     {
-      int i, regnum = FP0_REGNUM;
+      int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
       for (i = 0; i < len; i += 4)
-       if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
          regcache_raw_write (regcache, regnum++,
                              (char *) valbuf + len - 4 - i);
        else
          regcache_raw_write (regcache, regnum++,
                              (char *) valbuf + len - 4 - i);
        else
@@ -1292,15 +1291,15 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
       int return_register = DEFAULT_RETURN_REGNUM;
       int offset = 0;
 
       int return_register = DEFAULT_RETURN_REGNUM;
       int offset = 0;
 
-      if (len <= register_size (current_gdbarch, return_register))
+      if (len <= register_size (gdbarch, return_register))
        {
          /* Pad with zeros.  */
        {
          /* Pad with zeros.  */
-         memset (buf, 0, register_size (current_gdbarch, return_register));
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
-           offset = 0; /*register_size (current_gdbarch, 
+         memset (buf, 0, register_size (gdbarch, return_register));
+         if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
+           offset = 0; /*register_size (gdbarch, 
                          return_register) - len;*/
          else
                          return_register) - len;*/
          else
-           offset = register_size (current_gdbarch, return_register) - len;
+           offset = register_size (gdbarch, return_register) - len;
 
          memcpy (buf + offset, valbuf, len);
          regcache_raw_write (regcache, return_register, buf);
 
          memcpy (buf + offset, valbuf, len);
          regcache_raw_write (regcache, return_register, buf);
@@ -1311,8 +1310,8 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention
-sh64_return_value (struct gdbarch *gdbarch, struct type *type,
-                  struct regcache *regcache,
+sh64_return_value (struct gdbarch *gdbarch, struct type *func_type,
+                  struct type *type, struct regcache *regcache,
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   if (sh64_use_struct_convention (type))
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   if (sh64_use_struct_convention (type))
@@ -1325,93 +1324,122 @@ sh64_return_value (struct gdbarch *gdbarch, struct type *type,
 }
 
 static void
 }
 
 static void
-sh64_show_media_regs (void)
+sh64_show_media_regs (struct frame_info *frame)
 {
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   int i;
 
   int i;
 
-  printf_filtered ("PC=%s SR=%016llx \n",
-                  paddr (read_register (PC_REGNUM)),
-                  (long long) read_register (SR_REGNUM));
+  printf_filtered
+    ("PC=%s SR=%s\n",
+     phex (get_frame_register_unsigned (frame,
+                                       gdbarch_pc_regnum (gdbarch)), 8),
+     phex (get_frame_register_unsigned (frame, SR_REGNUM), 8));
 
 
-  printf_filtered ("SSR=%016llx SPC=%016llx \n",
-                  (long long) read_register (SSR_REGNUM),
-                  (long long) read_register (SPC_REGNUM));
-  printf_filtered ("FPSCR=%016lx\n ",
-                  (long) read_register (FPSCR_REGNUM));
+  printf_filtered
+    ("SSR=%s SPC=%s\n",
+     phex (get_frame_register_unsigned (frame, SSR_REGNUM), 8),
+     phex (get_frame_register_unsigned (frame, SPC_REGNUM), 8));
+  printf_filtered
+    ("FPSCR=%s\n ",
+     phex (get_frame_register_unsigned (frame, FPSCR_REGNUM), 8));
 
   for (i = 0; i < 64; i = i + 4)
 
   for (i = 0; i < 64; i = i + 4)
-    printf_filtered ("\nR%d-R%d  %016llx %016llx %016llx %016llx\n",
-                    i, i + 3,
-                    (long long) read_register (i + 0),
-                    (long long) read_register (i + 1),
-                    (long long) read_register (i + 2),
-                    (long long) read_register (i + 3));
+    printf_filtered
+      ("\nR%d-R%d  %s %s %s %s\n",
+       i, i + 3,
+      phex (get_frame_register_unsigned (frame, i + 0), 8),
+      phex (get_frame_register_unsigned (frame, i + 1), 8),
+      phex (get_frame_register_unsigned (frame, i + 2), 8),
+      phex (get_frame_register_unsigned (frame, i + 3), 8));
 
   printf_filtered ("\n");
   
   for (i = 0; i < 64; i = i + 8)
 
   printf_filtered ("\n");
   
   for (i = 0; i < 64; i = i + 8)
-    printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
-                    i, i + 7,
-                    (long) read_register (FP0_REGNUM + i + 0),
-                    (long) read_register (FP0_REGNUM + i + 1),
-                    (long) read_register (FP0_REGNUM + i + 2),
-                    (long) read_register (FP0_REGNUM + i + 3),
-                    (long) read_register (FP0_REGNUM + i + 4),
-                    (long) read_register (FP0_REGNUM + i + 5),
-                    (long) read_register (FP0_REGNUM + i + 6),
-                    (long) read_register (FP0_REGNUM + i + 7));
+    printf_filtered
+      ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+       i, i + 7,
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 0),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 1),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 2),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 3),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 4),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 5),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 6),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 7));
 }
 
 static void
 }
 
 static void
-sh64_show_compact_regs (void)
+sh64_show_compact_regs (struct frame_info *frame)
 {
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   int i;
 
   int i;
 
-  printf_filtered ("PC=%s \n",
-                  paddr (read_register (PC_C_REGNUM)));
-
-  printf_filtered ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
-                  (long) read_register (GBR_C_REGNUM),
-                  (long) read_register (MACH_C_REGNUM),
-                  (long) read_register (MACL_C_REGNUM),
-                  (long) read_register (PR_C_REGNUM),
-                  (long) read_register (T_C_REGNUM));
-  printf_filtered ("FPSCR=%08lx FPUL=%08lx\n",
-                  (long) read_register (FPSCR_C_REGNUM),
-                  (long) read_register (FPUL_C_REGNUM));
+  printf_filtered
+    ("PC=%s\n",
+     phex (get_frame_register_unsigned (frame, PC_C_REGNUM), 8));
+
+  printf_filtered
+    ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
+     (long) get_frame_register_unsigned (frame, GBR_C_REGNUM),
+     (long) get_frame_register_unsigned (frame, MACH_C_REGNUM),
+     (long) get_frame_register_unsigned (frame, MACL_C_REGNUM),
+     (long) get_frame_register_unsigned (frame, PR_C_REGNUM),
+     (long) get_frame_register_unsigned (frame, T_C_REGNUM));
+  printf_filtered
+    ("FPSCR=%08lx FPUL=%08lx\n",
+     (long) get_frame_register_unsigned (frame, FPSCR_C_REGNUM),
+     (long) get_frame_register_unsigned (frame, FPUL_C_REGNUM));
 
   for (i = 0; i < 16; i = i + 4)
 
   for (i = 0; i < 16; i = i + 4)
-    printf_filtered ("\nR%d-R%d  %08lx %08lx %08lx %08lx\n",
-                    i, i + 3,
-                    (long) read_register (i + 0),
-                    (long) read_register (i + 1),
-                    (long) read_register (i + 2),
-                    (long) read_register (i + 3));
+    printf_filtered
+      ("\nR%d-R%d  %08lx %08lx %08lx %08lx\n",
+       i, i + 3,
+       (long) get_frame_register_unsigned (frame, i + 0),
+       (long) get_frame_register_unsigned (frame, i + 1),
+       (long) get_frame_register_unsigned (frame, i + 2),
+       (long) get_frame_register_unsigned (frame, i + 3));
 
   printf_filtered ("\n");
   
   for (i = 0; i < 16; i = i + 8)
 
   printf_filtered ("\n");
   
   for (i = 0; i < 16; i = i + 8)
-    printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
-                    i, i + 7,
-                    (long) read_register (FP0_REGNUM + i + 0),
-                    (long) read_register (FP0_REGNUM + i + 1),
-                    (long) read_register (FP0_REGNUM + i + 2),
-                    (long) read_register (FP0_REGNUM + i + 3),
-                    (long) read_register (FP0_REGNUM + i + 4),
-                    (long) read_register (FP0_REGNUM + i + 5),
-                    (long) read_register (FP0_REGNUM + i + 6),
-                    (long) read_register (FP0_REGNUM + i + 7));
+    printf_filtered
+      ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+       i, i + 7,
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 0),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 1),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 2),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 3),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 4),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 5),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 6),
+       (long) get_frame_register_unsigned
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 7));
 }
 
 /* FIXME!!! This only shows the registers for shmedia, excluding the
    pseudo registers.  */
 void
 }
 
 /* FIXME!!! This only shows the registers for shmedia, excluding the
    pseudo registers.  */
 void
-sh64_show_regs (void)
+sh64_show_regs (struct frame_info *frame)
 {
 {
-  if (pc_is_isa32 (get_frame_pc (get_selected_frame (NULL))))
-    sh64_show_media_regs ();
+  if (pc_is_isa32 (get_frame_pc (frame)))
+    sh64_show_media_regs (frame);
   else
   else
-    sh64_show_compact_regs ();
+    sh64_show_compact_regs (frame);
 }
 
 /* *INDENT-OFF* */
 }
 
 /* *INDENT-OFF* */
@@ -1483,12 +1511,10 @@ REGISTER_BYTE returns the register byte for the base register.
 */
 
 static struct type *
 */
 
 static struct type *
-sh64_build_float_register_type (int high)
+sh64_build_float_register_type (struct gdbarch *gdbarch, int high)
 {
 {
-  struct type *temp;
-
-  temp = create_range_type (NULL, builtin_type_int, 0, high);
-  return create_array_type (NULL, builtin_type_float, temp);
+  return lookup_array_range_type (builtin_type (gdbarch)->builtin_float,
+                                 0, high);
 }
 
 /* Return the GDB type object for the "standard" data type
 }
 
 /* Return the GDB type object for the "standard" data type
@@ -1496,41 +1522,41 @@ sh64_build_float_register_type (int high)
 static struct type *
 sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
 static struct type *
 sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
-  if ((reg_nr >= FP0_REGNUM
+  if ((reg_nr >= gdbarch_fp0_regnum (gdbarch)
        && reg_nr <= FP_LAST_REGNUM)
       || (reg_nr >= FP0_C_REGNUM
          && reg_nr <= FP_LAST_C_REGNUM))
        && reg_nr <= FP_LAST_REGNUM)
       || (reg_nr >= FP0_C_REGNUM
          && reg_nr <= FP_LAST_C_REGNUM))
-    return builtin_type_float;
+    return builtin_type (gdbarch)->builtin_float;
   else if ((reg_nr >= DR0_REGNUM 
            && reg_nr <= DR_LAST_REGNUM)
           || (reg_nr >= DR0_C_REGNUM 
               && reg_nr <= DR_LAST_C_REGNUM))
   else if ((reg_nr >= DR0_REGNUM 
            && reg_nr <= DR_LAST_REGNUM)
           || (reg_nr >= DR0_C_REGNUM 
               && reg_nr <= DR_LAST_C_REGNUM))
-    return builtin_type_double;
+    return builtin_type (gdbarch)->builtin_double;
   else if  (reg_nr >= FPP0_REGNUM 
            && reg_nr <= FPP_LAST_REGNUM)
   else if  (reg_nr >= FPP0_REGNUM 
            && reg_nr <= FPP_LAST_REGNUM)
-    return sh64_build_float_register_type (1);
+    return sh64_build_float_register_type (gdbarch, 1);
   else if ((reg_nr >= FV0_REGNUM
            && reg_nr <= FV_LAST_REGNUM)
           ||(reg_nr >= FV0_C_REGNUM 
              && reg_nr <= FV_LAST_C_REGNUM))
   else if ((reg_nr >= FV0_REGNUM
            && reg_nr <= FV_LAST_REGNUM)
           ||(reg_nr >= FV0_C_REGNUM 
              && reg_nr <= FV_LAST_C_REGNUM))
-    return sh64_build_float_register_type (3);
+    return sh64_build_float_register_type (gdbarch, 3);
   else if (reg_nr == FPSCR_REGNUM)
   else if (reg_nr == FPSCR_REGNUM)
-    return builtin_type_int;
+    return builtin_type (gdbarch)->builtin_int;
   else if (reg_nr >= R0_C_REGNUM
           && reg_nr < FP0_C_REGNUM)
   else if (reg_nr >= R0_C_REGNUM
           && reg_nr < FP0_C_REGNUM)
-    return builtin_type_int;
+    return builtin_type (gdbarch)->builtin_int;
   else
   else
-    return builtin_type_long_long;
+    return builtin_type (gdbarch)->builtin_long_long;
 }
 
 static void
 }
 
 static void
-sh64_register_convert_to_virtual (int regnum, struct type *type,
-                                    char *from, char *to)
+sh64_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum,
+                                 struct type *type, char *from, char *to)
 {
 {
-  if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
     {
       /* It is a no-op.  */
-      memcpy (to, from, register_size (current_gdbarch, regnum));
+      memcpy (to, from, register_size (gdbarch, regnum));
       return;
     }
 
       return;
     }
 
@@ -1549,13 +1575,13 @@ sh64_register_convert_to_virtual (int regnum, struct type *type,
 }
 
 static void
 }
 
 static void
-sh64_register_convert_to_raw (struct type *type, int regnum,
-                                const void *from, void *to)
+sh64_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type,
+                             int regnum, const void *from, void *to)
 {
 {
-  if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
     {
       /* It is a no-op.  */
-      memcpy (to, from, register_size (current_gdbarch, regnum));
+      memcpy (to, from, register_size (gdbarch, regnum));
       return;
     }
 
       return;
     }
 
@@ -1564,7 +1590,7 @@ sh64_register_convert_to_raw (struct type *type, int regnum,
       || (regnum >= DR0_C_REGNUM 
          && regnum <= DR_LAST_C_REGNUM))
     {
       || (regnum >= DR0_C_REGNUM 
          && regnum <= DR_LAST_C_REGNUM))
     {
-      DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
+      DOUBLEST val = extract_typed_floating (from, type);
       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, 
                                 &val, to);
     }
       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, 
                                 &val, to);
     }
@@ -1576,6 +1602,7 @@ static void
 sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                           int reg_nr, gdb_byte *buffer)
 {
 sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                           int reg_nr, gdb_byte *buffer)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int base_regnum;
   int portion;
   int offset = 0;
   int base_regnum;
   int portion;
   int offset = 0;
@@ -1584,7 +1611,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   if (reg_nr >= DR0_REGNUM 
       && reg_nr <= DR_LAST_REGNUM)
     {
   if (reg_nr >= DR0_REGNUM 
       && reg_nr <= DR_LAST_REGNUM)
     {
-      base_regnum = sh64_dr_reg_base_num (reg_nr);
+      base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       /* DR regs are double precision registers obtained by
 
       /* Build the value in the provided buffer.  */ 
       /* DR regs are double precision registers obtained by
@@ -1595,7 +1622,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                            + register_size (gdbarch, base_regnum) * portion));
 
       /* We must pay attention to the endianness.  */
                            + register_size (gdbarch, base_regnum) * portion));
 
       /* We must pay attention to the endianness.  */
-      sh64_register_convert_to_virtual (reg_nr, 
+      sh64_register_convert_to_virtual (gdbarch, reg_nr,
                                        register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
 
                                        register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
 
@@ -1604,7 +1631,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FPP0_REGNUM 
           && reg_nr <= FPP_LAST_REGNUM)
     {
   else if (reg_nr >= FPP0_REGNUM 
           && reg_nr <= FPP_LAST_REGNUM)
     {
-      base_regnum = sh64_fpp_reg_base_num (reg_nr);
+      base_regnum = sh64_fpp_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       /* FPP regs are pairs of single precision registers obtained by
 
       /* Build the value in the provided buffer.  */ 
       /* FPP regs are pairs of single precision registers obtained by
@@ -1618,7 +1645,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FV0_REGNUM 
           && reg_nr <= FV_LAST_REGNUM)
     {
   else if (reg_nr >= FV0_REGNUM 
           && reg_nr <= FV_LAST_REGNUM)
     {
-      base_regnum = sh64_fv_reg_base_num (reg_nr);
+      base_regnum = sh64_fv_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       /* FV regs are vectors of single precision registers obtained by
 
       /* Build the value in the provided buffer.  */ 
       /* FV regs are vectors of single precision registers obtained by
@@ -1633,11 +1660,11 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= R0_C_REGNUM 
           && reg_nr <= T_C_REGNUM)
     {
   else if (reg_nr >= R0_C_REGNUM 
           && reg_nr <= T_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       regcache_raw_read (regcache, base_regnum, temp_buffer);
 
       /* Build the value in the provided buffer.  */ 
       regcache_raw_read (regcache, base_regnum, temp_buffer);
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
     }
        offset = 4;
       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
     }
@@ -1645,7 +1672,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FP0_C_REGNUM
           && reg_nr <= FP_LAST_C_REGNUM)
     {
   else if (reg_nr >= FP0_C_REGNUM
           && reg_nr <= FP_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       /* Floating point registers map 1-1 to the media fp regs,
 
       /* Build the value in the provided buffer.  */ 
       /* Floating point registers map 1-1 to the media fp regs,
@@ -1656,7 +1683,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= DR0_C_REGNUM 
           && reg_nr <= DR_LAST_C_REGNUM)
     {
   else if (reg_nr >= DR0_C_REGNUM 
           && reg_nr <= DR_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
 
       /* DR_C regs are double precision registers obtained by
         concatenating 2 single precision floating point registers.  */
 
       /* DR_C regs are double precision registers obtained by
         concatenating 2 single precision floating point registers.  */
@@ -1666,7 +1693,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                            + register_size (gdbarch, base_regnum) * portion));
 
       /* We must pay attention to the endianness.  */
                            + register_size (gdbarch, base_regnum) * portion));
 
       /* We must pay attention to the endianness.  */
-      sh64_register_convert_to_virtual (reg_nr, 
+      sh64_register_convert_to_virtual (gdbarch, reg_nr, 
                                        register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
     }
                                        register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
     }
@@ -1674,7 +1701,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FV0_C_REGNUM 
           && reg_nr <= FV_LAST_C_REGNUM)
     {
   else if (reg_nr >= FV0_C_REGNUM 
           && reg_nr <= FV_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
 
       /* Build the value in the provided buffer.  */ 
       /* FV_C regs are vectors of single precision registers obtained by
 
       /* Build the value in the provided buffer.  */ 
       /* FV_C regs are vectors of single precision registers obtained by
@@ -1715,23 +1742,23 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
       /* Get FPSCR into a local buffer */
       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
       /* Get value as an int.  */
       /* Get FPSCR into a local buffer */
       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
       /* Get value as an int.  */
-      fpscr_value = extract_unsigned_integer (temp_buffer, 4);
+      fpscr_value = extract_unsigned_integer (temp_buffer, 4, byte_order);
       /* Get SR into a local buffer */
       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
       /* Get value as an int.  */
       /* Get SR into a local buffer */
       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
       /* Get value as an int.  */
-      sr_value = extract_unsigned_integer (temp_buffer, 4);
+      sr_value = extract_unsigned_integer (temp_buffer, 4, byte_order);
       /* Build the new value.  */
       fpscr_c_part1_value = fpscr_value & 0x3fffd;
       fpscr_c_part2_value = (sr_value & 0x7000) << 6;
       fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
       /* Store that in out buffer!!! */
       /* Build the new value.  */
       fpscr_c_part1_value = fpscr_value & 0x3fffd;
       fpscr_c_part2_value = (sr_value & 0x7000) << 6;
       fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
       /* Store that in out buffer!!! */
-      store_unsigned_integer (buffer, 4, fpscr_c_value);
+      store_unsigned_integer (buffer, 4, byte_order, fpscr_c_value);
       /* FIXME There is surely an endianness gotcha here.  */
     }
 
   else if (reg_nr == FPUL_C_REGNUM)
     {
       /* FIXME There is surely an endianness gotcha here.  */
     }
 
   else if (reg_nr == FPUL_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
 
       /* FPUL_C register is floating point register 32,
         same size, same endianness.  */
 
       /* FPUL_C register is floating point register 32,
         same size, same endianness.  */
@@ -1743,6 +1770,7 @@ static void
 sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                            int reg_nr, const gdb_byte *buffer)
 {
 sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                            int reg_nr, const gdb_byte *buffer)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int base_regnum, portion;
   int offset;
   char temp_buffer[MAX_REGISTER_SIZE];
   int base_regnum, portion;
   int offset;
   char temp_buffer[MAX_REGISTER_SIZE];
@@ -1750,9 +1778,9 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   if (reg_nr >= DR0_REGNUM
       && reg_nr <= DR_LAST_REGNUM)
     {
   if (reg_nr >= DR0_REGNUM
       && reg_nr <= DR_LAST_REGNUM)
     {
-      base_regnum = sh64_dr_reg_base_num (reg_nr);
+      base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr);
       /* We must pay attention to the endianness.  */
       /* We must pay attention to the endianness.  */
-      sh64_register_convert_to_raw (register_type (gdbarch, reg_nr),
+      sh64_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr),
                                    reg_nr,
                                    buffer, temp_buffer);
 
                                    reg_nr,
                                    buffer, temp_buffer);
 
@@ -1767,7 +1795,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FPP0_REGNUM 
           && reg_nr <= FPP_LAST_REGNUM)
     {
   else if (reg_nr >= FPP0_REGNUM 
           && reg_nr <= FPP_LAST_REGNUM)
     {
-      base_regnum = sh64_fpp_reg_base_num (reg_nr);
+      base_regnum = sh64_fpp_reg_base_num (gdbarch, reg_nr);
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 2; portion++)
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 2; portion++)
@@ -1780,7 +1808,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FV0_REGNUM
           && reg_nr <= FV_LAST_REGNUM)
     {
   else if (reg_nr >= FV0_REGNUM
           && reg_nr <= FV_LAST_REGNUM)
     {
-      base_regnum = sh64_fv_reg_base_num (reg_nr);
+      base_regnum = sh64_fv_reg_base_num (gdbarch, reg_nr);
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 4; portion++)
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 4; portion++)
@@ -1795,9 +1823,9 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= R0_C_REGNUM 
           && reg_nr <= T_C_REGNUM)
     {
   else if (reg_nr >= R0_C_REGNUM 
           && reg_nr <= T_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
       /* reg_nr is 32 bit here, and base_regnum is 64 bits.  */
       /* reg_nr is 32 bit here, and base_regnum is 64 bits.  */
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       else 
        offset = 0;
        offset = 4;
       else 
        offset = 0;
@@ -1815,18 +1843,19 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FP0_C_REGNUM
               && reg_nr <= FP_LAST_C_REGNUM)
     {
   else if (reg_nr >= FP0_C_REGNUM
               && reg_nr <= FP_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
       regcache_raw_write (regcache, base_regnum, buffer);
     }
 
   else if (reg_nr >= DR0_C_REGNUM 
           && reg_nr <= DR_LAST_C_REGNUM)
     {
       regcache_raw_write (regcache, base_regnum, buffer);
     }
 
   else if (reg_nr >= DR0_C_REGNUM 
           && reg_nr <= DR_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
       for (portion = 0; portion < 2; portion++)
        {
          /* We must pay attention to the endianness.  */
       for (portion = 0; portion < 2; portion++)
        {
          /* We must pay attention to the endianness.  */
-         sh64_register_convert_to_raw (register_type (gdbarch, reg_nr),
+         sh64_register_convert_to_raw (gdbarch,
+                                       register_type (gdbarch, reg_nr),
                                        reg_nr,
                                        buffer, temp_buffer);
 
                                        reg_nr,
                                        buffer, temp_buffer);
 
@@ -1840,7 +1869,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   else if (reg_nr >= FV0_C_REGNUM 
           && reg_nr <= FV_LAST_C_REGNUM)
     {
   else if (reg_nr >= FV0_C_REGNUM 
           && reg_nr <= FV_LAST_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
      
       for (portion = 0; portion < 4; portion++)
        {
      
       for (portion = 0; portion < 4; portion++)
        {
@@ -1880,7 +1909,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
        */
       /* *INDENT-ON* */
       /* Get value as an int.  */
        */
       /* *INDENT-ON* */
       /* Get value as an int.  */
-      fpscr_c_value = extract_unsigned_integer (buffer, 4);
+      fpscr_c_value = extract_unsigned_integer (buffer, 4, byte_order);
 
       /* Build the new values.  */
       fpscr_mask = 0x0003fffd;
 
       /* Build the new values.  */
       fpscr_mask = 0x0003fffd;
@@ -1890,23 +1919,23 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       sr_value = (fpscr_value & sr_mask) >> 6;
       
       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
       sr_value = (fpscr_value & sr_mask) >> 6;
       
       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
-      old_fpscr_value = extract_unsigned_integer (temp_buffer, 4);
+      old_fpscr_value = extract_unsigned_integer (temp_buffer, 4, byte_order);
       old_fpscr_value &= 0xfffc0002;
       fpscr_value |= old_fpscr_value;
       old_fpscr_value &= 0xfffc0002;
       fpscr_value |= old_fpscr_value;
-      store_unsigned_integer (temp_buffer, 4, fpscr_value);
+      store_unsigned_integer (temp_buffer, 4, byte_order, fpscr_value);
       regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer);
       
       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
       regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer);
       
       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
-      old_sr_value = extract_unsigned_integer (temp_buffer, 4);
+      old_sr_value = extract_unsigned_integer (temp_buffer, 4, byte_order);
       old_sr_value &= 0xffff8fff;
       sr_value |= old_sr_value;
       old_sr_value &= 0xffff8fff;
       sr_value |= old_sr_value;
-      store_unsigned_integer (temp_buffer, 4, sr_value);
+      store_unsigned_integer (temp_buffer, 4, byte_order, sr_value);
       regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
     }
 
   else if (reg_nr == FPUL_C_REGNUM)
     {
       regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
     }
 
   else if (reg_nr == FPUL_C_REGNUM)
     {
-      base_regnum = sh64_compact_reg_base_num (reg_nr);
+      base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
       regcache_raw_write (regcache, base_regnum, buffer);
     }
 }
       regcache_raw_write (regcache, base_regnum, buffer);
     }
 }
@@ -1965,18 +1994,23 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file,
   int j;
 
   /* Allocate space for the float.  */
   int j;
 
   /* Allocate space for the float.  */
-  raw_buffer = (unsigned char *) alloca (register_size (gdbarch, FP0_REGNUM));
+  raw_buffer = (unsigned char *) alloca
+                                (register_size (gdbarch,
+                                                gdbarch_fp0_regnum
+                                                  (gdbarch)));
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
-    error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
+    error ("can't read register %d (%s)",
+          regnum, gdbarch_register_name (gdbarch, regnum));
 
   /* Get the register as a number */ 
 
   /* Get the register as a number */ 
-  flt = unpack_double (builtin_type_float, raw_buffer, &inv);
+  flt = unpack_double (builtin_type (gdbarch)->builtin_float, raw_buffer, &inv);
 
   /* Print the name and some spaces.  */
 
   /* Print the name and some spaces.  */
-  fputs_filtered (REGISTER_NAME (regnum), file);
-  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
+  fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
+  print_spaces_filtered (15 - strlen (gdbarch_register_name
+                                       (gdbarch, regnum)), file);
 
   /* Print the value.  */
   if (inv)
 
   /* Print the value.  */
   if (inv)
@@ -1988,8 +2022,9 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file,
   fprintf_filtered (file, "\t(raw 0x");
   for (j = 0; j < register_size (gdbarch, regnum); j++)
     {
   fprintf_filtered (file, "\t(raw 0x");
   for (j = 0; j < register_size (gdbarch, regnum); j++)
     {
-      int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
-       : register_size (gdbarch, regnum) - 1 - j;
+      int idx = gdbarch_byte_order (gdbarch)
+               == BFD_ENDIAN_BIG ? j : register_size
+               (gdbarch, regnum) - 1 - j;
       fprintf_filtered (file, "%02x", raw_buffer[idx]);
     }
   fprintf_filtered (file, ")");
       fprintf_filtered (file, "%02x", raw_buffer[idx]);
     }
   fprintf_filtered (file, ")");
@@ -2002,15 +2037,16 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 {
   /* All the sh64-compact mode registers are pseudo registers.  */
 
 {
   /* All the sh64-compact mode registers are pseudo registers.  */
 
-  if (regnum < NUM_REGS 
-      || regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA
-                           + NUM_PSEUDO_REGS_SH_COMPACT)
+  if (regnum < gdbarch_num_regs (gdbarch)
+      || regnum >= gdbarch_num_regs (gdbarch)
+                  + NUM_PSEUDO_REGS_SH_MEDIA
+                  + NUM_PSEUDO_REGS_SH_COMPACT)
     internal_error (__FILE__, __LINE__,
                    _("Invalid pseudo register number %d\n"), regnum);
 
   else if ((regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM))
     {
     internal_error (__FILE__, __LINE__,
                    _("Invalid pseudo register number %d\n"), regnum);
 
   else if ((regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM))
     {
-      int fp_regnum = sh64_dr_reg_base_num (regnum);
+      int fp_regnum = sh64_dr_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "dr%d\t0x%08x%08x\n", regnum - DR0_REGNUM, 
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
       fprintf_filtered (file, "dr%d\t0x%08x%08x\n", regnum - DR0_REGNUM, 
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
@@ -2018,7 +2054,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   else if ((regnum >= DR0_C_REGNUM && regnum <= DR_LAST_C_REGNUM))
     {
 
   else if ((regnum >= DR0_C_REGNUM && regnum <= DR_LAST_C_REGNUM))
     {
-      int fp_regnum = sh64_compact_reg_base_num (regnum);
+      int fp_regnum = sh64_compact_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "dr%d_c\t0x%08x%08x\n", regnum - DR0_C_REGNUM,
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
       fprintf_filtered (file, "dr%d_c\t0x%08x%08x\n", regnum - DR0_C_REGNUM,
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
@@ -2026,7 +2062,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   else if ((regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM))
     {
 
   else if ((regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM))
     {
-      int fp_regnum = sh64_fv_reg_base_num (regnum);
+      int fp_regnum = sh64_fv_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
           regnum - FV0_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, fp_regnum),
       fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
           regnum - FV0_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, fp_regnum),
@@ -2037,7 +2073,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
           
   else if ((regnum >= FV0_C_REGNUM && regnum <= FV_LAST_C_REGNUM))
     {
           
   else if ((regnum >= FV0_C_REGNUM && regnum <= FV_LAST_C_REGNUM))
     {
-      int fp_regnum = sh64_compact_reg_base_num (regnum);
+      int fp_regnum = sh64_compact_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "fv%d_c\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
           regnum - FV0_C_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, fp_regnum),
       fprintf_filtered (file, "fv%d_c\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
           regnum - FV0_C_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, fp_regnum),
@@ -2048,7 +2084,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   else if (regnum >= FPP0_REGNUM && regnum <= FPP_LAST_REGNUM)
     {
 
   else if (regnum >= FPP0_REGNUM && regnum <= FPP_LAST_REGNUM)
     {
-      int fp_regnum = sh64_fpp_reg_base_num (regnum);
+      int fp_regnum = sh64_fpp_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "fpp%d\t0x%08x\t0x%08x\n", regnum - FPP0_REGNUM, 
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
       fprintf_filtered (file, "fpp%d\t0x%08x\t0x%08x\n", regnum - FPP0_REGNUM, 
          (unsigned) get_frame_register_unsigned (frame, fp_regnum),
          (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1));
@@ -2056,7 +2092,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   else if (regnum >= R0_C_REGNUM && regnum <= R_LAST_C_REGNUM)
     {
 
   else if (regnum >= R0_C_REGNUM && regnum <= R_LAST_C_REGNUM)
     {
-      int c_regnum = sh64_compact_reg_base_num (regnum);
+      int c_regnum = sh64_compact_reg_base_num (gdbarch, regnum);
       fprintf_filtered (file, "r%d_c\t0x%08x\n", regnum - R0_C_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, c_regnum));
     }
       fprintf_filtered (file, "r%d_c\t0x%08x\n", regnum - R0_C_REGNUM, 
           (unsigned) get_frame_register_unsigned (frame, c_regnum));
     }
@@ -2072,19 +2108,25 @@ sh64_do_register (struct gdbarch *gdbarch, struct ui_file *file,
                  struct frame_info *frame, int regnum)
 {
   unsigned char raw_buffer[MAX_REGISTER_SIZE];
                  struct frame_info *frame, int regnum)
 {
   unsigned char raw_buffer[MAX_REGISTER_SIZE];
+  struct value_print_options opts;
 
 
-  fputs_filtered (REGISTER_NAME (regnum), file);
-  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
+  fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
+  print_spaces_filtered (15 - strlen (gdbarch_register_name
+                                     (gdbarch, regnum)), file);
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
     fprintf_filtered (file, "*value not available*\n");
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
     fprintf_filtered (file, "*value not available*\n");
-      
+
+  get_formatted_print_options (&opts, 'x');
+  opts.deref_ref = 1;
   val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
   val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
-            file, 'x', 1, 0, Val_pretty_default);
+            file, 0, NULL, &opts, current_language);
   fprintf_filtered (file, "\t");
   fprintf_filtered (file, "\t");
+  get_formatted_print_options (&opts, 0);
+  opts.deref_ref = 1;
   val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
   val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
-            file, 0, 1, 0, Val_pretty_default);
+            file, 0, NULL, &opts, current_language);
   fprintf_filtered (file, "\n");
 }
 
   fprintf_filtered (file, "\n");
 }
 
@@ -2092,11 +2134,12 @@ static void
 sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
                     struct frame_info *frame, int regnum)
 {
 sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
                     struct frame_info *frame, int regnum)
 {
-  if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
+  if (regnum < 0 || regnum >= gdbarch_num_regs (gdbarch)
+                             + gdbarch_num_pseudo_regs (gdbarch))
     internal_error (__FILE__, __LINE__,
                    _("Invalid register number %d\n"), regnum);
 
     internal_error (__FILE__, __LINE__,
                    _("Invalid register number %d\n"), regnum);
 
-  else if (regnum >= 0 && regnum < NUM_REGS)
+  else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
     {
       if (TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
        sh64_do_fp_register (gdbarch, file, frame, regnum);     /* FP regs */
     {
       if (TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
        sh64_do_fp_register (gdbarch, file, frame, regnum);     /* FP regs */
@@ -2104,7 +2147,8 @@ sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
        sh64_do_register (gdbarch, file, frame, regnum);
     }
 
        sh64_do_register (gdbarch, file, frame, regnum);
     }
 
-  else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+  else if (regnum < gdbarch_num_regs (gdbarch)
+                   + gdbarch_num_pseudo_regs (gdbarch))
     sh64_do_pseudo_register (gdbarch, file, frame, regnum);
 }
 
     sh64_do_pseudo_register (gdbarch, file, frame, regnum);
 }
 
@@ -2115,7 +2159,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 {
   if (regnum != -1)            /* do one specified register */
     {
 {
   if (regnum != -1)            /* do one specified register */
     {
-      if (*(REGISTER_NAME (regnum)) == '\0')
+      if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
        error ("Not a valid register for the current processor type");
 
       sh64_print_register (gdbarch, file, frame, regnum);
        error ("Not a valid register for the current processor type");
 
       sh64_print_register (gdbarch, file, frame, regnum);
@@ -2124,12 +2168,12 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
     /* do all (or most) registers */
     {
       regnum = 0;
     /* do all (or most) registers */
     {
       regnum = 0;
-      while (regnum < NUM_REGS)
+      while (regnum < gdbarch_num_regs (gdbarch))
        {
          /* If the register name is empty, it is undefined for this
             processor, so don't display anything.  */
        {
          /* If the register name is empty, it is undefined for this
             processor, so don't display anything.  */
-         if (REGISTER_NAME (regnum) == NULL
-             || *(REGISTER_NAME (regnum)) == '\0')
+         if (gdbarch_register_name (gdbarch, regnum) == NULL
+             || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
            { 
              regnum++;
              continue;
            { 
              regnum++;
              continue;
@@ -2145,7 +2189,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
                  regnum ++;
                }
              else
                  regnum ++;
                }
              else
-               regnum += FP_LAST_REGNUM - FP0_REGNUM;  /* skip FP regs */
+               regnum += FP_LAST_REGNUM - gdbarch_fp0_regnum (gdbarch);
+               /* skip FP regs */
            }
          else
            {
            }
          else
            {
@@ -2155,7 +2200,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
        }
 
       if (fpregs)
        }
 
       if (fpregs)
-       while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+       while (regnum < gdbarch_num_regs (gdbarch)
+                       + gdbarch_num_pseudo_regs (gdbarch))
          {
            sh64_do_pseudo_register (gdbarch, file, frame, regnum);
            regnum++;
          {
            sh64_do_pseudo_register (gdbarch, file, frame, regnum);
            regnum++;
@@ -2171,7 +2217,7 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch,
 {
   if (regnum != -1)            /* do one specified register */
     {
 {
   if (regnum != -1)            /* do one specified register */
     {
-      if (*(REGISTER_NAME (regnum)) == '\0')
+      if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
        error ("Not a valid register for the current processor type");
 
       if (regnum >= 0 && regnum < R0_C_REGNUM)
        error ("Not a valid register for the current processor type");
 
       if (regnum >= 0 && regnum < R0_C_REGNUM)
@@ -2183,7 +2229,8 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch,
     /* do all compact registers */
     {
       regnum = R0_C_REGNUM;
     /* do all compact registers */
     {
       regnum = R0_C_REGNUM;
-      while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+      while (regnum < gdbarch_num_regs (gdbarch)
+                     + gdbarch_num_pseudo_regs (gdbarch))
         {
           sh64_do_pseudo_register (gdbarch, file, frame, regnum);
           regnum++;
         {
           sh64_do_pseudo_register (gdbarch, file, frame, regnum);
           regnum++;
@@ -2229,8 +2276,9 @@ sh64_alloc_frame_cache (void)
 }
 
 static struct sh64_frame_cache *
 }
 
 static struct sh64_frame_cache *
-sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
+sh64_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
 {
+  struct gdbarch *gdbarch;
   struct sh64_frame_cache *cache;
   CORE_ADDR current_pc;
   int i;
   struct sh64_frame_cache *cache;
   CORE_ADDR current_pc;
   int i;
@@ -2238,10 +2286,11 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
   if (*this_cache)
     return *this_cache;
 
   if (*this_cache)
     return *this_cache;
 
+  gdbarch = get_frame_arch (this_frame);
   cache = sh64_alloc_frame_cache ();
   *this_cache = cache;
 
   cache = sh64_alloc_frame_cache ();
   *this_cache = cache;
 
-  current_pc = frame_pc_unwind (next_frame);
+  current_pc = get_frame_pc (this_frame);
   cache->media_mode = pc_is_isa32 (current_pc);
 
   /* In principle, for normal frames, fp holds the frame pointer,
   cache->media_mode = pc_is_isa32 (current_pc);
 
   /* In principle, for normal frames, fp holds the frame pointer,
@@ -2249,13 +2298,13 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
      However, for functions that don't need it, the frame pointer is
      optional.  For these "frameless" functions the frame pointer is
      actually the frame pointer of the calling frame. */
      However, for functions that don't need it, the frame pointer is
      optional.  For these "frameless" functions the frame pointer is
      actually the frame pointer of the calling frame. */
-  cache->base = frame_unwind_register_unsigned (next_frame, MEDIA_FP_REGNUM);
+  cache->base = get_frame_register_unsigned (this_frame, MEDIA_FP_REGNUM);
   if (cache->base == 0)
     return cache;
 
   if (cache->base == 0)
     return 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)
-    sh64_analyze_prologue (current_gdbarch, cache, cache->pc, current_pc);
+    sh64_analyze_prologue (gdbarch, cache, cache->pc, current_pc);
 
   if (!cache->uses_fp)
     {
 
   if (!cache->uses_fp)
     {
@@ -2266,7 +2315,8 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
          setup yet.  Try to reconstruct the base address for the stack
          frame by looking at the stack pointer.  For truly "frameless"
          functions this might work too.  */
          setup yet.  Try to reconstruct the base address for the stack
          frame by looking at the stack pointer.  For truly "frameless"
          functions this might work too.  */
-      cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
+      cache->base = get_frame_register_unsigned
+                   (this_frame, gdbarch_sp_regnum (gdbarch));
     }
 
   /* Now that we have the base address for the stack frame we can
     }
 
   /* Now that we have the base address for the stack frame we can
@@ -2282,76 +2332,48 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
   return cache;
 }
 
   return cache;
 }
 
-static void
-sh64_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 *
+sh64_frame_prev_register (struct frame_info *this_frame,
+                         void **this_cache, int regnum)
 {
 {
-  struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache);
+  struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
   gdb_assert (regnum >= 0);
 
 
   gdb_assert (regnum >= 0);
 
-  if (regnum == SP_REGNUM && cache->saved_sp)
-    {
-      *optimizedp = 0;
-      *lvalp = not_lval;
-      *addrp = 0;
-      *realnump = -1;
-      if (valuep)
-        {
-          /* Store the value.  */
-          store_unsigned_integer (valuep,
-                                 register_size (current_gdbarch, SP_REGNUM),
-                                 cache->saved_sp);
-        }
-      return;
-    }
+  if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp)
+    frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 
   /* The PC of the previous frame is stored in the PR register of
      the current frame.  Frob regnum so that we pull the value from
      the correct place.  */
 
   /* The PC of the previous frame is stored in the PR register of
      the current frame.  Frob regnum so that we pull the value from
      the correct place.  */
-  if (regnum == PC_REGNUM)
+  if (regnum == gdbarch_pc_regnum (gdbarch))
     regnum = PR_REGNUM;
 
   if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1)
     {
     regnum = PR_REGNUM;
 
   if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1)
     {
-      int reg_size = register_size (current_gdbarch, regnum);
-      int size;
-
-      *optimizedp = 0;
-      *lvalp = lval_memory;
-      *addrp = cache->saved_regs[regnum];
-      *realnump = -1;
-      if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32
+      if (gdbarch_tdep (gdbarch)->sh_abi == SH_ABI_32
           && (regnum == MEDIA_FP_REGNUM || regnum == PR_REGNUM))
           && (regnum == MEDIA_FP_REGNUM || regnum == PR_REGNUM))
-       size = 4;
-      else
-        size = reg_size;
-      if (valuep)
         {
         {
-         memset (valuep, 0, reg_size);
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
-           read_memory (*addrp, valuep, size);
-         else
-           read_memory (*addrp, (char *) valuep + reg_size - size, size);
+         CORE_ADDR val;
+         val = read_memory_unsigned_integer (cache->saved_regs[regnum],
+                                             4, byte_order);
+         return frame_unwind_got_constant (this_frame, regnum, val);
         }
         }
-      return;
+
+      return frame_unwind_got_memory (this_frame, regnum,
+                                     cache->saved_regs[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 void
 }
 
 static void
-sh64_frame_this_id (struct frame_info *next_frame, void **this_cache,
+sh64_frame_this_id (struct frame_info *this_frame, void **this_cache,
                    struct frame_id *this_id)
 {
                    struct frame_id *this_id)
 {
-  struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache);
+  struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache);
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
@@ -2363,38 +2385,37 @@ sh64_frame_this_id (struct frame_info *next_frame, void **this_cache,
 static const struct frame_unwind sh64_frame_unwind = {
   NORMAL_FRAME,
   sh64_frame_this_id,
 static const struct frame_unwind sh64_frame_unwind = {
   NORMAL_FRAME,
   sh64_frame_this_id,
-  sh64_frame_prev_register
+  sh64_frame_prev_register,
+  NULL,
+  default_frame_sniffer
 };
 
 };
 
-static const struct frame_unwind *
-sh64_frame_sniffer (struct frame_info *next_frame)
-{
-  return &sh64_frame_unwind;
-}
-
 static CORE_ADDR
 sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
 static CORE_ADDR
 sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
-  return frame_unwind_register_unsigned (next_frame, SP_REGNUM);
+  return frame_unwind_register_unsigned (next_frame,
+                                        gdbarch_sp_regnum (gdbarch));
 }
 
 static CORE_ADDR
 sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
 }
 
 static CORE_ADDR
 sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
-  return frame_unwind_register_unsigned (next_frame, PC_REGNUM);
+  return frame_unwind_register_unsigned (next_frame,
+                                        gdbarch_pc_regnum (gdbarch));
 }
 
 static struct frame_id
 }
 
 static struct frame_id
-sh64_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+sh64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
 {
-  return frame_id_build (sh64_unwind_sp (gdbarch, next_frame),
-                         frame_pc_unwind (next_frame));
+  CORE_ADDR sp = get_frame_register_unsigned (this_frame,
+                                             gdbarch_sp_regnum (gdbarch));
+  return frame_id_build (sp, get_frame_pc (this_frame));
 }
 
 static CORE_ADDR
 }
 
 static CORE_ADDR
-sh64_frame_base_address (struct frame_info *next_frame, void **this_cache)
+sh64_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
 {
-  struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache);
+  struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache);
 
   return cache->base;
 }
 
   return cache->base;
 }
@@ -2465,14 +2486,10 @@ sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc);
 
 
   set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc);
 
-  set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh64);
+  set_gdbarch_print_insn (gdbarch, print_insn_sh);
   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
 
   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
 
-  set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
   set_gdbarch_return_value (gdbarch, sh64_return_value);
   set_gdbarch_return_value (gdbarch, sh64_return_value);
-  set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
-                                           sh64_extract_struct_value_address);
 
   set_gdbarch_skip_prologue (gdbarch, sh64_skip_prologue);
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 
   set_gdbarch_skip_prologue (gdbarch, sh64_skip_prologue);
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
@@ -2484,7 +2501,7 @@ sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frame_align (gdbarch, sh64_frame_align);
   set_gdbarch_unwind_sp (gdbarch, sh64_unwind_sp);
   set_gdbarch_unwind_pc (gdbarch, sh64_unwind_pc);
   set_gdbarch_frame_align (gdbarch, sh64_frame_align);
   set_gdbarch_unwind_sp (gdbarch, sh64_unwind_sp);
   set_gdbarch_unwind_pc (gdbarch, sh64_unwind_pc);
-  set_gdbarch_unwind_dummy_id (gdbarch, sh64_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, sh64_dummy_id);
   frame_base_set_default (gdbarch, &sh64_frame_base);
 
   set_gdbarch_print_registers_info (gdbarch, sh64_print_registers_info);
   frame_base_set_default (gdbarch, &sh64_frame_base);
 
   set_gdbarch_print_registers_info (gdbarch, sh64_print_registers_info);
@@ -2495,8 +2512,8 @@ sh64_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, dwarf2_frame_sniffer);
-  frame_unwind_append_sniffer (gdbarch, sh64_frame_sniffer);
+  dwarf2_append_unwinders (gdbarch);
+  frame_unwind_append_unwinder (gdbarch, &sh64_frame_unwind);
 
   return gdbarch;
 }
 
   return gdbarch;
 }
GDB Binutils - Deliverables
This page took 0.044114 seconds and 4 git commands to generate.