This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFA] Undeprecate sh to sh4


Hi,

the following patch is the first step in undeprecating the 32 bit variants
of the sh CPU, sh, sh2, ... to sh4.  Everything except the new frame code
is covered by this patch.

Corinna

	* sh-tdep.c: Substitute calls to REGISTER_RAW_SIZE by calls to
	register_size and calls to REGISTER_VIRTUAL_TYPE by calls to
	gdbarch_register_type in 32 bit code throughout.  Avoid current_gdbarch
	as possible.
	(do_pseudo_register): Remove.
	(sh_push_dummy_code): New function.
	(sh64_store_struct_return): Rename from sh_store_struct_return.
	Only called for sh64 now.
	(sh_extract_struct_value_address): Regcache'ify.
	(sh_push_dummy_call): Rename from sh_push_arguments.  Regcache'ify
	and accomodate new tasks.
	(sh64_push_return_address): Rename from sh_push_return_address.
	Only called for sh64 now.
	(sh_default_extract_return_value): Rename from sh_extract_return_value.
	Regcache'ify.
	(sh3e_sh4_extract_return_value): Regcache'ify.
	(sh_default_store_return_value): Ditto.
	(sh3e_sh4_store_return_value): Ditto.
	(sh_default_register_byte): Remove.
	(sh_sh4_register_byte): Remove.
	(sh_default_register_raw_size): Remove.
	(sh_sh4_register_raw_size): Remove.
	(sh_register_virtual_size): Remove.
	(sh_sh3e_register_virtual_type): Remove.
	(sh_sh3e_register_type): New function.
	(sh_sh4_register_virtual_type): Remove.
	(sh_sh4_register_type): New function.
	(sh_default_register_virtual_type): Remove.
	(sh_default_register_type): New function.
	(do_fv_register_info): Add parameters to accomodate call from
	sh_print_registers_info.
	(do_dr_register_info): Ditto.
	(sh_print_pseudo_register): Rename from sh_do_pseudo_register.
	Add parameters to accomodate call from sh_print_registers_info.
	(sh_do_fp_register): Ditto.
	(sh64_do_pseudo_register): Call do_dr_register_info,
	do_fv_register_info and sh_do_fp_register with default parameters.
	(sh_do_register): Add parameters to accomodate call from
	sh_print_registers_info.
	(sh_print_register): Ditto.
	(sh_print_registers_info): Rename from sh_do_registers_info.
	Add parameters to be used as gdbarch_print_registers_info
	implementation.  Accomodate removed do_pseudo_register function
	pointer.
	(sh_compact_do_registers_info): Accomodate removed do_pseudo_register
	function pointer. Call sh_print_register with default parameters.
	(sh64_do_registers_info): Call sh_print_registers_info instead of
	sh_do_registers_info.
	(sh_gdbarch_init): Rearrange to cleanup and to allow easier
	detection of deprecated vs. non-deprecated functionality.
	Rename sh_call_dummy_words to sh64_call_dummy_words.  Remove
	function pointer assignments by direct function calls.

Index: sh-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh-tdep.c,v
retrieving revision 1.133
diff -u -p -r1.133 sh-tdep.c
--- sh-tdep.c	9 Jul 2003 22:23:57 -0000	1.133
+++ sh-tdep.c	14 Jul 2003 10:58:04 -0000
@@ -53,7 +53,6 @@
 
 void (*sh_show_regs) (void);
 CORE_ADDR (*skip_prologue_hard_way) (CORE_ADDR);
-void (*do_pseudo_register) (int);
 
 #define SH_DEFAULT_NUM_REGS 59
 
@@ -345,6 +344,22 @@ sh_breakpoint_from_pc (CORE_ADDR *pcptr,
   return breakpoint;
 }
 
+static CORE_ADDR
+sh_push_dummy_code (struct gdbarch *gdbarch,
+		    CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+		    struct value **args, int nargs,
+		    struct type *value_type,
+		    CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  /* Allocate space sufficient for a breakpoint.  */
+  sp = (sp - 2) & ~1;
+  /* Store the address of that breakpoint */
+  *bp_addr = sp;
+  /* sh always starts the call at the callee's entry point.  */
+  *real_pc = funaddr;
+  return sp;
+}
+
 /* Macros and functions for setting and testing a bit in a minimal
    symbol that marks it as 32-bit function.  The MSB of the minimal
    symbol's "info" field is used for this purpose. This field is
@@ -928,7 +943,7 @@ sh64_use_struct_convention (int gcc_p, s
 
    We store structs through a pointer passed in R2 */
 static void
-sh_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
+sh64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 {
   write_register (STRUCT_RETURN_REGNUM, (addr));
 }
@@ -1034,7 +1049,7 @@ sh_find_callers_reg (struct frame_info *
 	  return 0;
 	if (get_frame_saved_regs (fi)[regnum] != 0)
 	  return read_memory_integer (get_frame_saved_regs (fi)[regnum],
-				      REGISTER_RAW_SIZE (regnum));
+				      register_size (current_gdbarch, regnum));
       }
   return read_register (regnum);
 }
