21#include "sim/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");
189 tdep->
voyd = alloc.
new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT,
"void");
194 xsnprintf (type_name,
sizeof (type_name),
"%s_data_addr_t",
199 xsnprintf (type_name,
sizeof (type_name),
"%s_code_addr_t",
312static enum register_status
320static enum register_status
355static enum register_status
367static enum register_status
380static enum register_status
392static enum register_status
421 int elt_offset = reg->
n * elt_len;
424 if (elt_offset + elt_len > containing_len)
426 elt_len = containing_len - elt_offset;
429 gdb_assert (elt_len > 0);
434 elt_offset = reg->
rx->
type->
length () - elt_offset - elt_len;
436 *offset_p = elt_offset;
445static enum register_status
460static enum register_status
476static enum register_status
481 enum register_status
status;
483 gdb_assert (reg->
type->
length () == high_bytes + low_bytes);
504static enum register_status
511 gdb_assert (reg->
type->
length () == high_bytes + low_bytes);
531static enum register_status
537 enum register_status
status;
567static enum register_status
594static enum register_status
603 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
604 gdb_assert (
arch == cache->
arch ());
606 reg = &tdep->
regs[cookednum];
608 return reg->
read (reg, cache, buf);
621 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
622 gdb_assert (
arch == cache->
arch ());
624 reg = &tdep->
regs[cookednum];
626 reg->
write (reg, cache, buf);
723#define FLAGBIT_B 0x0010
724#define FLAGBIT_U 0x0080
731#define R(name, type, sim_num) \
732 (add_reg (arch, (name), (type), (sim_num), \
733 m32c_raw_read, m32c_raw_write, NULL, NULL, 0))
736#define SIM(name) (m32c_sim_reg_ ## name)
741 (R(#name, tdep->uint16, SIM (name)))
746 (R(#name, tdep->data_addr_reg_type, SIM (name)))
751 (R(#name, tdep->code_addr_reg_type, SIM (name)))
755#define RP(name, type) \
756 (R(#name "0", (type), SIM (name ## 0)), \
757 R(#name "1", (type), SIM (name ## 1)) - 1)
762 (R("", tdep->int16, SIM (name ## _bank0)), \
763 R("", tdep->int16, SIM (name ## _bank1)) - 1)
768 (R("", tdep->data_addr_reg_type, SIM (name ## _bank0)), \
769 R("", tdep->data_addr_reg_type, SIM (name ## _bank1)) - 1)
775#define CB(name, raw_pair) \
776 (add_reg (arch, #name, (raw_pair)->type, 0, \
777 m32c_banked_read, m32c_banked_write, \
778 (raw_pair), (raw_pair + 1), FLAGBIT_B))
783#define CHL(name, type) \
784 (add_reg (arch, #name "h", (type), 0, \
785 m32c_part_read, m32c_part_write, name, NULL, 1), \
786 add_reg (arch, #name "l", (type), 0, \
787 m32c_part_read, m32c_part_write, name, NULL, 0) - 1)
791#define CCAT(high, low, type) \
792 (add_reg (arch, #high #low, (type), 0, \
793 m32c_cat_read, m32c_cat_write, (high), (low), 0))
796#define G(reg) (mark_general (reg))
797#define S(reg) (mark_system (reg))
798#define DMA(reg) (mark_dma (reg))
846 if (mach == bfd_mach_m32c)
862 r0 =
G (
CB (r0, raw_r0_pair));
863 r1 =
G (
CB (r1, raw_r1_pair));
864 r2 =
G (
CB (r2, raw_r2_pair));
865 r3 =
G (
CB (r3, raw_r3_pair));
866 a0 =
G (
CB (a0, raw_a0_pair));
867 a1 =
G (
CB (a1, raw_a1_pair));
868 fb =
G (
CB (fb, raw_fb_pair));
874 raw_sb_pair, raw_sb_pair + 1, 0));
890 r3r1r2r0 =
CCAT (r3r1, r2r0, tdep->
int64);
896 if (mach == bfd_mach_m16c)
901 num_cooked_regs = tdep->
num_regs - num_raw_regs;
999enum m32c_prologue_kind
1002 prologue_with_frame_ptr,
1005 prologue_sans_frame_ptr,
1009 prologue_first_frame
1056#define M32C_MAX_INSN_LEN (9)
1149 int mask = 1 << (
bits - 1);
1150 return (v ^ mask) - mask;
1180 return low + (high << 8);
1201 return low + (mid << 8) + (high << 16);
1209 return (((i[0] & 0x70) >> 2)
1210 | ((i[1] & 0x30) >> 4));
1218 return (((i[0] & 0x0e) << 1)
1219 | ((i[1] & 0xc0) >> 6));
1239 case 0x0: sd.
reg = &st->r0;
break;
1240 case 0x1: sd.
reg = (
size == 1 ? &st->r0 : &st->r1);
break;
1241 case 0x2: sd.
reg = (
size == 1 ? &st->r1 : &st->r2);
break;
1242 case 0x3: sd.
reg = (
size == 1 ? &st->r1 : &st->r3);
break;
1244 case 0x4: sd.
reg = &st->a0;
break;
1245 case 0x5: sd.
reg = &st->a1;
break;
1247 case 0x6: sd.
addr = st->a0;
break;
1248 case 0x7: sd.
addr = st->a1;
break;
1261 gdb_assert_not_reached (
"unexpected srcdest4");
1298 case 0x12: sd.
reg = &st->r0;
break;
1299 case 0x13: sd.
reg = &st->r1;
break;
1300 case 0x10: sd.
reg = ((
size == 1) ? &st->r0 : &st->r2);
break;
1301 case 0x11: sd.
reg = ((
size == 1) ? &st->r1 : &st->r3);
break;
1302 case 0x02: sd.
reg = &st->a0;
break;
1303 case 0x03: sd.
reg = &st->a1;
break;
1305 case 0x00: sd.
addr = st->a0;
break;
1306 case 0x01: sd.
addr = st->a1;
break;
1320 gdb_assert_not_reached (
"unexpected sd23");
1358 state->
fb = state->
sp;
1533 if (
size == saved_size)
1552 CORE_ADDR start, CORE_ADDR limit,
1557 CORE_ADDR after_last_frame_related_insn;
1578 memset (prologue, 0,
sizeof (*prologue));
1586 st.
scan_pc = after_last_frame_related_insn = start;
1590 pv_t pre_insn_fb = st.
fb;
1591 pv_t pre_insn_sp = st.
sp;
1614 if (mach == bfd_mach_m16c)
1617 if (st.
insn[0] == 0x7c && st.
insn[1] == 0xf2)
1624 else if (st.
insn[0] == 0xec)
1626 int src = st.
insn[1];
1632 after_last_frame_related_insn = st.
next_addr;
1636 else if ((st.
insn[0] & 0xfe) == 0x72)
1638 int size = (st.
insn[0] & 0x01) ? 2 : 1;
1651 after_last_frame_related_insn = st.
next_addr;
1653 after_last_frame_related_insn = st.
next_addr;
1660 else if (st.
insn[0] == 0xeb
1661 && st.
insn[1] == 0x50)
1677 int src_indirect = 0;
1678 int dest_indirect = 0;
1681 gdb_assert (mach == bfd_mach_m32c);
1684 if (st.
insn[0] == 0x41)
1689 else if (st.
insn[0] == 0x09)
1694 else if (st.
insn[0] == 0x49)
1696 src_indirect = dest_indirect = 1;
1701 if (st.
insn[i] == 0xec)
1709 else if (st.
insn[i] == 0x8f)
1711 int src = st.
insn[i + 1];
1717 after_last_frame_related_insn = st.
next_addr;
1721 else if ((st.
insn[i] & 0x80) == 0x80
1722 && (st.
insn[i + 1] & 0x0f) == 0x0b
1729 int bw = st.
insn[i] & 0x01;
1730 int size = bw ? 2 : 1;
1735 size, src_indirect);
1738 size, dest_indirect);
1742 after_last_frame_related_insn = st.
next_addr;
1748 else if (st.
insn[i] == 0xd5
1749 && st.
insn[i + 1] == 0x29)
1780 after_last_frame_related_insn = st.
next_addr;
1789 && ((pre_insn_sp.
k - st.
sp.
k) < (st.
sp.
k - pre_insn_sp.
k)))
1790 after_last_frame_related_insn = st.
next_addr;
1798 prologue->
kind = prologue_first_frame;
1804 prologue->
kind = prologue_with_frame_ptr;
1813 prologue->
kind = prologue_sans_frame_ptr;
1820 prologue->
kind = prologue_first_frame;
1825 prologue->
prologue_end = after_last_frame_related_insn;
1833 CORE_ADDR func_addr, func_end, sal_end;
1845 if (sal_end != 0 && sal_end != ip && sal_end < p.
prologue_end)
1857 void **this_prologue_cache)
1859 if (! *this_prologue_cache)
1867 stop_addr = func_start;
1871 func_start, stop_addr,
1881 void **this_prologue_cache)
1896 case prologue_with_frame_ptr:
1903 case prologue_sans_frame_ptr:
1910 case prologue_first_frame:
1914 gdb_assert_not_reached (
"unexpected prologue kind");
1921 void **this_prologue_cache,
1932static struct value *
1934 void **this_prologue_cache,
int regnum)
2004 return (
code == TYPE_CODE_INT
2005 ||
code == TYPE_CODE_ENUM
2006 ||
code == TYPE_CODE_PTR
2008 ||
code == TYPE_CODE_BOOL
2009 ||
code == TYPE_CODE_CHAR);
2016 struct value **args, CORE_ADDR sp,
2018 CORE_ADDR struct_addr)
2031 int num_prototyped_args = 0;
2037 if (
func_type->code () == TYPE_CODE_PTR)
2040 gdb_assert (
func_type->code () == TYPE_CODE_FUNC ||
2041 func_type->code () == TYPE_CODE_METHOD);
2049 num_prototyped_args =
func_type->num_fields ();
2063 for (i = nargs - 1; i >= 0; i--)
2065 struct value *arg = args[i];
2066 const gdb_byte *arg_bits = arg->
contents ().data ();
2067 struct type *arg_type = arg->
type ();
2068 ULONGEST arg_size = arg_type->
length ();
2073 && i < num_prototyped_args
2082 struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->
r1 : tdep->
r0;
2087 else if (mach == bfd_mach_m16c
2090 && i < num_prototyped_args
2100 if (mach == bfd_mach_m32c)
2171 return (
code == TYPE_CODE_STRUCT
2172 ||
code == TYPE_CODE_UNION);
2177 struct value *function,
2178 struct type *valtype,
2181 const gdb_byte *writebuf)
2186 ULONGEST valtype_len = valtype->
length ();
2200 gdb_assert (valtype_len <= 8);
2203 if (valtype_len <= tdep->r0->type->length ())
2218 error (_(
"The return value is stored in memory at 'mem0', "
2219 "but GDB cannot find\n"
2232 gdb_assert (valtype_len <= 8);
2235 if (valtype_len <= tdep->r0->type->length ())
2250 error (_(
"The return value is stored in memory at 'mem0', "
2251 "but GDB cannot find\n"
2324 CORE_ADDR start, end;
2329 if (strcmp (
name,
"m32c_jsri16") == 0
2330 && stop_pc == start)
2411 struct type *
type, gdb_byte *buf, CORE_ADDR addr)
2419 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2421 const char *func_name;
2430 error (_(
"Cannot convert code address %s to function pointer:\n"
2431 "couldn't find a symbol at that address, to find trampoline."),
2435 tramp_name = (
char *)
xmalloc (strlen (func_name) + 5);
2436 strcpy (tramp_name, func_name);
2437 strcat (tramp_name,
".plt");
2462 ptrval = addr & 0xffff;
2464 warning (_(
"Cannot convert code address %s to function pointer:\n"
2465 "couldn't find trampoline named '%s.plt'.\n"
2466 "Returning pointer value %s instead; this may produce\n"
2467 "a useful result if converted back into an address by GDB,\n"
2468 "but will most likely not be useful otherwise."),
2488 struct type *
type,
const gdb_byte *buf)
2500 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2509 int len = strlen (ptr_msym_name);
2512 && strcmp (ptr_msym_name + len - 4,
".plt") == 0)
2521 char *func_name = (
char *)
xmalloc (len - 4 + 1);
2522 memcpy (func_name, ptr_msym_name, len - 4);
2523 func_name[len - 4] =
'\0';
2537 for (aspace = 1; aspace <= 15; aspace++)
2542 ptr |= aspace << 16;
2553 LONGEST *frame_offset)
2556 CORE_ADDR func_addr, func_end;
2563 internal_error (_(
"No virtual frame pointer available"));
2568 case prologue_with_frame_ptr:
2572 case prologue_sans_frame_ptr:
2583 internal_error (_(
"No virtual frame pointer available"));
2608 if (mach == bfd_mach_m16c)
2630 dwarf2_append_sniffers (
gdbarch);
#define bits(obj, st, fn)
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
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, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
function_call_return_method
struct type * init_integer_type(type_allocator &alloc, int bit, int unsigned_p, const char *name)
struct type * lookup_function_type(struct type *type)
struct type * init_pointer_type(type_allocator &alloc, int bit, const char *name, struct type *target_type)
#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)
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)
static m32c_write_reg_t m32c_banked_write
#define CB(name, raw_pair)
enum register_status m32c_write_reg_t(struct m32c_reg *reg, struct regcache *cache, const gdb_byte *buf)
void _initialize_m32c_tdep()
enum register_status m32c_read_reg_t(struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
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 struct bfd_arch_info * bfd_arch_info
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 gdbarch * arch() const
gdb::array_view< const gdb_byte > contents()
struct type * type() const
struct value::@203::@204 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)