void (*sh_show_regs) (void);
CORE_ADDR (*skip_prologue_hard_way) (CORE_ADDR);
-void (*do_pseudo_register) (int);
#define SH_DEFAULT_NUM_REGS 59
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
#define MSYMBOL_IS_SPECIAL(msym) \
(((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
-void
+static void
sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
{
if (msym == NULL)
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));
}
/* Given a GDB frame, determine the address of the calling function's
frame. This will be used to create a new GDB frame struct, and
- then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
- called for the new frame.
+ then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
+ will be called for the new frame.
For us, the frame address is its stack pointer value, so we look up
the function prologue to determine the caller's sp value, and return it. */
if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
size = 4;
else
- size = REGISTER_RAW_SIZE (translate_insn_rn (FP_REGNUM, media_mode));
+ size = REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode));
return read_memory_integer (get_frame_base (frame)
+ get_frame_extra_info (frame)->f_offset,
size);
get_frame_base (fi), regnum);
else
{
- FRAME_INIT_SAVED_REGS (fi);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
if (!get_frame_pc (fi))
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);
}
get_frame_base (fi), pr_regnum);
else
{
- FRAME_INIT_SAVED_REGS (fi);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
if (!get_frame_pc (fi))
return 0;
that does not appear to be part of the prologue. But give up
after 20 of them, since we're getting silly then. */
- pc = get_pc_function_start (get_frame_pc (fi));
+ pc = get_frame_func (fi);
if (!pc)
{
deprecated_update_frame_pc_hack (fi, 0);
{
if (where[rn] >= 0)
{
- if (rn == FP_REGNUM)
+ if (rn == DEPRECATED_FP_REGNUM)
have_fp = 1;
get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4;
if (have_fp)
{
- get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
+ get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4);
}
else
{
get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4;
}
- get_frame_extra_info (fi)->f_offset = depth - where[FP_REGNUM] - 4;
+ get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4;
/* Work out the return pc - either from the saved pr or the pr
value */
}
&& rn <= tdep->FV_LAST_REGNUM);
}
-int
+static int
sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc)
{
return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc));
that does not appear to be part of the prologue. But give up
after 20 of them, since we're getting silly then. */
- pc = get_pc_function_start (get_frame_pc (fi));
+ pc = get_frame_func (fi);
if (!pc)
{
deprecated_update_frame_pc_hack (fi, 0);
/* The frame pointer register is general register 14 in shmedia and
shcompact modes. In sh compact it is a pseudo register. Same goes
for the stack pointer register, which is register 15. */
- fp_regnum = translate_insn_rn (FP_REGNUM, media_mode);
+ fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode);
sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
for (opc = pc + (insn_size * 28); pc < opc; pc += insn_size)
register r15 which still is the SP register. */
/* The place on the stack where fp is stored contains the sp of
the caller. */
- /* Again, saved_registers contains only space for the real registers,
- so we store in FP_REGNUM position. */
+ /* Again, saved_registers contains only space for the real
+ registers, so we store in DEPRECATED_FP_REGNUM position. */
int size;
if (tdep->sh_abi == SH_ABI_32)
size = 4;
that does not appear to be part of the prologue. But give up
after 20 of them, since we're getting silly then. */
- pc = get_pc_function_start (get_frame_pc (fi));
+ pc = get_frame_func (fi);
if (!pc)
{
deprecated_update_frame_pc_hack (fi, 0);
{
if (where[rn] >= 0)
{
- if (rn == FP_REGNUM)
+ if (rn == DEPRECATED_FP_REGNUM)
have_fp = 1;
get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4;
if (have_fp)
{
get_frame_saved_regs (fi)[SP_REGNUM] =
- read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
+ read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4);
}
else
{
get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4;
}
- get_frame_extra_info (fi)->f_offset = depth - where[FP_REGNUM] - 4;
+ get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4;
/* Work out the return pc - either from the saved pr or the pr
value */
}
frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
if (get_next_frame (fi))
- deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (get_next_frame (fi)));
+ deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
get_frame_base (fi)))
{
- /* We need to setup fi->frame here because run_stack_dummy gets it wrong
- by assuming it's always FP. */
+ /* We need to setup fi->frame here because call_function_by_hand
+ gets it wrong by assuming it's always FP. */
deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi),
SP_REGNUM));
get_frame_extra_info (fi)->return_pc = deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi),
PC_REGNUM);
- get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
+ get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->leaf_function = 0;
return;
}
else
{
- FRAME_INIT_SAVED_REGS (fi);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
get_frame_extra_info (fi)->return_pc =
sh_find_callers_reg (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM);
}
frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
if (get_next_frame (fi))
- deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (get_next_frame (fi)));
+ deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
get_frame_base (fi)))
{
- /* We need to setup fi->frame here because run_stack_dummy gets it wrong
- by assuming it's always FP. */
+ /* We need to setup fi->frame here because call_function_by_hand
+ gets it wrong by assuming it's always FP. */
deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
get_frame_extra_info (fi)->return_pc =
deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), PC_REGNUM);
- get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
+ get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->leaf_function = 0;
return;
}
else
{
- FRAME_INIT_SAVED_REGS (fi);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
get_frame_extra_info (fi)->return_pc =
sh64_get_saved_pr (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM);
}
}
-void
+static void
sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
struct frame_info *frame, int regnum,
enum lval_type *lval)
return;
}
- FRAME_INIT_SAVED_REGS (frame);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
if (get_frame_saved_regs (frame) != NULL
&& get_frame_saved_regs (frame)[regnum] != 0)
{
if (regnum == SP_REGNUM)
{
if (raw_buffer) /* SP register treated specially */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
- get_frame_saved_regs (frame)[regnum]);
+ store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
+ get_frame_saved_regs (frame)[regnum]);
}
else
{ /* any other register */
{
int size;
if (tdep->sh_abi == SH_ABI_32
- && (live_regnum == FP_REGNUM
+ && (live_regnum == DEPRECATED_FP_REGNUM
|| live_regnum == tdep->PR_REGNUM))
size = 4;
else
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_address ((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
sh64_extract_struct_value_address (char *regbuf)
{
- return (extract_address ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
- REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
+ return (extract_unsigned_integer ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
+ REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
}
static CORE_ADDR
else
{
fp = get_frame_base (frame);
- FRAME_INIT_SAVED_REGS (frame);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
/* Copy regs from where they were saved in the frame */
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
else
{
fp = get_frame_base (frame);
- FRAME_INIT_SAVED_REGS (frame);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
/* Copy regs from where they were saved in the frame */
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
{
int size;
if (tdep->sh_abi == SH_ABI_32
- && (regnum == FP_REGNUM
+ && (regnum == DEPRECATED_FP_REGNUM
|| regnum == tdep->PR_REGNUM))
size = 4;
else
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;
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;
/* 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++)
if (argreg <= tdep->ARGLAST_REGNUM)
{
/* there's room in a register */
- regval = extract_address (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;
}
if (int_argreg <= tdep->ARGLAST_REGNUM)
{
/* there's room in a register */
- regval = extract_address (val, argreg_size);
+ regval = extract_unsigned_integer (val, argreg_size);
write_register (int_argreg, regval);
}
/* Store the value 8 bytes at a time. This means that
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
{
memset (valbuf_tmp, 0, sizeof (valbuf_tmp));
- REGISTER_CONVERT_TO_VIRTUAL (regnum,
- type, val, valbuf_tmp);
+ DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum,
+ type, val,
+ valbuf_tmp);
val = valbuf_tmp;
}
#endif
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 ());
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;
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);
- 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
else
floatformat_to_doublest (&floatformat_ieee_double_big,
(char *) regbuf + offset, &val);
- store_floating (valbuf, len, val);
+ deprecated_store_floating (valbuf, len, val);
}
}
else
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
sh64_show_compact_regs ();
}
-void sh_show_regs_command (char *args, int from_tty)
+static void
+sh_show_regs_command (char *args, int from_tty)
{
if (sh_show_regs)
(*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)
+ (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)
{
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)
/* 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);
}
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))
}
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;
}
{
DOUBLEST val;
floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
- store_floating (to, TYPE_LENGTH (type), val);
+ store_typed_floating (to, type, val);
}
else
error ("sh_register_convert_to_virtual called with non DR register number");
}
-void
+static void
sh_sh64_register_convert_to_virtual (int regnum, struct type *type,
char *from, char *to)
{
{
DOUBLEST val;
floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
- store_floating(to, TYPE_LENGTH(type), val);
+ deprecated_store_floating(to, TYPE_LENGTH(type), val);
}
else
error("sh_register_convert_to_virtual called with non DR register number");
if (regnum >= tdep->DR0_REGNUM
&& regnum <= tdep->DR_LAST_REGNUM)
{
- DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
+ DOUBLEST val = extract_typed_floating (from, type);
floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
}
else
error("sh_register_convert_to_raw called with non DR register number");
}
-void
+static void
sh_sh64_register_convert_to_raw (struct type *type, int regnum,
const void *from, void *to)
{
|| (regnum >= tdep->DR0_C_REGNUM
&& regnum <= tdep->DR_LAST_C_REGNUM))
{
- DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
+ DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
}
else
error("sh_register_convert_to_raw called with non DR register number");
}
-void
+static void
sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, void *buffer)
{
int base_regnum, portion;
- char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char temp_buffer[MAX_REGISTER_SIZE];
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
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
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));
}
}
int base_regnum;
int portion;
int offset = 0;
- char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char temp_buffer[MAX_REGISTER_SIZE];
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
}
}
-void
+static void
sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, const void *buffer)
{
int base_regnum, portion;
- char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char temp_buffer[MAX_REGISTER_SIZE];
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
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)
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));
}
}
-void
+static void
sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, const void *buffer)
{
int base_regnum, portion;
int offset;
- char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char temp_buffer[MAX_REGISTER_SIZE];
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
/* 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),
/* 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));
}
}
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);
+ && regnum <= tdep->DR_LAST_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 */
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))
+ if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
/* Get the register as a number */
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
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))
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))
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)
}
static void
-sh_do_register (int regnum)
+sh_do_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
{
- char *raw_buffer = alloca (max_register_size (current_gdbarch));
+ 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");
+ if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
+ 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__,
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);
+ }
}
-void
-sh_do_registers_info (int regnum, int fpregs)
+static void
+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 */
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++;
}
}
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++;
}
}
}
-void
+static void
sh_compact_do_registers_info (int regnum, int fpregs)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
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 */
regnum = tdep->R0_C_REGNUM;
while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
{
- do_pseudo_register (regnum);
+ sh64_do_pseudo_register (regnum);
regnum++;
}
}
}
-void
+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);
}
{
if (legacy_register_sim_regno (nr) < 0)
return legacy_register_sim_regno (nr);
- if (nr >= DSP_DSR_REGNUM && nr < DSP_Y1_REGNUM)
+ if (nr >= DSP_DSR_REGNUM && nr <= DSP_Y1_REGNUM)
return nr - DSP_DSR_REGNUM + SIM_SH_DSR_REGNUM;
if (nr == DSP_MOD_REGNUM)
return SIM_SH_MOD_REGNUM;
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_register_virtual_type_ftype *sh_register_virtual_type;
/* If there is already a candidate, use it. */
arches = gdbarch_list_lookup_by_info (arches, &info);
tdep->sh_abi = SH_ABI_UNKNOWN;
- set_gdbarch_fp0_regnum (gdbarch, -1);
- set_gdbarch_num_pseudo_regs (gdbarch, 0);
- set_gdbarch_max_register_raw_size (gdbarch, 4);
- set_gdbarch_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_fp_regnum (gdbarch, 14);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, 14);
set_gdbarch_pc_regnum (gdbarch, 16);
- set_gdbarch_register_size (gdbarch, 4);
- set_gdbarch_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_frame_chain (gdbarch, sh_frame_chain);
- set_gdbarch_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
- set_gdbarch_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
- set_gdbarch_deprecated_extract_return_value (gdbarch, sh_extract_return_value);
- set_gdbarch_push_arguments (gdbarch, sh_push_arguments);
- set_gdbarch_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_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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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);
+
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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);
+
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
break;
case bfd_mach_sh2e:
- sh_register_name = sh_sh2e_register_name;
+ /* doubles on sh2e and sh3e are actually 4 byte. */
+ set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+
+ 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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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;
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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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;
+ /* doubles on sh2e and sh3e are actually 4 byte. */
+ set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+
+ 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_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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;
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_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_register_raw_size (gdbarch, sh_sh4_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_sh4_register_raw_size);
- set_gdbarch_register_byte (gdbarch, sh_sh4_register_byte);
set_gdbarch_num_pseudo_regs (gdbarch, 12);
- set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
- set_gdbarch_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;
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;
/* the number of real registers is the same whether we are in
ISA16(compact) or ISA32(media). */
set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
- set_gdbarch_register_size (gdbarch, 8); /*????*/
- set_gdbarch_register_bytes (gdbarch,
- ((SIM_SH64_NR_FP_REGS + 1) * 4)
- + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
+ set_gdbarch_deprecated_register_size (gdbarch, 8); /*????*/
+ 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_register_raw_size (gdbarch, sh_sh64_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_sh64_register_raw_size);
- set_gdbarch_register_byte (gdbarch, sh_sh64_register_byte);
+ 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);
/* This seems awfully wrong!*/
- /*set_gdbarch_max_register_raw_size (gdbarch, 8);*/
+ /*set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);*/
/* should include the size of the pseudo regs. */
- set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4 * 4);
/* Or should that go in the virtual_size? */
- /*set_gdbarch_max_register_virtual_size (gdbarch, 8);*/
- set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
+ /*set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);*/
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4 * 4);
set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info);
- set_gdbarch_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
+ 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_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, sh64_frame_chain);
- set_gdbarch_get_saved_register (gdbarch, sh64_get_saved_register);
+ 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_push_arguments (gdbarch, sh64_push_arguments);
- /*set_gdbarch_store_struct_return (gdbarch, sh64_store_struct_return);*/
+ set_gdbarch_deprecated_push_arguments (gdbarch, sh64_push_arguments);
+ 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_pop_frame (gdbarch, sh64_pop_frame);
+ set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame);
set_gdbarch_elf_make_msymbol_special (gdbarch,
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_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
- set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
- set_gdbarch_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_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
break;
}
- set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
- set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
- set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
- set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
-
- set_gdbarch_register_name (gdbarch, sh_register_name);
- set_gdbarch_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_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); /*???*/
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
- set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
-
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_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_frame_saved_pc (gdbarch, sh_frame_saved_pc);
- set_gdbarch_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
- set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
- set_gdbarch_believe_pcc_promotion (gdbarch, 1);
-
/* Hook in ABI-specific overrides, if they have been registered. */
gdbarch_init_osabi (info, gdbarch);
/* FIXME: dump the rest of gdbarch_tdep. */
}
+extern initialize_file_ftype _initialize_sh_tdep; /* -Wmissing-prototypes */
+
void
_initialize_sh_tdep (void)
{