@@ -1919,9 +1934,12 @@ sh64_get_saved_register (char *raw_buffe
    the address in which a function should return its structure value,
    as a CORE_ADDR (or an expression that can be used as one).  */
 static CORE_ADDR
-sh_extract_struct_value_address (char *regbuf)
+sh_extract_struct_value_address (struct regcache *regcache)
 {
-  return (extract_unsigned_integer ((regbuf), REGISTER_RAW_SIZE (0)));
+  ULONGEST addr;
+  /*FIXME: Is R0 really correct here?  Not STRUCT_RETURN_REGNUM? */
+  regcache_cooked_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &addr);
+  return addr;
 }
 
 static CORE_ADDR
@@ -2054,8 +2072,11 @@ sh64_pop_frame (void)
    to R7.   */
 
 static CORE_ADDR
-sh_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
-	  	   int struct_return, CORE_ADDR struct_addr)
+sh_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
+		    struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
+		    struct value **args, CORE_ADDR sp, int struct_return,
+		    CORE_ADDR struct_addr)
+
 {
   int stack_offset, stack_alloc;
   int argreg;
@@ -2066,7 +2087,7 @@ sh_push_arguments (int nargs, struct val
   char valbuf[4];
   int len;
   int odd_sized_struct;
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   /* first force sp to a 4-byte alignment */
   sp = sp & ~3;
@@ -2074,7 +2095,7 @@ sh_push_arguments (int nargs, struct val
   /* The "struct return pointer" pseudo-argument has its own dedicated 
      register */
   if (struct_return)
-    write_register (STRUCT_RETURN_REGNUM, struct_addr);
+    regcache_cooked_write_unsigned (regcache, STRUCT_RETURN_REGNUM, struct_addr);
 
   /* Now make sure there's space on the stack */
   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
@@ -2123,16 +2144,24 @@ sh_push_arguments (int nargs, struct val
 	  if (argreg <= tdep->ARGLAST_REGNUM)
 	    {			
 	      /* there's room in a register */
-	      regval = extract_unsigned_integer (val, REGISTER_RAW_SIZE (argreg));
-	      write_register (argreg++, regval);
+	      regval = extract_unsigned_integer (val, register_size (gdbarch,
+								     argreg));
+	      regcache_cooked_write_unsigned (regcache, argreg++, regval);
 	    }
 	  /* Store the value 4 bytes at a time.  This means that things
 	     larger than 4 bytes may go partly in registers and partly
 	     on the stack.  */
-	  len -= REGISTER_RAW_SIZE (argreg);
-	  val += REGISTER_RAW_SIZE (argreg);
+	  len -= register_size (gdbarch, argreg);
+	  val += register_size (gdbarch, argreg);
 	}
     }
+
+  /* Store return address. */
+  regcache_cooked_write_unsigned (regcache, tdep->PR_REGNUM, bp_addr);
+
+  /* Update stack pointer.  */
+  regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
+
   return sp;
 }
 
@@ -2331,7 +2360,7 @@ sh64_push_arguments (int nargs, struct v
    Needed for targets where we don't actually execute a JSR/BSR instruction */
 
 static CORE_ADDR
-sh_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+sh64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 {
   write_register (gdbarch_tdep (current_gdbarch)->PR_REGNUM,
 		  CALL_DUMMY_ADDRESS ());
@@ -2366,7 +2395,8 @@ sh_fix_call_dummy (char *dummy, CORE_ADD
    containing the (raw) register state a function return value of type
    TYPE, and copy that, in virtual format, into VALBUF.  */
 static void
-sh_extract_return_value (struct type *type, char *regbuf, char *valbuf)
+sh_default_extract_return_value (struct type *type, struct regcache *regcache,
+				 void *valbuf)
 {
   int len = TYPE_LENGTH (type);
   int return_register = R0_REGNUM;
@@ -2374,67 +2404,34 @@ sh_extract_return_value (struct type *ty
   
   if (len <= 4)
     {
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	offset = REGISTER_BYTE (return_register) + 4 - len;
-      else
-	offset = REGISTER_BYTE (return_register);
-      memcpy (valbuf, regbuf + offset, len);
+      ULONGEST c;
+
+      regcache_cooked_read_unsigned (regcache, R0_REGNUM, &c);
+      store_unsigned_integer (valbuf, len, c);
     }
-  else if (len <= 8)
+  else if (len == 8)
     {
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	offset = REGISTER_BYTE (return_register) + 8 - len;
-      else
-	offset = REGISTER_BYTE (return_register);
-      memcpy (valbuf, regbuf + offset, len);
+      int i, regnum = R0_REGNUM;
+      for (i = 0; i < len; i += 4)
+	regcache_raw_read (regcache, regnum++, (char *)valbuf + i);
     }
   else
     error ("bad size for return value");
 }
 
 static void
-sh3e_sh4_extract_return_value (struct type *type, char *regbuf, char *valbuf)
+sh3e_sh4_extract_return_value (struct type *type, struct regcache *regcache,
+			       void *valbuf)
 {
-  int return_register;
-  int offset;
-  int len = TYPE_LENGTH (type);
-
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
-    return_register = FP0_REGNUM;
-  else
-    return_register = R0_REGNUM;
-  
-  if (len == 8 && TYPE_CODE (type) == TYPE_CODE_FLT)
     {
-      DOUBLEST val;
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
-	floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
-				 (char *) regbuf + REGISTER_BYTE (return_register),
-				 &val);
-      else
-	floatformat_to_doublest (&floatformat_ieee_double_big,
-				 (char *) regbuf + REGISTER_BYTE (return_register),
-				 &val);
-      deprecated_store_floating (valbuf, len, val);
-    }
-  else if (len <= 4)
-    {
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	offset = REGISTER_BYTE (return_register) + 4 - len;
-      else
-	offset = REGISTER_BYTE (return_register);
-      memcpy (valbuf, regbuf + offset, len);
-    }
-  else if (len <= 8)
-    {
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	offset = REGISTER_BYTE (return_register) + 8 - len;
-      else
-	offset = REGISTER_BYTE (return_register);
-      memcpy (valbuf, regbuf + offset, len);
+      int len = TYPE_LENGTH (type);
+      int i, regnum = FP0_REGNUM;
+      for (i = 0; i < len; i += 4)
+	regcache_raw_read (regcache, regnum++, (char *)valbuf + i);
     }
   else
-    error ("bad size for return value");
+    sh_default_extract_return_value (type, regcache, valbuf);
 }
 
 static void
@@ -2497,35 +2494,38 @@ sh64_extract_return_value (struct type *
    depending on the type of the return value. In all the other cases
    the result is stored in r0, left-justified. */
 static void
-sh_default_store_return_value (struct type *type, char *valbuf)
+sh_default_store_return_value (struct type *type, struct regcache *regcache,
+			       const void *valbuf)
 {
-  char buf[32];	/* more than enough... */
+  ULONGEST val;
+  int len = TYPE_LENGTH (type);
 
-  if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (R0_REGNUM))
+  if (len <= 4)
     {
-      /* Add leading zeros to the value. */
-      memset (buf, 0, REGISTER_RAW_SIZE (R0_REGNUM));
-      if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-	memcpy (buf + REGISTER_RAW_SIZE (R0_REGNUM) - TYPE_LENGTH (type),
-		valbuf, TYPE_LENGTH (type));
-      else
-	memcpy (buf, valbuf, TYPE_LENGTH (type));
-      deprecated_write_register_bytes (REGISTER_BYTE (R0_REGNUM), buf, 
-				       REGISTER_RAW_SIZE (R0_REGNUM));
+      val = extract_unsigned_integer (valbuf, len);
+      regcache_cooked_write_unsigned (regcache, R0_REGNUM, val);
     }
   else
-    deprecated_write_register_bytes (REGISTER_BYTE (R0_REGNUM), valbuf, 
-				     TYPE_LENGTH (type));
+    {
+      int i, regnum = R0_REGNUM;
+      for (i = 0; i < len; i += 4)
+        regcache_raw_write (regcache, regnum++, (char *)valbuf + i);
+    }
 }
 
 static void
-sh3e_sh4_store_return_value (struct type *type, char *valbuf)
+sh3e_sh4_store_return_value (struct type *type, struct regcache *regcache,
+			     const void *valbuf)
 {
   if (TYPE_CODE (type) == TYPE_CODE_FLT) 
-    deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM), 
-				     valbuf, TYPE_LENGTH (type));
+    {
+      int len = TYPE_LENGTH (type);
+      int i, regnum = FP0_REGNUM;
+      for (i = 0; i < len; i += 4)
+        regcache_raw_write (regcache, regnum++, (char *)valbuf + i);
+    }
   else
-    sh_default_store_return_value (type, valbuf);
+    sh_default_store_return_value (type, regcache, valbuf);
 }
 
 static void
@@ -3043,29 +3043,6 @@ sh_show_regs_command (char *args, int fr
     (*sh_show_regs)();
 }
 
-/* Index within `registers' of the first byte of the space for
-   register N.  */
-static int
-sh_default_register_byte (int reg_nr)
-{
-  return (reg_nr * 4);
-}
-
-static int
-sh_sh4_register_byte (int reg_nr)
-{
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
-
-  if (reg_nr >= tdep->DR0_REGNUM 
-      && reg_nr <= tdep->DR_LAST_REGNUM)
-    return (dr_reg_base_num (reg_nr) * 4);
-  else if  (reg_nr >= tdep->FV0_REGNUM 
-	    && reg_nr <= tdep->FV_LAST_REGNUM)
-    return (fv_reg_base_num (reg_nr) * 4);
-  else
-    return (reg_nr * 4);
-}
-
 /* *INDENT-OFF* */
 /*
     SH MEDIA MODE (ISA 32)
@@ -3221,29 +3198,6 @@ sh_sh64_register_byte (int reg_nr)
       + (reg_nr - FP0_REGNUM + 1) * 4);
 }
 
-/* Number of bytes of storage in the actual machine representation for
-   register REG_NR.  */
-static int
-sh_default_register_raw_size (int reg_nr)
-{
-  return 4;
-}
-
-static int
-sh_sh4_register_raw_size (int reg_nr)
-{
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
-
-  if (reg_nr >= tdep->DR0_REGNUM 
-      && reg_nr <= tdep->DR_LAST_REGNUM)
-    return 8;
-  else if  (reg_nr >= tdep->FV0_REGNUM 
-	    && reg_nr <= tdep->FV_LAST_REGNUM)
-    return 16;
-  else
-    return 4;
-}
-
 static int
 sh_sh64_register_raw_size (int reg_nr)
 {
@@ -3268,14 +3222,6 @@ sh_sh64_register_raw_size (int reg_nr)
     return 4;
 }
 
-/* Number of bytes of storage in the program's representation
-   for register N.  */
-static int
-sh_register_virtual_size (int reg_nr)
-{
-  return 4;
-}
-
 /* ??????? FIXME */
 static int
 sh_sh64_register_virtual_size (int reg_nr)
@@ -3290,7 +3236,7 @@ sh_sh64_register_virtual_size (int reg_n
 /* Return the GDB type object for the "standard" data type
    of data in register N.  */
 static struct type *
-sh_sh3e_register_virtual_type (int reg_nr)
+sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
 
@@ -3312,9 +3258,9 @@ sh_sh4_build_float_register_type (int hi
 }
 
 static struct type *
-sh_sh4_register_virtual_type (int reg_nr)
+sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if ((reg_nr >= FP0_REGNUM
        && (reg_nr <= tdep->FP_LAST_REGNUM)) 
@@ -3363,7 +3309,7 @@ sh_sh64_register_virtual_type (int reg_n
 }
 
 static struct type *
-sh_default_register_virtual_type (int reg_nr)
+sh_default_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
   return builtin_type_int;
 }
@@ -3496,10 +3442,10 @@ sh_pseudo_register_read (struct gdbarch 
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   (temp_buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + register_size (gdbarch, base_regnum) * portion));
       /* We must pay attention to the endiannes. */
       sh_sh4_register_convert_to_virtual (reg_nr,
-					  REGISTER_VIRTUAL_TYPE (reg_nr),
+					  gdbarch_register_type (gdbarch, reg_nr),
 					  temp_buffer, buffer);
     }
   else if (reg_nr >= tdep->FV0_REGNUM 
@@ -3511,7 +3457,7 @@ sh_pseudo_register_read (struct gdbarch 
       for (portion = 0; portion < 4; portion++)
 	regcache_raw_read (regcache, base_regnum + portion, 
 			   ((char *) buffer
-			    + REGISTER_RAW_SIZE (base_regnum) * portion));
+			    + register_size (gdbarch, base_regnum) * portion));
     }
 }
 
