X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmoxie-tdep.c;h=0c38438697131208c11690d409a23a599d48fb63;hb=488d02fe7729dda5b9414a3942df68e0c316ce53;hp=200365792c78cc9c4f588735d1198a0d44e23d93;hpb=e17a4113357102b55cfa5b80557d590a46a43300;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c index 200365792c..0c38438697 100644 --- a/gdb/moxie-tdep.c +++ b/gdb/moxie-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for Moxie. - Copyright (C) 2009 Free Software Foundation, Inc. + Copyright (C) 2009-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -25,7 +25,6 @@ #include "gdbtypes.h" #include "gdbcmd.h" #include "gdbcore.h" -#include "gdb_string.h" #include "value.h" #include "inferior.h" #include "symfile.h" @@ -36,14 +35,11 @@ #include "regcache.h" #include "trad-frame.h" #include "dis-asm.h" - -#include "gdb_assert.h" +#include "record.h" +#include "record-full.h" #include "moxie-tdep.h" - -/* Local functions. */ - -extern void _initialize_moxie_tdep (void); +#include /* Use an invalid address value as 'not available' marker. */ enum { REG_UNAVAIL = (CORE_ADDR) -1 }; @@ -68,21 +64,13 @@ moxie_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) return sp & ~1; } -/* Implement the "breakpoint_from_pc" gdbarch method. */ +constexpr gdb_byte moxie_break_insn[] = { 0x35, 0x00 }; -const static unsigned char * -moxie_breakpoint_from_pc (struct gdbarch *gdbarch, - CORE_ADDR *pcptr, int *lenptr) -{ - static unsigned char breakpoint[] = { 0x35, 0x00 }; - - *lenptr = sizeof (breakpoint); - return breakpoint; -} +typedef BP_MANIPULATION (moxie_break_insn) moxie_breakpoint; /* Moxie register names. */ -char *moxie_register_names[] = { +static const char *moxie_register_names[] = { "$fp", "$sp", "$r0", "$r1", "$r2", "$r3", "$r4", "$r5", "$r6", "$r7", "$r8", "$r9", "$r10", "$r11", "$r12", @@ -118,9 +106,9 @@ moxie_register_type (struct gdbarch *gdbarch, int reg_nr) static void moxie_store_return_value (struct type *type, struct regcache *regcache, - const void *valbuf) + const gdb_byte *valbuf) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR regval; int len = TYPE_LENGTH (type); @@ -130,8 +118,7 @@ moxie_store_return_value (struct type *type, struct regcache *regcache, regcache_cooked_write_unsigned (regcache, RET1_REGNUM, regval); if (len > 4) { - regval = extract_unsigned_integer ((gdb_byte *) valbuf + 4, - len - 4, byte_order); + regval = extract_unsigned_integer (valbuf + 4, len - 4, byte_order); regcache_cooked_write_unsigned (regcache, RET1_REGNUM + 1, regval); } } @@ -144,10 +131,9 @@ moxie_store_return_value (struct type *type, struct regcache *regcache, static CORE_ADDR moxie_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, - struct moxie_frame_cache *cache, - struct frame_info *this_frame) + struct moxie_frame_cache *cache, + struct gdbarch *gdbarch) { - struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR next_addr; ULONGEST inst, inst2; @@ -166,31 +152,47 @@ moxie_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, { inst = read_memory_unsigned_integer (next_addr, 2, byte_order); - /* Match "push $rN" where N is between 2 and 13 inclusive. */ - if (inst >= 0x0614 && inst <= 0x061f) + /* Match "push $sp $rN" where N is between 0 and 13 inclusive. */ + if (inst >= 0x0612 && inst <= 0x061f) { regnum = inst & 0x000f; cache->framesize += 4; cache->saved_regs[regnum] = cache->framesize; next_addr += 2; } + else + break; + } - /* Optional stack allocation for args and local vars <= 4 - byte. */ - else if (inst == 0x01f0) /* ldi.l $r12, X */ - { - offset = read_memory_integer (next_addr + 2, 4, byte_order); - inst2 = read_memory_unsigned_integer (next_addr + 6, 2, byte_order); + inst = read_memory_unsigned_integer (next_addr, 2, byte_order); - if (inst2 == 0x051f) /* add.l $sp, $r12 */ - { - cache->framesize += offset; - } + /* Optional stack allocation for args and local vars <= 4 + byte. */ + if (inst == 0x01e0) /* ldi.l $r12, X */ + { + offset = read_memory_integer (next_addr + 2, 4, byte_order); + inst2 = read_memory_unsigned_integer (next_addr + 6, 2, byte_order); + + if (inst2 == 0x291e) /* sub.l $sp, $r12 */ + { + cache->framesize += offset; + } + + return (next_addr + 8); + } + else if ((inst & 0xff00) == 0x9100) /* dec $sp, X */ + { + cache->framesize += (inst & 0x00ff); + next_addr += 2; - return (next_addr + 8); + while (next_addr < end_addr) + { + inst = read_memory_unsigned_integer (next_addr, 2, byte_order); + if ((inst & 0xff00) != 0x9100) /* no more dec $sp, X */ + break; + cache->framesize += (inst & 0x00ff); + next_addr += 2; } - else /* This is not a prologue instruction. */ - break; } return next_addr; @@ -202,7 +204,7 @@ static CORE_ADDR moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { CORE_ADDR func_addr = 0, func_end = 0; - char *func_name; + const char *func_name; /* See if we can determine the end of the prologue via the symbol table. If so, then return either PC, or the PC after the prologue, whichever @@ -212,7 +214,7 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) CORE_ADDR post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr); if (post_prologue_pc != 0) - return max (pc, post_prologue_pc); + return std::max (pc, post_prologue_pc); else { /* Can't determine prologue from the symbol table, need to examine @@ -225,12 +227,12 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) memset (&cache, 0, sizeof cache); plg_end = moxie_analyze_prologue (func_addr, - func_end, &cache, NULL); + func_end, &cache, gdbarch); /* Found a function. */ - sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL); + sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol; /* Don't use line number debug info for assembly source - files. */ - if (sym && SYMBOL_LANGUAGE (sym) != language_asm) + files. */ + if (sym && sym->language () != language_asm) { sal = find_pc_line (func_addr, 0); if (sal.end && sal.end < func_end) @@ -268,31 +270,181 @@ struct moxie_unwind_cache struct trad_frame_saved_reg *saved_regs; }; -/* Implement the "read_pc" gdbarch method. */ - -static CORE_ADDR -moxie_read_pc (struct regcache *regcache) +/* Read an unsigned integer from the inferior, and adjust + endianness. */ +static ULONGEST +moxie_process_readu (CORE_ADDR addr, gdb_byte *buf, + int length, enum bfd_endian byte_order) { - ULONGEST pc; + if (target_read_memory (addr, buf, length)) + { + if (record_debug) + printf_unfiltered (_("Process record: error reading memory at " + "addr 0x%s len = %d.\n"), + paddress (target_gdbarch (), addr), length); + return -1; + } - regcache_cooked_read_unsigned (regcache, MOXIE_PC_REGNUM, &pc); - return pc; + return extract_unsigned_integer (buf, length, byte_order); } -/* Implement the "write_pc" gdbarch method. */ -static void -moxie_write_pc (struct regcache *regcache, CORE_ADDR val) -{ - regcache_cooked_write_unsigned (regcache, MOXIE_PC_REGNUM, val); -} +/* Helper macro to extract the signed 10-bit offset from a 16-bit + branch instruction. */ +#define INST2OFFSET(o) ((((signed short)((o & ((1<<10)-1))<<6))>>6)<<1) -/* Implement the "unwind_pc" gdbarch method. */ +/* Insert a single step breakpoint. */ -static CORE_ADDR -moxie_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) +static std::vector +moxie_software_single_step (struct regcache *regcache) { - return frame_unwind_register_unsigned (next_frame, MOXIE_SP_REGNUM); + struct gdbarch *gdbarch = regcache->arch (); + CORE_ADDR addr; + gdb_byte buf[4]; + uint16_t inst; + uint32_t tmpu32; + ULONGEST fp; + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + std::vector next_pcs; + + addr = regcache_read_pc (regcache); + + inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); + + /* Decode instruction. */ + if (inst & (1 << 15)) + { + if (inst & (1 << 14)) + { + /* This is a Form 3 instruction. */ + int opcode = (inst >> 10 & 0xf); + + switch (opcode) + { + case 0x00: /* beq */ + case 0x01: /* bne */ + case 0x02: /* blt */ + case 0x03: /* bgt */ + case 0x04: /* bltu */ + case 0x05: /* bgtu */ + case 0x06: /* bge */ + case 0x07: /* ble */ + case 0x08: /* bgeu */ + case 0x09: /* bleu */ + /* Insert breaks on both branches, because we can't currently tell + which way things will go. */ + next_pcs.push_back (addr + 2); + next_pcs.push_back (addr + 2 + INST2OFFSET(inst)); + break; + default: + { + /* Do nothing. */ + break; + } + } + } + else + { + /* This is a Form 2 instruction. They are all 16 bits. */ + next_pcs.push_back (addr + 2); + } + } + else + { + /* This is a Form 1 instruction. */ + int opcode = inst >> 8; + + switch (opcode) + { + /* 16-bit instructions. */ + case 0x00: /* bad */ + case 0x02: /* mov (register-to-register) */ + case 0x05: /* add.l */ + case 0x06: /* push */ + case 0x07: /* pop */ + case 0x0a: /* ld.l (register indirect) */ + case 0x0b: /* st.l */ + case 0x0e: /* cmp */ + case 0x0f: /* nop */ + case 0x10: /* sex.b */ + case 0x11: /* sex.s */ + case 0x12: /* zex.b */ + case 0x13: /* zex.s */ + case 0x14: /* umul.x */ + case 0x15: /* mul.x */ + case 0x16: + case 0x17: + case 0x18: + case 0x1c: /* ld.b (register indirect) */ + case 0x1e: /* st.b */ + case 0x21: /* ld.s (register indirect) */ + case 0x23: /* st.s */ + case 0x26: /* and */ + case 0x27: /* lshr */ + case 0x28: /* ashl */ + case 0x29: /* sub.l */ + case 0x2a: /* neg */ + case 0x2b: /* or */ + case 0x2c: /* not */ + case 0x2d: /* ashr */ + case 0x2e: /* xor */ + case 0x2f: /* mul.l */ + case 0x31: /* div.l */ + case 0x32: /* udiv.l */ + case 0x33: /* mod.l */ + case 0x34: /* umod.l */ + next_pcs.push_back (addr + 2); + break; + + /* 32-bit instructions. */ + case 0x0c: /* ldo.l */ + case 0x0d: /* sto.l */ + case 0x36: /* ldo.b */ + case 0x37: /* sto.b */ + case 0x38: /* ldo.s */ + case 0x39: /* sto.s */ + next_pcs.push_back (addr + 4); + break; + + /* 48-bit instructions. */ + case 0x01: /* ldi.l (immediate) */ + case 0x08: /* lda.l */ + case 0x09: /* sta.l */ + case 0x1b: /* ldi.b (immediate) */ + case 0x1d: /* lda.b */ + case 0x1f: /* sta.b */ + case 0x20: /* ldi.s (immediate) */ + case 0x22: /* lda.s */ + case 0x24: /* sta.s */ + next_pcs.push_back (addr + 6); + break; + + /* Control flow instructions. */ + case 0x03: /* jsra */ + case 0x1a: /* jmpa */ + next_pcs.push_back (moxie_process_readu (addr + 2, buf, 4, + byte_order)); + break; + + case 0x04: /* ret */ + regcache_cooked_read_unsigned (regcache, MOXIE_FP_REGNUM, &fp); + next_pcs.push_back (moxie_process_readu (fp + 4, buf, 4, byte_order)); + break; + + case 0x19: /* jsr */ + case 0x25: /* jmp */ + regcache->raw_read ((inst >> 4) & 0xf, (gdb_byte *) & tmpu32); + next_pcs.push_back (tmpu32); + break; + + case 0x30: /* swi */ + case 0x35: /* brk */ + /* Unsupported, for now. */ + break; + } + } + + return next_pcs; } /* Given a return value in `regbuf' with a type `valtype', @@ -300,32 +452,31 @@ moxie_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) static void moxie_extract_return_value (struct type *type, struct regcache *regcache, - void *dst) + gdb_byte *dst) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - bfd_byte *valbuf = dst; int len = TYPE_LENGTH (type); ULONGEST tmp; /* By using store_unsigned_integer we avoid having to do anything special for small big-endian values. */ regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp); - store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp); + store_unsigned_integer (dst, (len > 4 ? len - 4 : len), byte_order, tmp); /* Ignore return values more than 8 bytes in size because the moxie returns anything more than 8 bytes in the stack. */ if (len > 4) { regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp); - store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp); + store_unsigned_integer (dst + len - 4, 4, byte_order, tmp); } } /* Implement the "return_value" gdbarch method. */ static enum return_value_convention -moxie_return_value (struct gdbarch *gdbarch, struct type *func_type, +moxie_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { @@ -371,7 +522,7 @@ moxie_frame_cache (struct frame_info *this_frame, void **this_cache) int i; if (*this_cache) - return *this_cache; + return (struct moxie_frame_cache *) *this_cache; cache = moxie_alloc_frame_cache (); *this_cache = cache; @@ -383,7 +534,10 @@ moxie_frame_cache (struct frame_info *this_frame, void **this_cache) cache->pc = get_frame_func (this_frame); current_pc = get_frame_pc (this_frame); if (cache->pc) - moxie_analyze_prologue (cache->pc, current_pc, cache, this_frame); + { + struct gdbarch *gdbarch = get_frame_arch (this_frame); + moxie_analyze_prologue (cache->pc, current_pc, cache, gdbarch); + } cache->saved_sp = cache->base - cache->framesize; @@ -394,14 +548,6 @@ moxie_frame_cache (struct frame_info *this_frame, void **this_cache) return cache; } -/* Implement the "unwind_pc" gdbarch method. */ - -static CORE_ADDR -moxie_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_unwind_register_unsigned (next_frame, MOXIE_PC_REGNUM); -} - /* Given a GDB frame, determine the address of the calling function's frame. This will be used to create a new GDB frame struct. */ @@ -442,6 +588,7 @@ moxie_frame_prev_register (struct frame_info *this_frame, static const struct frame_unwind moxie_frame_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, moxie_frame_this_id, moxie_frame_prev_register, NULL, @@ -466,12 +613,436 @@ static const struct frame_base moxie_frame_base = { moxie_frame_base_address }; -static struct frame_id -moxie_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) +/* Parse the current instruction and record the values of the registers and + memory that will be changed in current instruction to "record_arch_list". + Return -1 if something wrong. */ + +static int +moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, + CORE_ADDR addr) { - CORE_ADDR sp = get_frame_register_unsigned (this_frame, MOXIE_SP_REGNUM); + gdb_byte buf[4]; + uint16_t inst; + uint32_t tmpu32; + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record " + "addr = 0x%s\n", + paddress (target_gdbarch (), addr)); + + inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); + + /* Decode instruction. */ + if (inst & (1 << 15)) + { + if (inst & (1 << 14)) + { + /* This is a Form 3 instruction. */ + int opcode = (inst >> 10 & 0xf); + + switch (opcode) + { + case 0x00: /* beq */ + case 0x01: /* bne */ + case 0x02: /* blt */ + case 0x03: /* bgt */ + case 0x04: /* bltu */ + case 0x05: /* bgtu */ + case 0x06: /* bge */ + case 0x07: /* ble */ + case 0x08: /* bgeu */ + case 0x09: /* bleu */ + /* Do nothing. */ + break; + default: + { + /* Do nothing. */ + break; + } + } + } + else + { + /* This is a Form 2 instruction. */ + int opcode = (inst >> 12 & 0x3); + switch (opcode) + { + case 0x00: /* inc */ + case 0x01: /* dec */ + case 0x02: /* gsr */ + { + int reg = (inst >> 8) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x03: /* ssr */ + { + /* Do nothing until GDB learns about moxie's special + registers. */ + } + break; + default: + /* Do nothing. */ + break; + } + } + } + else + { + /* This is a Form 1 instruction. */ + int opcode = inst >> 8; - return frame_id_build (sp, get_frame_pc (this_frame)); + switch (opcode) + { + case 0x00: /* nop */ + /* Do nothing. */ + break; + case 0x01: /* ldi.l (immediate) */ + case 0x02: /* mov (register-to-register) */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x03: /* jsra */ + { + regcache->raw_read ( + MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) + || (record_full_arch_list_add_reg (regcache, + MOXIE_SP_REGNUM)) + || record_full_arch_list_add_mem (tmpu32 - 12, 12)) + return -1; + } + break; + case 0x04: /* ret */ + { + if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) + || (record_full_arch_list_add_reg (regcache, + MOXIE_SP_REGNUM))) + return -1; + } + break; + case 0x05: /* add.l */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x06: /* push */ + { + int reg = (inst >> 4) & 0xf; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_reg (regcache, reg) + || record_full_arch_list_add_mem (tmpu32 - 4, 4)) + return -1; + } + break; + case 0x07: /* pop */ + { + int a = (inst >> 4) & 0xf; + int b = inst & 0xf; + if (record_full_arch_list_add_reg (regcache, a) + || record_full_arch_list_add_reg (regcache, b)) + return -1; + } + break; + case 0x08: /* lda.l */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x09: /* sta.l */ + { + tmpu32 = (uint32_t) moxie_process_readu (addr+2, buf, + 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 4)) + return -1; + } + break; + case 0x0a: /* ld.l (register indirect) */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x0b: /* st.l */ + { + int reg = (inst >> 4) & 0xf; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 4)) + return -1; + } + break; + case 0x0c: /* ldo.l */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x0d: /* sto.l */ + { + int reg = (inst >> 4) & 0xf; + uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, + byte_order)) << 16 ) >> 16; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + tmpu32 += offset; + if (record_full_arch_list_add_mem (tmpu32, 4)) + return -1; + } + break; + case 0x0e: /* cmp */ + { + if (record_full_arch_list_add_reg (regcache, MOXIE_CC_REGNUM)) + return -1; + } + break; + case 0x0f: /* nop */ + { + /* Do nothing. */ + break; + } + case 0x10: /* sex.b */ + case 0x11: /* sex.s */ + case 0x12: /* zex.b */ + case 0x13: /* zex.s */ + case 0x14: /* umul.x */ + case 0x15: /* mul.x */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x16: + case 0x17: + case 0x18: + { + /* Do nothing. */ + break; + } + case 0x19: /* jsr */ + { + regcache->raw_read ( + MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) + || (record_full_arch_list_add_reg (regcache, + MOXIE_SP_REGNUM)) + || record_full_arch_list_add_mem (tmpu32 - 12, 12)) + return -1; + } + break; + case 0x1a: /* jmpa */ + { + /* Do nothing. */ + } + break; + case 0x1b: /* ldi.b (immediate) */ + case 0x1c: /* ld.b (register indirect) */ + case 0x1d: /* lda.b */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x1e: /* st.b */ + { + int reg = (inst >> 4) & 0xf; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 1)) + return -1; + } + break; + case 0x1f: /* sta.b */ + { + tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 1)) + return -1; + } + break; + case 0x20: /* ldi.s (immediate) */ + case 0x21: /* ld.s (register indirect) */ + case 0x22: /* lda.s */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x23: /* st.s */ + { + int reg = (inst >> 4) & 0xf; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 2)) + return -1; + } + break; + case 0x24: /* sta.s */ + { + tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 2)) + return -1; + } + break; + case 0x25: /* jmp */ + { + /* Do nothing. */ + } + break; + case 0x26: /* and */ + case 0x27: /* lshr */ + case 0x28: /* ashl */ + case 0x29: /* sub */ + case 0x2a: /* neg */ + case 0x2b: /* or */ + case 0x2c: /* not */ + case 0x2d: /* ashr */ + case 0x2e: /* xor */ + case 0x2f: /* mul */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x30: /* swi */ + { + /* We currently implement support for libgloss' + system calls. */ + + int inum = moxie_process_readu (addr+2, buf, 4, byte_order); + + switch (inum) + { + case 0x1: /* SYS_exit */ + { + /* Do nothing. */ + } + break; + case 0x2: /* SYS_open */ + { + if (record_full_arch_list_add_reg (regcache, RET1_REGNUM)) + return -1; + } + break; + case 0x4: /* SYS_read */ + { + uint32_t length, ptr; + + /* Read buffer pointer is in $r1. */ + regcache->raw_read (3, (gdb_byte *) & ptr); + ptr = extract_unsigned_integer ((gdb_byte *) & ptr, + 4, byte_order); + + /* String length is at 0x12($fp). */ + regcache->raw_read ( + MOXIE_FP_REGNUM, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + length = moxie_process_readu (tmpu32+20, buf, 4, byte_order); + + if (record_full_arch_list_add_mem (ptr, length)) + return -1; + } + break; + case 0x5: /* SYS_write */ + { + if (record_full_arch_list_add_reg (regcache, RET1_REGNUM)) + return -1; + } + break; + default: + break; + } + } + break; + case 0x31: /* div.l */ + case 0x32: /* udiv.l */ + case 0x33: /* mod.l */ + case 0x34: /* umod.l */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x35: /* brk */ + /* Do nothing. */ + break; + case 0x36: /* ldo.b */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x37: /* sto.b */ + { + int reg = (inst >> 4) & 0xf; + uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, + byte_order)) << 16 ) >> 16; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + tmpu32 += offset; + if (record_full_arch_list_add_mem (tmpu32, 1)) + return -1; + } + break; + case 0x38: /* ldo.s */ + { + int reg = (inst >> 4) & 0xf; + if (record_full_arch_list_add_reg (regcache, reg)) + return -1; + } + break; + case 0x39: /* sto.s */ + { + int reg = (inst >> 4) & 0xf; + uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2, + byte_order)) << 16 ) >> 16; + regcache->raw_read (reg, (gdb_byte *) & tmpu32); + tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, + 4, byte_order); + tmpu32 += offset; + if (record_full_arch_list_add_mem (tmpu32, 2)) + return -1; + } + break; + default: + /* Do nothing. */ + break; + } + } + + if (record_full_arch_list_add_reg (regcache, MOXIE_PC_REGNUM)) + return -1; + if (record_full_arch_list_add_end ()) + return -1; + return 0; } /* Allocate and initialize the moxie gdbarch object. */ @@ -488,15 +1059,15 @@ moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return arches->gdbarch; /* Allocate space for the new architecture. */ - tdep = XMALLOC (struct gdbarch_tdep); + tdep = XCNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); - set_gdbarch_read_pc (gdbarch, moxie_read_pc); - set_gdbarch_write_pc (gdbarch, moxie_write_pc); - set_gdbarch_unwind_sp (gdbarch, moxie_unwind_sp); + set_gdbarch_wchar_bit (gdbarch, 32); + set_gdbarch_wchar_signed (gdbarch, 0); set_gdbarch_num_regs (gdbarch, MOXIE_NUM_REGS); set_gdbarch_sp_regnum (gdbarch, MOXIE_SP_REGNUM); + set_gdbarch_pc_regnum (gdbarch, MOXIE_PC_REGNUM); set_gdbarch_register_name (gdbarch, moxie_register_name); set_gdbarch_register_type (gdbarch, moxie_register_type); @@ -504,29 +1075,29 @@ moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_skip_prologue (gdbarch, moxie_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); - set_gdbarch_breakpoint_from_pc (gdbarch, moxie_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, + moxie_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, + moxie_breakpoint::bp_from_kind); set_gdbarch_frame_align (gdbarch, moxie_frame_align); frame_base_set_default (gdbarch, &moxie_frame_base); - /* Methods for saving / extracting a dummy frame's ID. The ID's - stack address must match the SP value returned by - PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ - set_gdbarch_dummy_id (gdbarch, moxie_dummy_id); - - set_gdbarch_unwind_pc (gdbarch, moxie_unwind_pc); - - set_gdbarch_print_insn (gdbarch, print_insn_moxie); - /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); /* Hook in the default unwinders. */ frame_unwind_append_unwinder (gdbarch, &moxie_frame_unwind); + /* Single stepping. */ + set_gdbarch_software_single_step (gdbarch, moxie_software_single_step); + /* Support simple overlay manager. */ set_gdbarch_overlay_update (gdbarch, simple_overlay_update); + /* Support reverse debugging. */ + set_gdbarch_process_record (gdbarch, moxie_process_record); + return gdbarch; }