44#include "opcode/m68hc11.h"
45#include "elf/m68hc11.h"
60#define MSYMBOL_SET_RTC(msym) \
61 (msym)->set_target_flag_1 (true)
63#define MSYMBOL_SET_RTI(msym) \
64 (msym)->set_target_flag_2 (true)
66#define MSYMBOL_IS_RTC(msym) \
67 (msym)->target_flag_1 ()
69#define MSYMBOL_IS_RTI(msym) \
70 (msym)->target_flag_2 ()
81#define HARD_X_REGNUM 0
82#define HARD_D_REGNUM 1
83#define HARD_Y_REGNUM 2
84#define HARD_SP_REGNUM 3
85#define HARD_PC_REGNUM 4
87#define HARD_A_REGNUM 5
88#define HARD_B_REGNUM 6
89#define HARD_CCR_REGNUM 7
96#define HARD_PAGE_REGNUM 8
97#define M68HC11_LAST_HARD_REG (HARD_PAGE_REGNUM)
102#define SOFT_Z_REGNUM 8
107#define SOFT_FP_REGNUM 9
108#define SOFT_TMP_REGNUM 10
109#define SOFT_ZS_REGNUM 11
110#define SOFT_XY_REGNUM 12
111#define SOFT_UNUSED_REGNUM 13
112#define SOFT_D1_REGNUM 14
113#define SOFT_D32_REGNUM (SOFT_D1_REGNUM+31)
114#define M68HC11_MAX_SOFT_REGS 32
116#define M68HC11_NUM_REGS (M68HC11_LAST_HARD_REG + 1)
117#define M68HC11_NUM_PSEUDO_REGS (M68HC11_MAX_SOFT_REGS+5)
118#define M68HC11_ALL_REGS (M68HC11_NUM_REGS+M68HC11_NUM_PSEUDO_REGS)
120#define M68HC11_REG_SIZE (2)
122#define M68HC12_NUM_REGS (9)
123#define M68HC12_NUM_PSEUDO_REGS ((M68HC11_MAX_SOFT_REGS+5)+1-1)
124#define M68HC12_HARD_PC_REGNUM (SOFT_D32_REGNUM+1)
184 "x",
"d",
"y",
"sp",
"pc",
"a",
"b",
185 "ccr",
"page",
"frame",
"tmp",
"zs",
"xy", 0,
186 "d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
187 "d8",
"d9",
"d10",
"d11",
"d12",
"d13",
"d14",
188 "d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
189 "d22",
"d23",
"d24",
"d25",
"d26",
"d27",
"d28",
190 "d29",
"d30",
"d31",
"d32"
201#define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
266 warning (_(
"No frame soft register found in the symbol table.\n"
267 "Stack backtrace will not work."));
292static enum register_status
295 int regno, gdb_byte *buf)
304 const int regsize = 4;
305 enum register_status
status;
310 if (pc >= 0x8000 && pc < 0xc000)
343 int regno,
const gdb_byte *buf)
351 const int regsize = 4;
352 gdb_byte *tmp = (gdb_byte *) alloca (regsize);
355 memcpy (tmp, buf, regsize);
376 const int regsize = 2;
377 gdb_byte *tmp = (gdb_byte *) alloca (regsize);
378 memcpy (tmp, buf, regsize);
415#define M6811_OP_PAGE2 (0x18)
416#define M6811_OP_LDX (0xde)
417#define M6811_OP_LDX_EXT (0xfe)
418#define M6811_OP_PSHX (0x3c)
419#define M6811_OP_STS (0x9f)
420#define M6811_OP_STS_EXT (0xbf)
421#define M6811_OP_TSX (0x30)
422#define M6811_OP_XGDX (0x8f)
423#define M6811_OP_ADDD (0xc3)
424#define M6811_OP_TXS (0x35)
425#define M6811_OP_DES (0x34)
428#define M6812_OP_PAGE2 (0x18)
429#define M6812_OP_MOVW (0x01)
430#define M6812_PB_PSHW (0xae)
431#define M6812_OP_STS (0x5f)
432#define M6812_OP_STS_EXT (0x7f)
433#define M6812_OP_LEAS (0x1b)
434#define M6812_OP_PSHX (0x34)
435#define M6812_OP_PSHY (0x35)
438#define OP_DIRECT (0x100)
439#define OP_IMM_LOW (0x200)
440#define OP_IMM_HIGH (0x300)
441#define OP_PBYTE (0x400)
523 for (; seq->
type != P_LAST; seq++)
526 for (j = 0; j < seq->
length; j++)
535 if (seq->
code[j] == buffer[j])
538 if ((seq->
code[j] & 0xf00) == 0)
542 switch (seq->
code[j])
545 cur_val = (CORE_ADDR) buffer[j];
549 cur_val = cur_val & 0x0ff;
550 cur_val |= (buffer[j] << 8);
555 cur_val |= buffer[j];
559 if ((buffer[j] & 0xE0) == 0x80)
561 v = buffer[j] & 0x1f;
565 else if ((buffer[j] & 0xfe) == 0xf0)
571 else if (buffer[j] == 0xf2)
623 int found_frame_point;
630 if (pc >= current_pc)
687 found_frame_point = 0;
690 while (!done && pc + 2 < func_end)
702 if (pc + seq->
length > current_pc)
706 if (seq->
type == P_SAVE_REG)
708 if (found_frame_point)
715 if (info->saved_regs)
716 info->saved_regs[
saved_reg].set_addr (save_addr);
723 else if (seq->
type == P_SET_FRAME)
725 found_frame_point = 1;
728 else if (seq->
type == P_LOCAL_1)
732 else if (seq->
type == P_LOCAL_2)
736 else if (seq->
type == P_LOCAL_N)
740 size -= (int) (val) | 0xffff0000;
745 if (found_frame_point == 0)
746 info->sp_offset =
size;
748 info->sp_offset = -1;
755 CORE_ADDR func_addr, func_end;
765 if (sal.
end && sal.
end < func_end)
781 void **this_prologue_cache)
787 CORE_ADDR current_pc;
790 if ((*this_prologue_cache))
794 (*this_prologue_cache) = info;
818 if (info->sp_offset != (CORE_ADDR) -1)
822 prev_sp = this_base + info->sp_offset + 2;
829 prev_sp = this_base + info->size + 2;
856 info->base = this_base;
861 if (info->saved_regs[i].is_addr ())
863 info->saved_regs[i].set_addr (info->saved_regs[i].addr () + this_base);
878 void **this_prologue_cache,
893 base = info->prev_sp;
903 void **this_prologue_cache,
int regnum)
917 if (
pc >= 0x08000 &&
pc < 0x0c000)
929 pc += ((page & 0x0ff) << 14);
965 addr = info->base + info->size;
1013 gdb_printf (file,
"0x%02x ", (
unsigned char) rval);
1020 = gdbarch_tdep<m68gc11_gdbarch_tdep> (
gdbarch);
1027 gdb_printf (file,
"0x%02x:%04x ", (
unsigned) page,
1032 gdb_printf (file,
"0x%04x ", (
unsigned) rval);
1043 unsigned char l = rval & 0xff;
1046 l & M6811_S_BIT ?
'S' :
'-',
1047 l & M6811_X_BIT ?
'X' :
'-',
1048 l & M6811_H_BIT ?
'H' :
'-',
1049 l & M6811_I_BIT ?
'I' :
'-',
1050 l & M6811_N_BIT ?
'N' :
'-',
1051 l & M6811_Z_BIT ?
'Z' :
'-',
1052 l & M6811_V_BIT ?
'V' :
'-',
1053 l & M6811_C_BIT ?
'C' :
'-');
1054 N = (l & M6811_N_BIT) != 0;
1055 Z = (l & M6811_Z_BIT) != 0;
1056 V = (l & M6811_V_BIT) != 0;
1057 C = (l & M6811_C_BIT) != 0;
1062 else if ((C | Z) == 1)
1077 if ((Z | (N ^ V)) == 0)
1149 if (nr && (nr % 8) != 7)
1157 int nargs,
struct value **args, CORE_ADDR sp,
1159 CORE_ADDR struct_addr)
1163 int first_stack_argnum;
1165 const gdb_byte *val;
1168 first_stack_argnum = 0;
1173 type = args[0]->type ();
1182 first_stack_argnum = 1;
1193 for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
1195 type = args[argnum]->type ();
1199 static gdb_byte zero = 0;
1204 val = args[argnum]->contents ().data ();
1251 const gdb_byte *valbuf)
1266 error (_(
"return of value > 4 is not supported."));
1283 memcpy (valbuf, buf + 1, 1);
1287 memcpy (valbuf, buf, 2);
1291 memcpy ((
char*) valbuf + 1, buf, 2);
1293 memcpy (valbuf, buf + 1, 1);
1297 memcpy ((
char*) valbuf + 2, buf, 2);
1299 memcpy (valbuf, buf, 2);
1303 error (_(
"bad size for return value"));
1310 gdb_byte *readbuf,
const gdb_byte *writebuf)
1312 if (valtype->
code () == TYPE_CODE_STRUCT
1313 || valtype->
code () == TYPE_CODE_UNION
1314 || valtype->
code () == TYPE_CODE_ARRAY
1315 || valtype->
length () > 4)
1319 if (readbuf != NULL)
1321 if (writebuf != NULL)
1333 unsigned char flags;
1335 flags = ((elf_symbol_type *)sym)->internal_elf_sym.st_other;
1336 if (
flags & STO_M68HC12_FAR)
1338 if (
flags & STO_M68HC12_INTERRUPT)
1404 if (
info.abfd != NULL
1405 && bfd_get_flavour (
info.abfd) == bfd_target_elf_flavour)
1406 elf_flags = elf_elfheader (
info.abfd)->e_flags;
1416 = gdbarch_tdep<m68gc11_gdbarch_tdep> (
arches->gdbarch);
1431 switch (
info.bfd_arch_info->arch)
1433 case bfd_arch_m68hc11:
1443 case bfd_arch_m68hc12:
1449 elf_flags & E_M68HC12_BANKS
1469 if (elf_flags & E_M68HC11_F64)
1502 m68hc11_breakpoint::kind_from_pc);
1504 m68hc11_breakpoint::bp_from_kind);
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)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_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)
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
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
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)
LONGEST get_frame_register_signed(frame_info_ptr frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr 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)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
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)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special)
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_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
void set_gdbarch_print_registers_info(struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
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_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
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_long_bit(struct gdbarch *gdbarch, int long_bit)
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)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
static int gdbarch_num_cooked_regs(gdbarch *arch)
function_call_return_method
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static int soft_reg_initialized
static void m68hc11_add_reggroups(struct gdbarch *gdbarch)
static struct type * m68hc11_register_type(struct gdbarch *gdbarch, int reg_nr)
#define M68HC11_LAST_HARD_REG
static const reggroup * m68hc11_soft_reggroup
#define M68HC11_MAX_SOFT_REGS
static const char * m68hc11_register_names[]
static int stack_correction(gdbarch *arch)
static CORE_ADDR m68hc11_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void m68hc11_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static void m68hc11_print_register(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regno)
static void m68hc11_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
#define MSYMBOL_SET_RTI(msym)
static struct m68hc11_unwind_cache * m68hc11_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
static void m68hc11_get_register_info(struct m68hc11_soft_reg *reg, const char *name)
static struct value * m68hc11_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static struct frame_id m68hc11_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
#define MSYMBOL_IS_RTI(msym)
static enum register_status m68hc11_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regno, gdb_byte *buf)
static CORE_ADDR m68hc11_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)
static struct insn_sequence * m68hc11_analyze_instruction(struct gdbarch *gdbarch, struct insn_sequence *seq, CORE_ADDR pc, CORE_ADDR *val)
static struct gdbarch * m68hc11_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static enum insn_return_kind m68hc11_get_return_insn(CORE_ADDR pc)
constexpr gdb_byte m68hc11_break_insn[]
static CORE_ADDR m68hc11_frame_base_address(frame_info_ptr this_frame, void **this_cache)
#define MSYMBOL_IS_RTC(msym)
static const reggroup * m68hc11_hard_reggroup
void _initialize_m68hc11_tdep()
static CORE_ADDR m68hc11_frame_args_address(frame_info_ptr this_frame, void **this_cache)
static int m68hc11_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
static void m68hc11_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regno, int cpregs)
static int m68hc11_which_soft_register(CORE_ADDR addr)
#define MSYMBOL_SET_RTC(msym)
static const struct frame_base m68hc11_frame_base
static struct insn_sequence m6812_prologue[]
static struct m68hc11_soft_reg soft_regs[M68HC11_ALL_REGS]
static void m68hc11_init_reggroups(void)
#define M68HC12_NUM_PSEUDO_REGS
static struct insn_sequence m6811_prologue[]
static void m68hc11_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static enum return_value_convention m68hc11_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static void m68hc11_initialize_register_info(void)
static const struct frame_unwind m68hc11_frame_unwind
static void m68hc11_extract_return_value(struct type *type, struct regcache *regcache, void *valbuf)
#define M68HC12_HARD_PC_REGNUM
static const char * m68hc11_register_name(struct gdbarch *gdbarch, int reg_nr)
static int use_page_register(gdbarch *arch)
#define M68HC11_NUM_PSEUDO_REGS
static CORE_ADDR m68hc11_scan_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68hc11_unwind_cache *info)
static void m68hc11_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regno, const gdb_byte *buf)
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)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
const reggroup * reggroup_new(const char *name, enum reggroup_type type)
const reggroup *const save_reggroup
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
const reggroup *const restore_reggroup
void(* func)(remote_target *remote, char *)
CORE_ADDR value_address() const
struct minimal_symbol * minsym
struct type * builtin_uint16
struct type * builtin_uint32
struct type * builtin_uint8
unsigned short code[MAX_CODES]
struct insn_sequence * prologue
trad_frame_saved_reg * saved_regs
enum insn_return_kind return_kind
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
void gdb_printf(struct ui_file *stream, const char *format,...)
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
LONGEST value_as_long(struct value *val)
value_ref_ptr release_value(struct value *val)