@@ -3695,14 +3641,14 @@ sh_pseudo_register_write (struct gdbarch
       base_regnum = dr_reg_base_num (reg_nr);
 
       /* We must pay attention to the endiannes. */
-      sh_sh4_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
+      sh_sh4_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr), reg_nr,
 				      buffer, temp_buffer);
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 2; portion++)
 	regcache_raw_write (regcache, base_regnum + portion, 
 			    (temp_buffer
-			     + REGISTER_RAW_SIZE (base_regnum) * portion));
+			     + register_size (gdbarch, base_regnum) * portion));
     }
   else if (reg_nr >= tdep->FV0_REGNUM
 	   && reg_nr <= tdep->FV_LAST_REGNUM)
@@ -3713,7 +3659,7 @@ sh_pseudo_register_write (struct gdbarch
       for (portion = 0; portion < 4; portion++)
 	regcache_raw_write (regcache, base_regnum + portion,
 			    ((char *) buffer
-			     + REGISTER_RAW_SIZE (base_regnum) * portion));
+			     + register_size (gdbarch, base_regnum) * portion));
     }
 }
 
@@ -3886,11 +3832,12 @@ sh64_pseudo_register_write (struct gdbar
 
 /* Floating point vector of 4 float registers. */
 static void
-do_fv_register_info (int fv_regnum)
+do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
+		     int fv_regnum)
 {
   int first_fp_reg_num = fv_reg_base_num (fv_regnum);
-  printf_filtered ("fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
-		     fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM, 
+  fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", 
+		     fv_regnum - gdbarch_tdep (gdbarch)->FV0_REGNUM, 
 		     (int) read_register (first_fp_reg_num),
 		     (int) read_register (first_fp_reg_num + 1),
 		     (int) read_register (first_fp_reg_num + 2),
@@ -3925,12 +3872,13 @@ do_fpp_register_info (int fpp_regnum)
 
 /* Double precision registers. */
 static void
-do_dr_register_info (int dr_regnum)
+do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
+		     int dr_regnum)
 {
   int first_fp_reg_num = dr_reg_base_num (dr_regnum);
 
-  printf_filtered ("dr%d\t0x%08x%08x\n", 
-		    dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM, 
+  fprintf_filtered (file, "dr%d\t0x%08x%08x\n", 
+		    dr_regnum - gdbarch_tdep (gdbarch)->DR0_REGNUM, 
 		    (int) read_register (first_fp_reg_num),
 		    (int) read_register (first_fp_reg_num + 1));
 }
@@ -3986,23 +3934,24 @@ do_cr_c_register_info (int cr_c_regnum)
 }
 
 static void
-sh_do_pseudo_register (int regnum)
+sh_print_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
+			  int regnum)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
     internal_error (__FILE__, __LINE__,
 		    "Invalid pseudo register number %d\n", regnum);
   else if (regnum >= tdep->DR0_REGNUM
 	   && regnum < tdep->DR_LAST_REGNUM)
