This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[RFA] Undeprecate sh to sh4
- From: Corinna Vinschen <vinschen at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Mon, 14 Jul 2003 13:27:25 +0200
- Subject: [RFA] Undeprecate sh to sh4
- Reply-to: gdb-patches at sources dot redhat dot com
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