2007-11-02 Markus Deuling <deuling@de.ibm.com>

	* gdbarch.sh (register_name): Add gdbarch parameter.
	* gdbarch.{c,h}: Regenerate.

	* target-descriptions.c (tdesc_register_name): Add gdbarch parameter.
	(tdesc_register_name): Replace current_gdbarch by gdbarch.
	* target-descriptions.h (tdesc_register_name): Add gdbarch parameter.

	* xstormy16-tdep.c (xstormy16_register_name): Add gdbarch parameter.
	* vax-tdep.c (vax_register_name): Add gdbarch parameter.
	* spu-tdep.c (spu_register_name): Add gdbarch parameter.
	* s390-tdep.c (s390_register_name): Add gdbarch parameter.
	* mt-tdep.c (mt_register_name): Add gdbarch parameter.
	(mt_registers_info): Replace current_gdbarch by gdbarch.
	(mt_register_reggroup_p): Add gdbarch to mt_register_name call.
	* mips-tdep.c (mips_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	(mips_register_name): Add gdbarch to tdesc_register_name call.
	* mep-tdep.c (mep_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	(mep_register_reggroup_p): Add gdbarch to mep_register_name call.
	* m32c-tdep.c (m32c_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	* m88k-tdep.c (m88k_register_name): Add gdbarch parameter.
	* m68k-tdep.c (m68k_register_name): Add gdbarch parameter.
	* m32r-tdep.c (m32r_register_name): Add gdbarch parameter.
	(m32r_frame_unwind_cache): Use get_frame_arch to get at the current
	architecture by frame_info.
	* iq2000-tdep.c (iq2000_register_name): Add gdbarch parameter.
	* ia64-tdep.c (ia64_register_name): Add gdbarch parameter.
	* hppa-tdep.c (hppa32_register_name, hppa64_register_name): Add gdbarch
	parameter.
	* h8300-tdep.c (h8300_register_name, h8300s_register_name)
	(h8300sx_register_name): Add gdbarch parameter.
	* cris-tdep.c (cris_register_name, crisv32_register_name): Add
	gdbarch parameter. Replace current_gdbarch by gdbarch.
	(cris_gdbarch_init): Replace current_gdbarch by gdbarch (comment).
	* avr-tdep.c (avr_register_name): Add gdbarch parameter.
	* arm-tdep.c (arm_register_name): Add gdbarch paramete
	* amd64-tdep.c (amd64_register_name): Add gdbarch parameter. Update
	caller.
	* amd64-tdep.h (amd64_register_name): Add gdbarch parameter.
	* amd64-linux-tdep.c (amd64_linux_register_name): Add gdbarch parameter.
	* alpha-tdep.c (alpha_register_name): Add gdbarch parameter.
	(alpha_cannot_fetch_register, alpha_cannot_store_register): Update call
	of alpha_register_name.
	* frv-tdep.c (frv_register_name): Add gdbarch parameter.
	* i386-tdep.c (i386_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	(i386_register_type): Replace ?current_gdbarch by gdbarch.
	* i386-tdep.h (i386_register_name): Add gdbarch parameter.
	* i386-linux-tdep.c (i386_linux_register_name): Add gdbarch parameter.

	* m68hc11-tdep.c (m68hc11_register_name): Add gdbarch parameter.
	(m68hc11_register_reggroup_p): Add gdbarch to call of
	m68hc11_register_name.
	* mn10300-tdep.c (mn10300_generic_register_name, am33_register_name)
	(am33_2_register_name): Add gdbarch parameter.
	(mn10300_frame_unwind_cache): Use get_frame_arch to get at the current
	architecture by frame_info.
	(mn10300_dump_tdep): Replace current_gdbarch by gdbarch.
	* rs6000-tdep.c (rs6000_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	* score-tdep.c (score_register_name): Add gdbarch parameter.
	(score_return_value, score_push_dummy_call): Replace current_gdbarch
	by gdbarch.
	* sh64-tdep.c (sh64_register_name): Add gdbarch parameter.
	(sh64_compact_reg_base_num, sh64_register_convert_to_virtual)
	(sh64_register_convert_to_raw, sh64_fv_reg_base_num)
	(sh64_dr_reg_base_num, sh64_fpp_reg_base_num): Add gdbarch parameter
	and update caller. Replace current_gdbarch by gdbarch.
	(sh64_extract_return_value, sh64_store_return_value): Use
	get_regcache_arch to get at the current architecture by regcache.
	* sh-tdep.c (sh_sh_register_name, sh_sh3_register_name)
	(sh_sh3e_register_name, sh_sh2e_register_name, sh_sh2a_register_name)
	(sh_sh2a_nofpu_register_name, sh_sh_dsp_register_name)
	(sh_sh3_dsp_register_name, sh_sh4_register_name)
	(sh_sh4_nofpu_register_name, sh_sh4al_dsp_register_name): Add gdbarch
	parameter.
	(fv_reg_base_num, dr_reg_base_num, sh_justify_value_in_reg)
	(sh_next_flt_argreg): Add gdbarch parameter and update caller. Replace
	current_gdbarch by gdbarch.
	(sh_extract_return_value_fpu, sh_store_return_value_fpu): Use
	get_regcache_arch to get at the current architecture by regcache.
	* sparc-tdep.c (sparc32_register_name): Add gdbarch parameter.
	* sparc64-tdep.c (sparc64_register_name): Add gdbarch parameter.
	* v850-tdep.c (v850_register_name, v850e_register_name): Add gdbarch
	parameter.
	(v850_unwind_sp, v850_unwind_pc): Replace current_gdbarch by gdbarch.
	* xtensa-tdep.c (xtensa_register_name): Add gdbarch parameter. Replace
	current_gdbarch by gdbarch.
	(xtensa_pseudo_register_read, xtensa_pseudo_register_write)
	(xtensa_frame_prev_register): Add gdbarch parameter to
	xtensa_register_name call.

1 files changed, 64 insertions, 62 deletions

diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index d7b6bf3f4d4..d26b82c8c67 100644
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -124,7 +124,7 @@ enum
   };
 
 static const char *
-sh64_register_name (int reg_nr)
+sh64_register_name (struct gdbarch *gdbarch, int reg_nr)
 {
   static char *register_names[] =
   {
@@ -685,34 +685,31 @@ gdb_print_insn_sh64 (bfd_vma memaddr, disassemble_info *info)
 
 /* 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;
 
-  fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
-    (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
-sh64_dr_reg_base_num (int dr_regnum)
+sh64_dr_reg_base_num (struct gdbarch *gdbarch, int dr_regnum)
 {
   int fp_regnum;
 
-  fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
-    (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
-sh64_fpp_reg_base_num (int fpp_regnum)
+sh64_fpp_reg_base_num (struct gdbarch *gdbarch, int fpp_regnum)
 {
   int fp_regnum;
 
-  fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
-    (fpp_regnum - FPP0_REGNUM) * 2;
+  fp_regnum = gdbarch_fp0_regnum (gdbarch) + (fpp_regnum - FPP0_REGNUM) * 2;
   return fp_regnum;
 }
 
@@ -779,7 +776,7 @@ sh64_fpp_reg_base_num (int fpp_regnum)
 */
 /* *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;
 
@@ -791,20 +788,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)
-    base_regnum = reg_nr - FP0_C_REGNUM + gdbarch_fp0_regnum (current_gdbarch);
+    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)
-    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)
-    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)
-    base_regnum = gdbarch_pc_regnum (current_gdbarch);
+    base_regnum = gdbarch_pc_regnum (gdbarch);
 
   else if (reg_nr == GBR_C_REGNUM) 
     base_regnum = 16;
@@ -823,7 +822,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 = gdbarch_fp0_regnum (current_gdbarch) + 32;
+    base_regnum = gdbarch_fp0_regnum (gdbarch) + 32;
   
   return base_regnum;
 }
@@ -1203,15 +1202,16 @@ static void
 sh64_extract_return_value (struct type *type, struct regcache *regcache,
 			   void *valbuf)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int len = TYPE_LENGTH (type);
-  
+
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     {
       if (len == 4)
 	{
 	  /* Return value stored in gdbarch_fp0_regnum */
 	  regcache_raw_read (regcache,
-			     gdbarch_fp0_regnum (current_gdbarch), valbuf);
+			     gdbarch_fp0_regnum (gdbarch), valbuf);
 	}
       else if (len == 8)
 	{
@@ -1221,7 +1221,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
 
 	  regcache_cooked_read (regcache, DR0_REGNUM, buf);
 	  
-	  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
+	  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
 	    floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
 				     buf, &val);
 	  else
@@ -1240,8 +1240,8 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
 	     at the most significant end.  */
 	  regcache_raw_read (regcache, DEFAULT_RETURN_REGNUM, buf);
 
-	  if (gdbarch_byte_order (current_gdbarch) == 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;
@@ -1263,14 +1263,15 @@ static void
 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)
     {
-      int i, regnum = gdbarch_fp0_regnum (current_gdbarch);
+      int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
-	if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
+	if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
 	  regcache_raw_write (regcache, regnum++,
 			      (char *) valbuf + len - 4 - i);
 	else
@@ -1281,15 +1282,15 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
       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.  */
-	  memset (buf, 0, register_size (current_gdbarch, return_register));
-	  if (gdbarch_byte_order (current_gdbarch) == 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
-	    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);
@@ -1542,13 +1543,13 @@ sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
 }
 
 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 (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
-      memcpy (to, from, register_size (current_gdbarch, regnum));
+      memcpy (to, from, register_size (gdbarch, regnum));
       return;
     }
 
@@ -1567,13 +1568,13 @@ sh64_register_convert_to_virtual (int regnum, struct type *type,
 }
 
 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 (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
-      memcpy (to, from, register_size (current_gdbarch, regnum));
+      memcpy (to, from, register_size (gdbarch, regnum));
       return;
     }
 
@@ -1602,7 +1603,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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
@@ -1613,7 +1614,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 			    + 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);
 
@@ -1622,7 +1623,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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
@@ -1636,7 +1637,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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
@@ -1651,7 +1652,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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);
@@ -1663,7 +1664,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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,
@@ -1674,7 +1675,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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.  */
@@ -1684,7 +1685,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 			    + 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);
     }
@@ -1692,7 +1693,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   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
@@ -1749,7 +1750,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 
   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.  */
@@ -1768,9 +1769,9 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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.  */
-      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);
 
@@ -1785,7 +1786,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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++)
@@ -1798,7 +1799,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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++)
@@ -1813,7 +1814,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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.  */
       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	offset = 4;
@@ -1833,18 +1834,19 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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)
     {
-      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.  */
-	  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);
 
@@ -1858,7 +1860,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   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++)
 	{
@@ -1924,7 +1926,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 
   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);
     }
 }
@@ -2035,7 +2037,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   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));
@@ -2043,7 +2045,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   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));
@@ -2051,7 +2053,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   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),
@@ -2062,7 +2064,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 	   
   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),
@@ -2073,7 +2075,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   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));
@@ -2081,7 +2083,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 
   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));
     }