-    do_dr_register_info (regnum);
+    do_dr_register_info (gdbarch, file, regnum);
   else if (regnum >= tdep->FV0_REGNUM
 	   && regnum <= tdep->FV_LAST_REGNUM)
-    do_fv_register_info (regnum);
+    do_fv_register_info (gdbarch, file, regnum);
 }
 
 static void
-sh_do_fp_register (int regnum)
+sh_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
 {				/* do values for FP (float) regs */
   char *raw_buffer;
   double flt;	/* double extracted from raw hex data */
@@ -4010,7 +3959,7 @@ sh_do_fp_register (int regnum)
   int j;
 
   /* Allocate space for the float. */
-  raw_buffer = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
+  raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
 
   /* Get the data in raw format.  */
   if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
@@ -4020,25 +3969,25 @@ sh_do_fp_register (int regnum)
   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
 
   /* Print the name and some spaces. */
-  fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
-  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
+  fputs_filtered (REGISTER_NAME (regnum), file);
+  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
 
   /* Print the value. */
   if (inv)
-    printf_filtered ("<invalid float>");
+    fprintf_filtered (file, "<invalid float>");
   else
-    printf_filtered ("%-10.9g", flt);
+    fprintf_filtered (file, "%-10.9g", flt);
 
   /* Print the fp register as hex. */
-  printf_filtered ("\t(raw 0x");
-  for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
+  fprintf_filtered (file, "\t(raw 0x");
+  for (j = 0; j < register_size (gdbarch, regnum); j++)
     {
       register int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
-	: REGISTER_RAW_SIZE (regnum) - 1 - j;
-      printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
+	: register_size (gdbarch, regnum) - 1 - j;
+      fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
     }
-  printf_filtered (")");
-  printf_filtered ("\n");
+  fprintf_filtered (file, ")");
+  fprintf_filtered (file, "\n");
 }
 
 static void
