23 #include "gdb/sim-m32c.h"
95 #define M32C_MAX_NUM_REGS (75)
98 #define M32C_MAX_DWARF_REGNUM (40)
147 int data_addr_reg_bits, code_addr_reg_bits;
167 data_addr_reg_bits = 16;
168 code_addr_reg_bits = 24;
175 data_addr_reg_bits = 24;
176 code_addr_reg_bits = 24;
196 xsnprintf (type_name,
sizeof (type_name),
"%s_data_addr_t",
200 xstrdup (type_name));
204 xsnprintf (type_name,
sizeof (type_name),
"%s_code_addr_t",
208 xstrdup (type_name));
277 if (group == m32c_dma_reggroup
415 int elt_offset = reg->
n * elt_len;
418 if (elt_offset + elt_len > containing_len)
420 elt_len = containing_len - elt_offset;
430 *offset_p = elt_offset;
475 unsigned char *cbuf = buf;
506 unsigned char *cbuf = buf;
536 unsigned char *cbuf = buf;
573 unsigned char *cbuf = buf;
603 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
606 reg = &tdep->
regs[cookednum];
608 return reg->
read (reg, cache, buf);
621 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
624 reg = &tdep->
regs[cookednum];
626 reg->
write (reg, cache, (
void *) buf);
722 #define FLAGBIT_B 0x0010
723 #define FLAGBIT_U 0x0080
730 #define R(name, type, sim_num) \
731 (add_reg (arch, (name), (type), (sim_num), \
732 m32c_raw_read, m32c_raw_write, NULL, NULL, 0))
735 #define SIM(name) (m32c_sim_reg_ ## name)
740 (R(#name, tdep->uint16, SIM (name)))
745 (R(#name, tdep->data_addr_reg_type, SIM (name)))
750 (R(#name, tdep->code_addr_reg_type, SIM (name)))
754 #define RP(name, type) \
755 (R(#name "0", (type), SIM (name ## 0)), \
756 R(#name "1", (type), SIM (name ## 1)) - 1)
761 (R(NULL, tdep->int16, SIM (name ## _bank0)), \
762 R(NULL, tdep->int16, SIM (name ## _bank1)) - 1)
767 (R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank0)), \
768 R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank1)) - 1)
774 #define CB(name, raw_pair) \
775 (add_reg (arch, #name, (raw_pair)->type, 0, \
776 m32c_banked_read, m32c_banked_write, \
777 (raw_pair), (raw_pair + 1), FLAGBIT_B))
782 #define CHL(name, type) \
783 (add_reg (arch, #name "h", (type), 0, \
784 m32c_part_read, m32c_part_write, name, NULL, 1), \
785 add_reg (arch, #name "l", (type), 0, \
786 m32c_part_read, m32c_part_write, name, NULL, 0) - 1)
790 #define CCAT(high, low, type) \
791 (add_reg (arch, #high #low, (type), 0, \
792 m32c_cat_read, m32c_cat_write, (high), (low), 0))
795 #define G(reg) (mark_general (reg))
796 #define S(reg) (mark_system (reg))
797 #define DMA(reg) (mark_dma (reg))
848 if (mach == bfd_mach_m32c)
864 r0 =
G (
CB (r0, raw_r0_pair));
865 r1 =
G (
CB (r1, raw_r1_pair));
866 r2 =
G (
CB (r2, raw_r2_pair));
867 r3 =
G (
CB (r3, raw_r3_pair));
868 a0 =
G (
CB (a0, raw_a0_pair));
869 a1 =
G (
CB (a1, raw_a1_pair));
870 fb =
G (
CB (fb, raw_fb_pair));
876 raw_sb_pair, raw_sb_pair + 1, 0));
892 r3r1r2r0 =
CCAT (r3r1, r2r0, tdep->
int64);
898 if (mach == bfd_mach_m16c)
903 num_cooked_regs = tdep->
num_regs - num_raw_regs;
1000 static const unsigned char *
1003 static unsigned char break_insn[] = { 0x00 };
1005 *len =
sizeof (break_insn);
1070 #define M32C_MAX_INSN_LEN (9)
1163 int mask = 1 << (bits - 1);
1164 return (v ^ mask) - mask;
1194 return low + (high << 8);
1215 return low + (mid << 8) + (high << 16);
1223 return (((i[0] & 0x70) >> 2)
1224 | ((i[1] & 0x30) >> 4));
1232 return (((i[0] & 0x0e) << 1)
1233 | ((i[1] & 0xc0) >> 6));
1253 case 0x0: sd.
reg = (
size == 1 ? &st->r0 : &st->r0);
break;
1254 case 0x1: sd.
reg = (
size == 1 ? &st->r0 : &st->r1);
break;
1255 case 0x2: sd.
reg = (
size == 1 ? &st->r1 : &st->r2);
break;
1256 case 0x3: sd.
reg = (
size == 1 ? &st->r1 : &st->r3);
break;
1258 case 0x4: sd.
reg = &st->a0;
break;
1259 case 0x5: sd.
reg = &st->a1;
break;
1261 case 0x6: sd.
addr = st->a0;
break;
1262 case 0x7: sd.
addr = st->a1;
break;
1312 case 0x12: sd.
reg = &st->r0;
break;
1313 case 0x13: sd.
reg = &st->r1;
break;
1314 case 0x10: sd.
reg = ((
size == 1) ? &st->r0 : &st->r2);
break;
1315 case 0x11: sd.
reg = ((
size == 1) ? &st->r1 : &st->r3);
break;
1316 case 0x02: sd.
reg = &st->a0;
break;
1317 case 0x03: sd.
reg = &st->a1;
break;
1319 case 0x00: sd.
addr = st->a0;
break;
1320 case 0x01: sd.
addr = st->a1;
break;
1371 state->
fb = state->
sp;
1518 struct gdbarch *arch = prologue->
arch;
1537 if (size == saved_size)
1561 CORE_ADDR after_last_frame_related_insn;
1583 memset (prologue, 0,
sizeof (*prologue));
1591 st.
scan_pc = after_last_frame_related_insn = start;
1595 pv_t pre_insn_fb = st.
fb;
1596 pv_t pre_insn_sp = st.
sp;
1619 if (mach == bfd_mach_m16c)
1622 if (st.
insn[0] == 0x7c && st.
insn[1] == 0xf2)
1629 else if (st.
insn[0] == 0xec)
1631 int src = st.
insn[1];
1637 after_last_frame_related_insn = st.
next_addr;
1641 else if ((st.
insn[0] & 0xfe) == 0x72)
1643 int size = (st.
insn[0] & 0x01) ? 2 : 1;
1656 after_last_frame_related_insn = st.
next_addr;
1658 after_last_frame_related_insn = st.
next_addr;
1665 else if (st.
insn[0] == 0xeb
1666 && st.
insn[1] == 0x50)
1682 int src_indirect = 0;
1683 int dest_indirect = 0;
1689 if (st.
insn[0] == 0x41)
1694 else if (st.
insn[0] == 0x09)
1699 else if (st.
insn[0] == 0x49)
1701 src_indirect = dest_indirect = 1;
1706 if (st.
insn[i] == 0xec)
1714 else if (st.
insn[i] == 0x8f)
1716 int src = st.
insn[i + 1];
1722 after_last_frame_related_insn = st.
next_addr;
1726 else if ((st.
insn[i] & 0x80) == 0x80
1727 && (st.
insn[i + 1] & 0x0f) == 0x0b
1734 int bw = st.
insn[i] & 0x01;
1735 int size = bw ? 2 : 1;
1740 size, src_indirect);
1743 size, dest_indirect);
1747 after_last_frame_related_insn = st.
next_addr;
1753 else if (st.
insn[i] == 0xd5
1754 && st.
insn[i + 1] == 0x29)
1785 after_last_frame_related_insn = st.
next_addr;
1794 && ((pre_insn_sp.
k - st.
sp.
k) < (st.
sp.
k - pre_insn_sp.
k)))
1795 after_last_frame_related_insn = st.
next_addr;
1830 prologue->
prologue_end = after_last_frame_related_insn;
1852 if (sal_end != 0 && sal_end != ip && sal_end < p.
prologue_end)
1864 void **this_prologue_cache)
1866 if (! *this_prologue_cache)
1874 stop_addr = func_start;
1878 func_start, stop_addr, *this_prologue_cache);
1881 return *this_prologue_cache;
1887 void **this_prologue_cache)
1926 void **this_prologue_cache,
1937 static struct value *
1939 void **this_prologue_cache,
int regnum)
1947 if (regnum == tdep->
sp->
num)
2050 int num_prototyped_args = 0;
2082 for (i = nargs - 1; i >= 0; i--)
2084 struct value *arg = args[i];
2092 && i < num_prototyped_args
2101 struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->
r1 : tdep->
r0;
2106 else if (mach == bfd_mach_m16c
2109 && i < num_prototyped_args
2119 if (mach == bfd_mach_m32c)
2211 struct value *
function,
2212 struct type *valtype,
2252 error (
_(
"The return value is stored in memory at 'mem0', "
2253 "but GDB cannot find\n"
2284 error (
_(
"The return value is stored in memory at 'mem0', "
2285 "but GDB cannot find\n"
2363 if (strcmp (name,
"m32c_jsri16") == 0
2364 && stop_pc == start)
2456 const char *func_name;
2465 error (
_(
"Cannot convert code address %s to function pointer:\n"
2466 "couldn't find a symbol at that address, to find trampoline."),
2470 tramp_name =
xmalloc (strlen (func_name) + 5);
2471 strcpy (tramp_name, func_name);
2472 strcat (tramp_name,
".plt");
2497 ptrval = addr & 0xffff;
2499 warning (
_(
"Cannot convert code address %s to function pointer:\n"
2500 "couldn't find trampoline named '%s.plt'.\n"
2501 "Returning pointer value %s instead; this may produce\n"
2502 "a useful result if converted back into an address by GDB,\n"
2503 "but will most likely not be useful otherwise.\n"),
2504 paddress (gdbarch, addr), func_name,
2545 int len = strlen (ptr_msym_name);
2548 && strcmp (ptr_msym_name + len - 4,
".plt") == 0)
2557 char *func_name =
xmalloc (len - 4 + 1);
2558 memcpy (func_name, ptr_msym_name, len - 4);
2559 func_name[len - 4] =
'\0';
2573 for (aspace = 1; aspace <= 15; aspace++)
2578 ptr |= aspace << 16;
2600 _(
"No virtual frame pointer available"));
2621 _(
"No virtual frame pointer available"));
2627 static struct gdbarch *
2630 struct gdbarch *arch;
2641 tdep =
xcalloc (1,
sizeof (*tdep));
2648 if (mach == bfd_mach_m16c)
2674 dwarf2_append_sniffers (arch);
void reggroup_add(struct gdbarch *gdbarch, struct reggroup *group)
static int m32c_pv_enter(struct m32c_pv_state *state, int size)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
#define M32C_MAX_NUM_REGS
static void m32c_m16c_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
static int m32c_get_src23(unsigned char *i)
ssize_t read(int fd, void *buf, size_t count)
enum register_status() m32c_move_reg_t(struct m32c_reg *reg, struct regcache *cache, void *buf)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
#define CCAT(high, low, type)
static m32c_move_reg_t m32c_cat_read
static m32c_move_reg_t m32c_r3r2r1r0_write
static CORE_ADDR m32c_unwind_sp(struct gdbarch *arch, struct frame_info *next_frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
static CORE_ADDR m32c_frame_base(struct frame_info *this_frame, void **this_prologue_cache)
CORE_ADDR get_frame_pc(struct frame_info *frame)
#define MSYMBOL_LINKAGE_NAME(symbol)
struct frame_info * get_current_frame(void)
static CORE_ADDR m32c_skip_trampoline_code(struct frame_info *frame, CORE_ADDR stop_pc)
static m32c_move_reg_t m32c_sb_write
struct reggroup * reggroup_new(const char *name, enum reggroup_type type)
static m32c_move_reg_t m32c_part_write
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
static void m32c_virtual_frame_pointer(struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
static int m32c_reg_arg_type(struct type *type)
struct type * data_addr_reg_type
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
void warning(const char *fmt,...)
static struct reggroup * m32c_dma_reggroup
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
static m32c_move_reg_t m32c_banked_read
struct cleanup * make_cleanup_free_pv_area(struct pv_area *area)
static int m32c_srcdest_store(struct m32c_pv_state *state, struct srcdest loc, pv_t value, int size)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
static struct m32c_reg * mark_general(struct m32c_reg *reg)
LONGEST reg_offset[M32C_MAX_NUM_REGS]
CORE_ADDR get_frame_sp(struct frame_info *this_frame)
int pv_is_register(pv_t a, int r)
void internal_error(const char *file, int line, const char *fmt,...)
static m32c_move_reg_t m32c_r3r2r1r0_read
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
int pv_area_find_reg(struct pv_area *area, struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p)
enum prologue_value_kind kind
void regcache_cooked_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
static m32c_move_reg_t m32c_banked_write
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
struct gdbarch_list * next
struct reggroup *const restore_reggroup
static void m32c_pseudo_register_write(struct gdbarch *arch, struct regcache *cache, int cookednum, const gdb_byte *buf)
int gdbarch_num_regs(struct gdbarch *gdbarch)
static void check_for_saved(void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value)
static m32c_move_reg_t m32c_raw_read
struct reggroup *const all_reggroup
const struct bfd_arch_info * bfd_arch_info
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
struct m32c_reg * dwarf_regs[M32C_MAX_DWARF_REGNUM+1]
static int m32c_sdisp16(struct m32c_pv_state *st)
static int m32c_read_flg(struct regcache *cache)
#define bits(obj, st, fn)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
#define TYPE_PROTOTYPED(t)
static int m32c_register_sim_regno(struct gdbarch *gdbarch, int reg_nr)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
pv_t pv_constant(CORE_ADDR k)
static m32c_move_reg_t m32c_cat_write
struct regcache * get_current_regcache(void)
static int m32c_is_arg_spill(struct m32c_pv_state *st, struct srcdest loc, pv_t value)
#define FRAME_OBSTACK_ZALLOC(TYPE)
static int m32c_is_arg_reg(struct m32c_pv_state *state, pv_t value)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
int pv_is_identical(pv_t a, pv_t b)
static void m32c_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
static m32c_move_reg_t m32c_sb_read
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
struct m32c_reg * r3r2r1r0
static void make_types(struct gdbarch *arch)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
static void set_dwarf_regnum(struct m32c_reg *reg, int num)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
const gdb_byte * value_contents(struct value *value)
struct reggroup *const general_reggroup
static struct m32c_reg * add_reg(struct gdbarch *arch, const char *name, struct type *type, int sim_num, m32c_move_reg_t *read, m32c_move_reg_t *write, struct m32c_reg *rx, struct m32c_reg *ry, int n)
static void make_regs(struct gdbarch *arch)
#define M32C_MAX_INSN_LEN
static struct srcdest m32c_decode_srcdest4(struct m32c_pv_state *st, int code, int size)
void initialize_file_ftype(void)
static int m32c_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
struct reggroup *const system_reggroup
pv_t pv_area_fetch(struct pv_area *area, pv_t addr, CORE_ADDR size)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
static int m32c_debug_info_reg_to_regnum(struct gdbarch *gdbarch, int reg_nr)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
static CORE_ADDR m32c_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
void set_gdbarch_address_to_pointer(struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype address_to_pointer)
static int m32c_get_dest23(unsigned char *i)
#define gdb_assert_not_reached(message)
static int m32c_udisp8(struct m32c_pv_state *st)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
int pv_is_register_k(pv_t a, int r, CORE_ADDR k)
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype register_sim_regno)
static m32c_move_reg_t m32c_part_read
static struct srcdest m32c_decode_sd23(struct m32c_pv_state *st, int code, int size, int ind)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
static const unsigned char * m32c_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
struct m32c_reg * r3r1r2r0
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
static pv_t m32c_srcdest_fetch(struct m32c_pv_state *state, struct srcdest loc, int size)
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
void pv_area_store(struct pv_area *area, pv_t addr, CORE_ADDR size, pv_t value)
static const char * m32c_register_name(struct gdbarch *gdbarch, int num)
int pv_area_store_would_trash(struct pv_area *area, pv_t addr)
static int m32c_pv_push(struct m32c_pv_state *state, pv_t value, int size)
static CORE_ADDR m32c_unwind_pc(struct gdbarch *arch, struct frame_info *next_frame)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
static int m32c_sdisp8(struct m32c_pv_state *st)
static struct frame_id m32c_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype pointer_to_address)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
static int m32c_pv_pushm_one(struct m32c_pv_state *state, pv_t reg, int bit, int src, int size)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
void pv_area_scan(struct pv_area *area, void(*func)(void *closure, pv_t addr, CORE_ADDR size, pv_t value), void *closure)
struct insn_sequence * prologue
static struct type * m32c_register_type(struct gdbarch *arch, int reg_nr)
initialize_file_ftype _initialize_m32c_tdep
#define M32C_MAX_DWARF_REGNUM
struct pv_area * make_pv_area(int base_reg, int addr_bit)
static struct m32c_reg * mark_system(struct m32c_reg *reg)
static enum register_status m32c_pseudo_register_read(struct gdbarch *arch, struct regcache *cache, int cookednum, gdb_byte *buf)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
static enum return_value_convention m32c_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
static CORE_ADDR m32c_m16c_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
#define TYPE_TARGET_TYPE(thistype)
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
static struct m32c_reg * mark_save_restore(struct m32c_reg *reg)
static struct m32c_reg * mark_dma(struct m32c_reg *reg)
int xsnprintf(char *str, size_t size, const char *format,...)
#define TYPE_CODE(thistype)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static struct gdbarch * m32c_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static int m32c_return_by_passed_buf(struct type *type)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
struct minimal_symbol * minsym
static struct m32c_reg * m32c_banked_register(struct m32c_reg *reg, struct regcache *cache)
static struct m32c_prologue * m32c_analyze_frame_prologue(struct frame_info *this_frame, void **this_prologue_cache)
static int m32c_sign_ext(int v, int bits)
void set_gdbarch_virtual_frame_pointer(struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
static void m32c_analyze_prologue(struct gdbarch *arch, CORE_ADDR start, CORE_ADDR limit, struct m32c_prologue *prologue)
static int m32c_is_struct_return(struct m32c_pv_state *st, struct srcdest loc, pv_t value)
#define TYPE_NFIELDS(thistype)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
gdb_byte insn[M32C_MAX_INSN_LEN]
struct m32c_reg regs[M32C_MAX_NUM_REGS]
static CORE_ADDR m32c_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
static struct value * m32c_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
static void m32c_find_part(struct m32c_reg *reg, int *offset_p, int *len_p)
static unsigned int m32c_next_byte(struct m32c_pv_state *st)
unsigned long long ULONGEST
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
static m32c_move_reg_t m32c_raw_write
static int m32c_udisp24(struct m32c_pv_state *st)
unsigned int save_restore_p
int register_size(struct gdbarch *gdbarch, int regnum)
struct type * value_type(const struct value *value)
static int m32c_pushm_is_reg_save(struct m32c_pv_state *st, int src)
enum register_status regcache_cooked_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
struct type * code_addr_reg_type
struct reggroup *const save_reggroup
#define TYPE_LENGTH(thistype)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int length, char *name)
static int m32c_udisp16(struct m32c_pv_state *st)
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
#define CB(name, raw_pair)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
PTR xcalloc(size_t number, size_t size)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
int pv_is_constant(pv_t a)
static int m32c_pv_pushm(struct m32c_pv_state *state, int src)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
enum m32c_prologue_kind kind
void error(const char *fmt,...)
pv_t pv_register(int reg, CORE_ADDR k)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
void do_cleanups(struct cleanup *old_chain)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
static int m32c_is_1st_arg_reg(struct m32c_pv_state *state, pv_t value)
struct type * lookup_function_type(struct type *type)
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
const ULONGEST const LONGEST len
void set_gdbarch_vbit_in_delta(struct gdbarch *gdbarch, int vbit_in_delta)