21#include "gdb/sim-m32c.h"
93#define M32C_MAX_NUM_REGS (75)
96#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;
183 gdb_assert_not_reached (
"unexpected mach");
193 xsnprintf (type_name,
sizeof (type_name),
"%s_data_addr_t",
198 xsnprintf (type_name,
sizeof (type_name),
"%s_code_addr_t",
310static enum register_status
318static enum register_status
353static enum register_status
365static enum register_status
378static enum register_status
390static enum register_status
419 int elt_offset = reg->
n * elt_len;
422 if (elt_offset + elt_len > containing_len)
424 elt_len = containing_len - elt_offset;
427 gdb_assert (elt_len > 0);
432 elt_offset = reg->
rx->
type->
length () - elt_offset - elt_len;
434 *offset_p = elt_offset;
443static enum register_status
458static enum register_status
474static enum register_status
479 enum register_status
status;
481 gdb_assert (reg->
type->
length () == high_bytes + low_bytes);
502static enum register_status
509 gdb_assert (reg->
type->
length () == high_bytes + low_bytes);
529static enum register_status
535 enum register_status
status;
565static enum register_status
592static enum register_status
601 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
602 gdb_assert (
arch == cache->
arch ());
604 reg = &tdep->
regs[cookednum];
606 return reg->
read (reg, cache, buf);
619 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
620 gdb_assert (
arch == cache->
arch ());
622 reg = &tdep->
regs[cookednum];
624 reg->
write (reg, cache, buf);
721#define FLAGBIT_B 0x0010
722#define FLAGBIT_U 0x0080
729#define R(name, type, sim_num) \
730 (add_reg (arch, (name), (type), (sim_num), \
731 m32c_raw_read, m32c_raw_write, NULL, NULL, 0))
734#define SIM(name) (m32c_sim_reg_ ## name)
739 (R(#name, tdep->uint16, SIM (name)))
744 (R(#name, tdep->data_addr_reg_type, SIM (name)))
749 (R(#name, tdep->code_addr_reg_type, SIM (name)))
753#define RP(name, type) \
754 (R(#name "0", (type), SIM (name ## 0)), \
755 R(#name "1", (type), SIM (name ## 1)) - 1)
760 (R("", tdep->int16, SIM (name ## _bank0)), \
761 R("", tdep->int16, SIM (name ## _bank1)) - 1)
766 (R("", tdep->data_addr_reg_type, SIM (name ## _bank0)), \
767 R("", tdep->data_addr_reg_type, SIM (name ## _bank1)) - 1)
773#define CB(name, raw_pair) \
774 (add_reg (arch, #name, (raw_pair)->type, 0, \
775 m32c_banked_read, m32c_banked_write, \
776 (raw_pair), (raw_pair + 1), FLAGBIT_B))
781#define CHL(name, type) \
782 (add_reg (arch, #name "h", (type), 0, \
783 m32c_part_read, m32c_part_write, name, NULL, 1), \
784 add_reg (arch, #name "l", (type), 0, \
785 m32c_part_read, m32c_part_write, name, NULL, 0) - 1)
789#define CCAT(high, low, type) \
790 (add_reg (arch, #high #low, (type), 0, \
791 m32c_cat_read, m32c_cat_write, (high), (low), 0))
794#define G(reg) (mark_general (reg))
795#define S(reg) (mark_system (reg))
796#define DMA(reg) (mark_dma (reg))
844 if (mach == bfd_mach_m32c)
860 r0 =
G (
CB (r0, raw_r0_pair));
861 r1 =
G (
CB (r1, raw_r1_pair));
862 r2 =
G (
CB (r2, raw_r2_pair));
863 r3 =
G (
CB (r3, raw_r3_pair));
864 a0 =
G (
CB (a0, raw_a0_pair));
865 a1 =
G (
CB (a1, raw_a1_pair));
866 fb =
G (
CB (fb, raw_fb_pair));
872 raw_sb_pair, raw_sb_pair + 1, 0));
888 r3r1r2r0 =
CCAT (r3r1, r2r0, tdep->
int64);
894 if (mach == bfd_mach_m16c)
899 num_cooked_regs = tdep->
num_regs - num_raw_regs;
997enum m32c_prologue_kind
1000 prologue_with_frame_ptr,
1003 prologue_sans_frame_ptr,
1007 prologue_first_frame
1054#define M32C_MAX_INSN_LEN (9)
1147 int mask = 1 << (
bits - 1);
1148 return (v ^ mask) - mask;
1178 return low + (high << 8);
1199 return low + (mid << 8) + (high << 16);
1207 return (((i[0] & 0x70) >> 2)
1208 | ((i[1] & 0x30) >> 4));
1216 return (((i[0] & 0x0e) << 1)
1217 | ((i[1] & 0xc0) >> 6));
1237 case 0x0: sd.
reg = &st->r0;
break;
1238 case 0x1: sd.
reg = (
size == 1 ? &st->r0 : &st->r1);
break;
1239 case 0x2: sd.
reg = (
size == 1 ? &st->r1 : &st->r2);
break;
1240 case 0x3: sd.
reg = (
size == 1 ? &st->r1 : &st->r3);
break;
1242 case 0x4: sd.
reg = &st->a0;
break;
1243 case 0x5: sd.
reg = &st->a1;
break;
1245 case 0x6: sd.
addr = st->a0;
break;
1246 case 0x7: sd.
addr = st->a1;
break;
1259 gdb_assert_not_reached (
"unexpected srcdest4");
1296 case 0x12: sd.
reg = &st->r0;
break;
1297 case 0x13: sd.
reg = &st->r1;
break;
1298 case 0x10: sd.
reg = ((
size == 1) ? &st->r0 : &st->r2);
break;
1299 case 0x11: sd.
reg = ((
size == 1) ? &st->r1 : &st->r3);
break;
1300 case 0x02: sd.
reg = &st->a0;
break;
1301 case 0x03: sd.
reg = &st->a1;
break;
1303 case 0x00: sd.
addr = st->a0;
break;
1304 case 0x01: sd.
addr = st->a1;
break;
1318 gdb_assert_not_reached (
"unexpected sd23");
1356 state->
fb = state->
sp;
1531 if (
size == saved_size)
1550 CORE_ADDR start, CORE_ADDR limit,
1555 CORE_ADDR after_last_frame_related_insn;
1576 memset (prologue, 0,
sizeof (*prologue));
1584 st.
scan_pc = after_last_frame_related_insn = start;
1588 pv_t pre_insn_fb = st.
fb;
1589 pv_t pre_insn_sp = st.
sp;
1612 if (mach == bfd_mach_m16c)
1615 if (st.
insn[0] == 0x7c && st.
insn[1] == 0xf2)
1622 else if (st.
insn[0] == 0xec)
1624 int src = st.
insn[1];
1630 after_last_frame_related_insn = st.
next_addr;
1634 else if ((st.
insn[0] & 0xfe) == 0x72)
1636 int size = (st.
insn[0] & 0x01) ? 2 : 1;
1649 after_last_frame_related_insn = st.
next_addr;
1651 after_last_frame_related_insn = st.
next_addr;
1658 else if (st.
insn[0] == 0xeb
1659 && st.
insn[1] == 0x50)
1675 int src_indirect = 0;
1676 int dest_indirect = 0;
1679 gdb_assert (mach == bfd_mach_m32c);
1682 if (st.
insn[0] == 0x41)
1687 else if (st.
insn[0] == 0x09)
1692 else if (st.
insn[0] == 0x49)
1694 src_indirect = dest_indirect = 1;
1699 if (st.
insn[i] == 0xec)
1707 else if (st.
insn[i] == 0x8f)
1709 int src = st.
insn[i + 1];
1715 after_last_frame_related_insn = st.
next_addr;
1719 else if ((st.
insn[i] & 0x80) == 0x80
1720 && (st.
insn[i + 1] & 0x0f) == 0x0b
1727 int bw = st.
insn[i] & 0x01;
1728 int size = bw ? 2 : 1;
1733 size, src_indirect);
1736 size, dest_indirect);
1740 after_last_frame_related_insn = st.
next_addr;
1746 else if (st.
insn[i] == 0xd5
1747 && st.
insn[i + 1] == 0x29)
1778 after_last_frame_related_insn = st.
next_addr;
1787 && ((pre_insn_sp.
k - st.
sp.
k) < (st.
sp.
k - pre_insn_sp.
k)))
1788 after_last_frame_related_insn = st.
next_addr;
1796 prologue->
kind = prologue_first_frame;
1802 prologue->
kind = prologue_with_frame_ptr;
1811 prologue->
kind = prologue_sans_frame_ptr;
1818 prologue->
kind = prologue_first_frame;
1823 prologue->
prologue_end = after_last_frame_related_insn;
1831 CORE_ADDR func_addr, func_end, sal_end;
1843 if (sal_end != 0 && sal_end != ip && sal_end < p.
prologue_end)
1855 void **this_prologue_cache)
1857 if (! *this_prologue_cache)
1865 stop_addr = func_start;
1869 func_start, stop_addr,
1879 void **this_prologue_cache)
1894 case prologue_with_frame_ptr:
1901 case prologue_sans_frame_ptr:
1908 case prologue_first_frame:
1912 gdb_assert_not_reached (
"unexpected prologue kind");
1919 void **this_prologue_cache,
1930static struct value *
1932 void **this_prologue_cache,
int regnum)
2002 return (
code == TYPE_CODE_INT
2003 ||
code == TYPE_CODE_ENUM
2004 ||
code == TYPE_CODE_PTR
2006 ||
code == TYPE_CODE_BOOL
2007 ||
code == TYPE_CODE_CHAR);
2014 struct value **args, CORE_ADDR sp,
2016 CORE_ADDR struct_addr)
2029 int num_prototyped_args = 0;
2035 if (
func_type->code () == TYPE_CODE_PTR)
2038 gdb_assert (
func_type->code () == TYPE_CODE_FUNC ||
2039 func_type->code () == TYPE_CODE_METHOD);
2047 num_prototyped_args =
func_type->num_fields ();
2061 for (i = nargs - 1; i >= 0; i--)
2063 struct value *arg = args[i];
2066 ULONGEST arg_size = arg_type->
length ();
2071 && i < num_prototyped_args
2080 struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->
r1 : tdep->
r0;
2085 else if (mach == bfd_mach_m16c
2088 && i < num_prototyped_args
2098 if (mach == bfd_mach_m32c)
2169 return (
code == TYPE_CODE_STRUCT
2170 ||
code == TYPE_CODE_UNION);
2175 struct value *function,
2176 struct type *valtype,
2179 const gdb_byte *writebuf)
2184 ULONGEST valtype_len = valtype->
length ();
2198 gdb_assert (valtype_len <= 8);
2201 if (valtype_len <= tdep->r0->type->length ())
2216 error (_(
"The return value is stored in memory at 'mem0', "
2217 "but GDB cannot find\n"
2230 gdb_assert (valtype_len <= 8);
2233 if (valtype_len <= tdep->r0->type->length ())
2248 error (_(
"The return value is stored in memory at 'mem0', "
2249 "but GDB cannot find\n"
2322 CORE_ADDR start, end;
2327 if (strcmp (
name,
"m32c_jsri16") == 0
2328 && stop_pc == start)
2409 struct type *
type, gdb_byte *buf, CORE_ADDR addr)
2417 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2419 const char *func_name;
2428 error (_(
"Cannot convert code address %s to function pointer:\n"
2429 "couldn't find a symbol at that address, to find trampoline."),
2433 tramp_name = (
char *)
xmalloc (strlen (func_name) + 5);
2434 strcpy (tramp_name, func_name);
2435 strcat (tramp_name,
".plt");
2460 ptrval = addr & 0xffff;
2462 warning (_(
"Cannot convert code address %s to function pointer:\n"
2463 "couldn't find trampoline named '%s.plt'.\n"
2464 "Returning pointer value %s instead; this may produce\n"
2465 "a useful result if converted back into an address by GDB,\n"
2466 "but will most likely not be useful otherwise."),
2486 struct type *
type,
const gdb_byte *buf)
2498 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2507 int len = strlen (ptr_msym_name);
2510 && strcmp (ptr_msym_name + len - 4,
".plt") == 0)
2519 char *func_name = (
char *)
xmalloc (len - 4 + 1);
2520 memcpy (func_name, ptr_msym_name, len - 4);
2521 func_name[len - 4] =
'\0';
2535 for (aspace = 1; aspace <= 15; aspace++)
2540 ptr |= aspace << 16;
2551 LONGEST *frame_offset)
2554 CORE_ADDR func_addr, func_end;
2561 internal_error (_(
"No virtual frame pointer available"));
2566 case prologue_with_frame_ptr:
2570 case prologue_sans_frame_ptr:
2581 internal_error (_(
"No virtual frame pointer available"));
2591 unsigned long mach =
info.bfd_arch_info->mach;
2607 if (mach == bfd_mach_m16c)
2629 dwarf2_append_sniffers (
gdbarch);
#define bits(obj, st, fn)
static std::vector< const char * > arches
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
void scan(void(*func)(void *closure, pv_t addr, CORE_ADDR size, pv_t value), void *closure)
pv_t fetch(pv_t addr, CORE_ADDR size)
bool find_reg(struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p)
bool store_would_trash(pv_t addr)
void store(pv_t addr, CORE_ADDR size, pv_t value)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void cooked_write(int regnum, const gdb_byte *buf)
void cooked_write_part(int regnum, int offset, int len, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
ssize_t read(int fd, void *buf, size_t count)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
CORE_ADDR get_frame_sp(frame_info_ptr this_frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
frame_info_ptr get_current_frame(void)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum)
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
void set_gdbarch_address_to_pointer(struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_virtual_frame_pointer(struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_vbit_in_delta(struct gdbarch *gdbarch, int vbit_in_delta)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep)
function_call_return_method
struct type * arch_pointer_type(struct gdbarch *gdbarch, int bit, const char *name, struct type *target_type)
struct type * lookup_function_type(struct type *type)
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
#define TYPE_IS_REFERENCE(t)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static int m32c_srcdest_store(struct m32c_pv_state *state, struct srcdest loc, pv_t value, int size)
static int m32c_get_src23(unsigned char *i)
static int m32c_pv_pushm(struct m32c_pv_state *state, int src)
static m32c_write_reg_t m32c_sb_write
static m32c_write_reg_t m32c_r3r2r1r0_write
static void make_regs(struct gdbarch *arch)
static void m32c_analyze_prologue(struct gdbarch *arch, CORE_ADDR start, CORE_ADDR limit, struct m32c_prologue *prologue)
static void set_dwarf_regnum(struct m32c_reg *reg, int num)
static void m32c_pseudo_register_write(struct gdbarch *arch, struct regcache *cache, int cookednum, const gdb_byte *buf)
enum register_status() m32c_read_reg_t(struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
static struct m32c_reg * add_reg(struct gdbarch *arch, const char *name, struct type *type, int sim_num, m32c_read_reg_t *read, m32c_write_reg_t *write, struct m32c_reg *rx, struct m32c_reg *ry, int n)
static int m32c_is_struct_return(struct m32c_pv_state *st, struct srcdest loc, pv_t value)
static struct m32c_prologue * m32c_analyze_frame_prologue(frame_info_ptr this_frame, void **this_prologue_cache)
static struct m32c_reg * mark_system(struct m32c_reg *reg)
static void mark_dma(struct m32c_reg *reg)
static int m32c_pv_pushm_one(struct m32c_pv_state *state, pv_t reg, int bit, int src, int size)
static struct m32c_reg * m32c_banked_register(struct m32c_reg *reg, readable_regcache *cache)
static unsigned int m32c_next_byte(struct m32c_pv_state *st)
constexpr gdb_byte m32c_break_insn[]
static int m32c_reg_arg_type(struct type *type)
enum register_status() m32c_write_reg_t(struct m32c_reg *reg, struct regcache *cache, const gdb_byte *buf)
static m32c_write_reg_t m32c_banked_write
#define CB(name, raw_pair)
void _initialize_m32c_tdep()
static m32c_read_reg_t m32c_raw_read
static int m32c_pushm_is_reg_save(struct m32c_pv_state *st, int src)
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, function_call_return_method return_method, CORE_ADDR struct_addr)
#define M32C_MAX_NUM_REGS
static struct m32c_reg * mark_general(struct m32c_reg *reg)
static CORE_ADDR m32c_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR stop_pc)
static int m32c_sdisp16(struct m32c_pv_state *st)
static int m32c_sign_ext(int v, int bits)
static m32c_read_reg_t m32c_cat_read
static m32c_write_reg_t m32c_cat_write
static m32c_write_reg_t m32c_raw_write
static void m32c_m16c_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
static int m32c_pv_push(struct m32c_pv_state *state, pv_t value, int size)
static m32c_read_reg_t m32c_part_read
static int m32c_is_arg_spill(struct m32c_pv_state *st, struct srcdest loc, pv_t value)
static const reggroup * m32c_dma_reggroup
static void m32c_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
#define M32C_MAX_INSN_LEN
static CORE_ADDR m32c_m16c_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
static m32c_write_reg_t m32c_part_write
static void m32c_virtual_frame_pointer(struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
static int m32c_is_arg_reg(struct m32c_pv_state *state, pv_t value)
static int m32c_pv_enter(struct m32c_pv_state *state, int size)
static void m32c_find_part(struct m32c_reg *reg, int *offset_p, int *len_p)
#define M32C_MAX_DWARF_REGNUM
static struct m32c_reg * mark_save_restore(struct m32c_reg *reg)
static struct gdbarch * m32c_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static CORE_ADDR m32c_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
static const char * m32c_register_name(struct gdbarch *gdbarch, int num)
static CORE_ADDR m32c_frame_base(frame_info_ptr this_frame, void **this_prologue_cache)
static int m32c_register_sim_regno(struct gdbarch *gdbarch, int reg_nr)
static void make_types(struct gdbarch *arch)
static int m32c_udisp16(struct m32c_pv_state *st)
static void check_for_saved(void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value)
static int m32c_get_dest23(unsigned char *i)
static enum register_status m32c_pseudo_register_read(struct gdbarch *arch, readable_regcache *cache, int cookednum, gdb_byte *buf)
static int m32c_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
static int m32c_sdisp8(struct m32c_pv_state *st)
static int m32c_return_by_passed_buf(struct type *type)
static m32c_read_reg_t m32c_banked_read
static int m32c_read_flg(readable_regcache *cache)
#define CCAT(high, low, type)
static int m32c_is_1st_arg_reg(struct m32c_pv_state *state, pv_t value)
static struct srcdest m32c_decode_srcdest4(struct m32c_pv_state *st, int code, int size)
static const struct frame_unwind m32c_unwind
static int m32c_debug_info_reg_to_regnum(struct gdbarch *gdbarch, int reg_nr)
static struct type * m32c_register_type(struct gdbarch *arch, int reg_nr)
static pv_t m32c_srcdest_fetch(struct m32c_pv_state *state, struct srcdest loc, int size)
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)
static struct value * m32c_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static int m32c_udisp8(struct m32c_pv_state *st)
static struct srcdest m32c_decode_sd23(struct m32c_pv_state *st, int code, int size, int ind)
static m32c_read_reg_t m32c_sb_read
static m32c_read_reg_t m32c_r3r2r1r0_read
static int m32c_udisp24(struct m32c_pv_state *st)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
pv_t pv_constant(CORE_ADDR k)
int pv_is_register_k(pv_t a, int r, CORE_ADDR k)
pv_t pv_register(int reg, CORE_ADDR k)
int pv_is_identical(pv_t a, pv_t b)
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
int pv_is_register(pv_t a, int r)
int pv_is_constant(pv_t a)
int register_size(struct gdbarch *gdbarch, int regnum)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
struct regcache * get_current_regcache(void)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const reggroup *const general_reggroup
const reggroup * reggroup_new(const char *name, enum reggroup_type type)
const reggroup *const system_reggroup
const reggroup *const save_reggroup
const reggroup *const all_reggroup
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
const reggroup *const restore_reggroup
CORE_ADDR value_address() const
struct minimal_symbol * minsym
const char * linkage_name() const
struct m32c_reg regs[M32C_MAX_NUM_REGS]
struct m32c_reg * r3r2r1r0
struct m32c_reg * r3r1r2r0
struct type * code_addr_reg_type
struct m32c_reg * dwarf_regs[M32C_MAX_DWARF_REGNUM+1]
struct type * data_addr_reg_type
LONGEST reg_offset[M32C_MAX_NUM_REGS]
enum m32c_prologue_kind kind
gdb_byte insn[M32C_MAX_INSN_LEN]
unsigned int save_restore_p
struct type * target_type() const
struct value::@195::@196 reg
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct type * value_type(const struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)