@@ -4054,7 +4003,7 @@ sh64_do_pseudo_register (int regnum)
 
   else if ((regnum >= tdep->DR0_REGNUM
 	    && regnum <= tdep->DR_LAST_REGNUM))
-    do_dr_register_info (regnum);
+    do_dr_register_info (current_gdbarch, gdb_stdout, regnum);
 
   else if ((regnum >= tdep->DR0_C_REGNUM
 	    && regnum <= tdep->DR_LAST_C_REGNUM))
@@ -4062,7 +4011,7 @@ sh64_do_pseudo_register (int regnum)
 
   else if ((regnum >= tdep->FV0_REGNUM
 	    && regnum <= tdep->FV_LAST_REGNUM))
-    do_fv_register_info (regnum);
+    do_fv_register_info (current_gdbarch, gdb_stdout, regnum);
 	   
   else if ((regnum >= tdep->FV0_C_REGNUM
 	    && regnum <= tdep->FV_LAST_C_REGNUM))
@@ -4078,7 +4027,7 @@ sh64_do_pseudo_register (int regnum)
 
   else if (regnum >= tdep->FP0_C_REGNUM
 	   && regnum <= tdep->FP_LAST_C_REGNUM)
-    sh_do_fp_register (regnum); /* this should work also for pseudoregs */
+    sh_do_fp_register (current_gdbarch, gdb_stdout, regnum); /* this should work also for pseudoregs */
 
   else if (regnum >= tdep->PC_C_REGNUM
 	   && regnum <= tdep->FPUL_C_REGNUM)
@@ -4087,27 +4036,27 @@ sh64_do_pseudo_register (int regnum)
 }
 
 static void
-sh_do_register (int regnum)
+sh_do_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
 {
   char raw_buffer[MAX_REGISTER_SIZE];
 
-  fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
-  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
+  fputs_filtered (REGISTER_NAME (regnum), file);
+  print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
 
   /* Get the data in raw format.  */
   if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
-    printf_filtered ("*value not available*\n");
+    fprintf_filtered (file, "*value not available*\n");
       
-  val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
-	     gdb_stdout, 'x', 1, 0, Val_pretty_default);
-  printf_filtered ("\t");
-  val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
-	     gdb_stdout, 0, 1, 0, Val_pretty_default);
-  printf_filtered ("\n");
+  val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
+	     file, 'x', 1, 0, Val_pretty_default);
+  fprintf_filtered (file, "\t");
+  val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
+	     file, 0, 1, 0, Val_pretty_default);
+  fprintf_filtered (file, "\n");
 }
 
 static void
-sh_print_register (int regnum)
+sh_print_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
 {
   if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
     internal_error (__FILE__, __LINE__,
@@ -4115,25 +4064,31 @@ sh_print_register (int regnum)
 
   else if (regnum >= 0 && regnum < NUM_REGS)
     {
-      if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
-	sh_do_fp_register (regnum);	/* FP regs */
+      if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
+	sh_do_fp_register (gdbarch, file, regnum);	/* FP regs */
       else
-	sh_do_register (regnum);	/* All other regs */
+	sh_do_register (gdbarch, file, regnum);	/* All other regs */
     }
 
   else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
-    do_pseudo_register (regnum);
+    {
+      if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh5)
+	sh64_do_pseudo_register (regnum);
+      else
+	sh_print_pseudo_register (gdbarch, file, regnum);
+    }
 }
 
 static void
-sh_do_registers_info (int regnum, int fpregs)
+sh_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
+			 struct frame_info *frame, int regnum, int fpregs)
 {
   if (regnum != -1)		/* do one specified register */
     {
       if (*(REGISTER_NAME (regnum)) == '\0')
 	error ("Not a valid register for the current processor type");
 
-      sh_print_register (regnum);
+      sh_print_register (gdbarch, file, regnum);
     }
   else
     /* do all (or most) registers */
@@ -4150,20 +4105,20 @@ sh_do_registers_info (int regnum, int fp
 	      continue;
 	    }
 
-	  if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
+	  if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
 	    {
 	      if (fpregs)
 		{
 		  /* true for "INFO ALL-REGISTERS" command */
-		  sh_do_fp_register (regnum);	/* FP regs */
+		  sh_do_fp_register (gdbarch, file, regnum);	/* FP regs */
 		  regnum ++;
 		}
 	      else
-		regnum += (gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM - FP0_REGNUM);	/* skip FP regs */
+		regnum += (gdbarch_tdep (gdbarch)->FP_LAST_REGNUM - FP0_REGNUM);	/* skip FP regs */
 	    }
 	  else
 	    {
-	      sh_do_register (regnum);	/* All other regs */
+	      sh_do_register (gdbarch, file, regnum);	/* All other regs */
 	      regnum++;
 	    }
 	}
@@ -4171,7 +4126,10 @@ sh_do_registers_info (int regnum, int fp
       if (fpregs)
 	while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
 	  {
-	    do_pseudo_register (regnum);
+	    if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh5)
+	      sh64_do_pseudo_register (regnum);
+	    else
+	      sh_print_pseudo_register (gdbarch, file, regnum);
 	    regnum++;
 	  }
     }
@@ -4189,7 +4147,7 @@ sh_compact_do_registers_info (int regnum
       if (regnum >= 0 && regnum < tdep->R0_C_REGNUM)
         error ("Not a valid register for the current processor mode.");
 
-      sh_print_register (regnum);
+      sh_print_register (current_gdbarch, gdb_stdout, regnum);
     }
   else
     /* do all compact registers */
@@ -4197,7 +4155,7 @@ sh_compact_do_registers_info (int regnum
       regnum = tdep->R0_C_REGNUM;
       while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
         {
-          do_pseudo_register (regnum);
+          sh64_do_pseudo_register (regnum);
           regnum++;
         }
     }
@@ -4207,7 +4165,8 @@ static void
 sh64_do_registers_info (int regnum, int fpregs)
 {
   if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
-   sh_do_registers_info (regnum, fpregs);
+   sh_print_registers_info (current_gdbarch, gdb_stdout,
+			    deprecated_selected_frame, regnum, fpregs);
   else
    sh_compact_do_registers_info (regnum, fpregs); 
 }
@@ -4303,12 +4262,9 @@ static gdbarch_init_ftype sh_gdbarch_ini
 static struct gdbarch *
 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 {
-  static LONGEST sh_call_dummy_words[] = {0};
+  static LONGEST sh64_call_dummy_words[] = {0};
   struct gdbarch *gdbarch;
   struct gdbarch_tdep *tdep;
-  gdbarch_register_name_ftype *sh_register_name;
-  gdbarch_deprecated_store_return_value_ftype *sh_store_return_value;
-  gdbarch_deprecated_register_virtual_type_ftype *sh_register_virtual_type;
 
   /* If there is already a candidate, use it.  */
   arches = gdbarch_list_lookup_by_info (arches, &info);
@@ -4359,80 +4315,104 @@ sh_gdbarch_init (struct gdbarch_info inf
 
   tdep->sh_abi = SH_ABI_UNKNOWN;
 
-  set_gdbarch_fp0_regnum (gdbarch, -1);
-  set_gdbarch_num_pseudo_regs (gdbarch, 0);
-  set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
-  set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
+  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+  set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+  set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+  set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+  set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+
   set_gdbarch_num_regs (gdbarch, SH_DEFAULT_NUM_REGS);
   set_gdbarch_sp_regnum (gdbarch, 15);
   set_gdbarch_deprecated_fp_regnum (gdbarch, 14);
   set_gdbarch_pc_regnum (gdbarch, 16);
-  set_gdbarch_deprecated_register_size (gdbarch, 4);
-  set_gdbarch_deprecated_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4);
-  set_gdbarch_deprecated_do_registers_info (gdbarch, sh_do_registers_info);
+  set_gdbarch_fp0_regnum (gdbarch, -1);
+  set_gdbarch_num_pseudo_regs (gdbarch, 0);
+
   set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
-  set_gdbarch_deprecated_frame_chain (gdbarch, sh_frame_chain);
-  set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
-  set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
-  set_gdbarch_deprecated_extract_return_value (gdbarch, sh_extract_return_value);
-  set_gdbarch_deprecated_push_arguments (gdbarch, sh_push_arguments);
-  set_gdbarch_deprecated_store_struct_return (gdbarch, sh_store_struct_return);
   set_gdbarch_use_struct_convention (gdbarch, sh_use_struct_convention);
-  set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
-  set_gdbarch_deprecated_pop_frame (gdbarch, sh_pop_frame);
+
   set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
+
+  set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
+
+  set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
+  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+  set_gdbarch_decr_pc_after_break (gdbarch, 0);
+  set_gdbarch_function_start_offset (gdbarch, 0);
+
+  set_gdbarch_frame_args_skip (gdbarch, 0);
+  set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
+  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+
   skip_prologue_hard_way = sh_skip_prologue_hard_way;
-  do_pseudo_register = sh_do_pseudo_register;
+
+  set_gdbarch_deprecated_frame_chain (gdbarch, sh_frame_chain);
+  set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
+  set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
+  set_gdbarch_deprecated_pop_frame (gdbarch, sh_pop_frame);
+  set_gdbarch_deprecated_frame_saved_pc (gdbarch, sh_frame_saved_pc);
+  set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
 
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_sh:
-      sh_register_name = sh_sh_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh_generic_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
+
       set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
       break;
     case bfd_mach_sh2:
-      sh_register_name = sh_sh_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh_generic_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
+
       set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
       break;      
     case bfd_mach_sh2e:
-      sh_register_name = sh_sh2e_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh2e_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh2e_show_regs;
-      sh_store_return_value = sh3e_sh4_store_return_value;
-      sh_register_virtual_type = sh_sh3e_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
+      set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
       set_gdbarch_fp0_regnum (gdbarch, 25);
+      set_gdbarch_store_return_value (gdbarch, sh3e_sh4_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->FPUL_REGNUM = 23;
       tdep->FPSCR_REGNUM = 24;
       tdep->FP_LAST_REGNUM = 40;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
       break;
     case bfd_mach_sh_dsp:
-      sh_register_name = sh_sh_dsp_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh_dsp_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh_dsp_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
       set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->DSR_REGNUM = 24;
       tdep->A0G_REGNUM = 25;
       tdep->A0_REGNUM = 26;
@@ -4447,45 +4427,53 @@ sh_gdbarch_init (struct gdbarch_info inf
       tdep->MOD_REGNUM = 40;
       tdep->RS_REGNUM = 43;
       tdep->RE_REGNUM = 44;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
       break;
     case bfd_mach_sh3:
-      sh_register_name = sh_sh3_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh3_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh3_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->SSR_REGNUM = 41;
       tdep->SPC_REGNUM = 42;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
       break;
     case bfd_mach_sh3e:
-      sh_register_name = sh_sh3e_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh3e_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh3e_show_regs;
-      sh_store_return_value = sh3e_sh4_store_return_value;
-      sh_register_virtual_type = sh_sh3e_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
-      set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
+      set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
       set_gdbarch_fp0_regnum (gdbarch, 25);
+      set_gdbarch_store_return_value (gdbarch, sh3e_sh4_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->FPUL_REGNUM = 23;
       tdep->FPSCR_REGNUM = 24;
       tdep->FP_LAST_REGNUM = 40;
       tdep->SSR_REGNUM = 41;
       tdep->SPC_REGNUM = 42;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
       break;
     case bfd_mach_sh3_dsp:
-      sh_register_name = sh_sh3_dsp_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh3_dsp_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh3_dsp_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->DSR_REGNUM = 24;
       tdep->A0G_REGNUM = 25;
       tdep->A0_REGNUM = 26;
@@ -4502,23 +4490,23 @@ sh_gdbarch_init (struct gdbarch_info inf
       tdep->RE_REGNUM = 44;
       tdep->SSR_REGNUM = 41;
       tdep->SPC_REGNUM = 42;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
       break;
     case bfd_mach_sh4:
-      sh_register_name = sh_sh4_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh4_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh4_show_regs;
-      sh_store_return_value = sh3e_sh4_store_return_value;
-      sh_register_virtual_type = sh_sh4_register_virtual_type;
-      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
-      set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
+      set_gdbarch_register_type (gdbarch, sh_sh4_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
       set_gdbarch_fp0_regnum (gdbarch, 25);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_sh4_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_sh4_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_sh4_register_byte);
       set_gdbarch_num_pseudo_regs (gdbarch, 12);
-      set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4 * 4);
-      set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4 * 4);
       set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
       set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
+      set_gdbarch_store_return_value (gdbarch, sh3e_sh4_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
+      set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call);
+      set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
       tdep->FPUL_REGNUM = 23;
       tdep->FPSCR_REGNUM = 24;
       tdep->FP_LAST_REGNUM = 40;
@@ -4528,6 +4516,8 @@ sh_gdbarch_init (struct gdbarch_info inf
       tdep->DR_LAST_REGNUM = 66;
       tdep->FV0_REGNUM = 67;
       tdep->FV_LAST_REGNUM = 70;
+
+      set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
       break;
     case bfd_mach_sh5:
       tdep->PR_REGNUM = 18;
@@ -4589,16 +4579,15 @@ sh_gdbarch_init (struct gdbarch_info inf
 	 ISA16(compact) or ISA32(media). */
       set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
       set_gdbarch_deprecated_register_size (gdbarch, 8); /*????*/
-      set_gdbarch_deprecated_register_bytes (gdbarch, 
+      set_gdbarch_deprecated_register_bytes (gdbarch,
 					     ((SIM_SH64_NR_FP_REGS + 1) * 4)
 					     + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
 
-      sh_register_name = sh_sh64_register_name;
+      set_gdbarch_register_name (gdbarch, sh_sh64_register_name);
       sh_show_regs = sh64_show_regs;
-      sh_register_virtual_type = sh_sh64_register_virtual_type;
-      sh_store_return_value = sh64_store_return_value;
+      set_gdbarch_deprecated_register_virtual_type (gdbarch, sh_sh64_register_virtual_type);
+      set_gdbarch_deprecated_store_return_value (gdbarch, sh64_store_return_value);
       skip_prologue_hard_way = sh64_skip_prologue_hard_way;
-      do_pseudo_register = sh64_do_pseudo_register;
       set_gdbarch_deprecated_register_raw_size (gdbarch, sh_sh64_register_raw_size);
       set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_sh64_register_raw_size);
       set_gdbarch_deprecated_register_byte (gdbarch, sh_sh64_register_byte);
@@ -4615,12 +4604,17 @@ sh_gdbarch_init (struct gdbarch_info inf
       set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info);
       set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
       set_gdbarch_breakpoint_from_pc (gdbarch, sh_sh64_breakpoint_from_pc);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, sh64_call_dummy_words);
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh64_call_dummy_words));
+
       set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
       set_gdbarch_deprecated_frame_chain (gdbarch, sh64_frame_chain);
       set_gdbarch_deprecated_get_saved_register (gdbarch, sh64_get_saved_register);
       set_gdbarch_deprecated_extract_return_value (gdbarch, sh64_extract_return_value);
       set_gdbarch_deprecated_push_arguments (gdbarch, sh64_push_arguments);
-      /*set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return);*/
+      set_gdbarch_deprecated_push_return_address (gdbarch, sh64_push_return_address);
+      set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
+      set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return);
       set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address);
       set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention);
       set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame);
@@ -4628,46 +4622,17 @@ sh_gdbarch_init (struct gdbarch_info inf
                                             sh64_elf_make_msymbol_special);
       break;
     default:
-      sh_register_name = sh_generic_register_name;
+      set_gdbarch_register_name (gdbarch, sh_generic_register_name);
+      set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
       sh_show_regs = sh_generic_show_regs;
-      sh_store_return_value = sh_default_store_return_value;
-      sh_register_virtual_type = sh_default_register_virtual_type;
+      set_gdbarch_register_type (gdbarch, sh_default_register_type);
+      set_gdbarch_push_dummy_code (gdbarch, sh_push_dummy_code);
+      set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value);
+      set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value);
+
       set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
-      set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size);
-      set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte);
       break;
     }
-
-  set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
-
-  set_gdbarch_register_name (gdbarch, sh_register_name);
-  set_gdbarch_deprecated_register_virtual_type (gdbarch, sh_register_virtual_type);
-
-  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-  set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-  set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-
-  set_gdbarch_deprecated_call_dummy_words (gdbarch, sh_call_dummy_words);
-  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
-
-  set_gdbarch_deprecated_push_return_address (gdbarch, sh_push_return_address);
-
-  set_gdbarch_deprecated_store_return_value (gdbarch, sh_store_return_value);
-  set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
-  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
-  set_gdbarch_decr_pc_after_break (gdbarch, 0);
-  set_gdbarch_function_start_offset (gdbarch, 0);
-
-  set_gdbarch_frame_args_skip (gdbarch, 0);
-  set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
-  set_gdbarch_deprecated_frame_saved_pc (gdbarch, sh_frame_saved_pc);
-  set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
-  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 
   /* Hook in ABI-specific overrides, if they have been registered.  */
   gdbarch_init_osabi (info, gdbarch);

-- 
Corinna Vinschen
Cygwin Developer
Red Hat, Inc.
mailto:vinschen@redhat.com


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]