X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmoxie-tdep.c;h=1f552481662c4c422ed35550d7ad268eeb8a66aa;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=32bacc7c31359dc23bf6d32ff30a9b51bcb89d44;hpb=7b6bb8daaceb9ecf3f42dea57ae82733d6a3b2f6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c index 32bacc7c31..1f55248166 100644 --- a/gdb/moxie-tdep.c +++ b/gdb/moxie-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for Moxie. - Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 2009-2020 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" @@ -37,14 +36,10 @@ #include "trad-frame.h" #include "dis-asm.h" #include "record.h" - -#include "gdb_assert.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 }; @@ -69,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", @@ -119,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); @@ -131,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); } } @@ -166,8 +152,8 @@ 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; @@ -182,19 +168,19 @@ moxie_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, /* Optional stack allocation for args and local vars <= 4 byte. */ - if (inst == 0x0170) /* ldi.l $r5, X */ + 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 == 0x0517) /* add.l $sp, $r5 */ + if (inst2 == 0x291e) /* sub.l $sp, $r12 */ { cache->framesize += offset; } return (next_addr + 8); } - else if ((inst & 0xff00) == 0x91) /* dec $sp, X */ + else if ((inst & 0xff00) == 0x9100) /* dec $sp, X */ { cache->framesize += (inst & 0x00ff); next_addr += 2; @@ -202,7 +188,7 @@ moxie_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, while (next_addr < end_addr) { inst = read_memory_unsigned_integer (next_addr, 2, byte_order); - if ((inst & 0xff00) != 0x91) /* no more dec $sp, X */ + if ((inst & 0xff00) != 0x9100) /* no more dec $sp, X */ break; cache->framesize += (inst & 0x00ff); next_addr += 2; @@ -218,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 @@ -228,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 @@ -243,10 +229,10 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) plg_end = moxie_analyze_prologue (func_addr, 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) @@ -284,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_sp" 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', @@ -316,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) { @@ -387,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; @@ -413,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. */ @@ -461,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, @@ -485,37 +613,11 @@ 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) -{ - CORE_ADDR sp = get_frame_register_unsigned (this_frame, MOXIE_SP_REGNUM); - - return frame_id_build (sp, get_frame_pc (this_frame)); -} - -/* Read an unsigned integer from the inferior, and adjust - endianess. */ -static ULONGEST -moxie_process_readu (CORE_ADDR addr, char *buf, - int length, enum bfd_endian byte_order) -{ - 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; - } - - return extract_unsigned_integer (buf, length, byte_order); -} - /* 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. */ + Return -1 if something wrong. */ -int +static int moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr) { @@ -527,7 +629,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record " "addr = 0x%s\n", - paddress (target_gdbarch, addr)); + paddress (target_gdbarch (), addr)); inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); @@ -571,7 +673,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x02: /* gsr */ { int reg = (inst >> 8) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; @@ -601,46 +703,46 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x02: /* mov (register-to-register) */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x03: /* jsra */ { - regcache_raw_read (regcache, + regcache->raw_read ( MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) - || (record_arch_list_add_reg (regcache, - MOXIE_SP_REGNUM)) - || record_arch_list_add_mem (tmpu32 - 12, 12)) + 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_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) - || (record_arch_list_add_reg (regcache, - MOXIE_SP_REGNUM))) + 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_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x06: /* push */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_reg (regcache, reg) - || record_arch_list_add_mem (tmpu32 - 4, 4)) + if (record_full_arch_list_add_reg (regcache, reg) + || record_full_arch_list_add_mem (tmpu32 - 4, 4)) return -1; } break; @@ -648,15 +750,15 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, { int a = (inst >> 4) & 0xf; int b = inst & 0xf; - if (record_arch_list_add_reg (regcache, a) - || record_arch_list_add_reg (regcache, b)) + 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_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; @@ -664,60 +766,70 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, { tmpu32 = (uint32_t) moxie_process_readu (addr+2, buf, 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 4)) + 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_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x0b: /* st.l */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 4)) + if (record_full_arch_list_add_mem (tmpu32, 4)) return -1; } break; case 0x0c: /* ldo.l */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x0d: /* sto.l */ { int reg = (inst >> 4) & 0xf; - uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4, - byte_order); - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + 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_arch_list_add_mem (tmpu32, 4)) + if (record_full_arch_list_add_mem (tmpu32, 4)) return -1; } break; case 0x0e: /* cmp */ { - if (record_arch_list_add_reg (regcache, MOXIE_CC_REGNUM)) + 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 0x0f: - case 0x10: - case 0x11: - case 0x12: - case 0x13: - case 0x14: - case 0x15: case 0x16: case 0x17: case 0x18: @@ -727,14 +839,14 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, } case 0x19: /* jsr */ { - regcache_raw_read (regcache, + regcache->raw_read ( MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_reg (regcache, MOXIE_FP_REGNUM) - || (record_arch_list_add_reg (regcache, - MOXIE_SP_REGNUM)) - || record_arch_list_add_mem (tmpu32 - 12, 12)) + 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; @@ -748,25 +860,24 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x1d: /* lda.b */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x1e: /* st.b */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 1)) + if (record_full_arch_list_add_mem (tmpu32, 1)) return -1; } break; case 0x1f: /* sta.b */ { - tmpu32 = moxie_process_readu (addr+2, (char *) buf, - 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 1)) + tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 1)) return -1; } break; @@ -775,25 +886,24 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x22: /* lda.s */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x23: /* st.s */ { int reg = (inst >> 4) & 0xf; - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + regcache->raw_read (reg, (gdb_byte *) & tmpu32); tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 2)) + if (record_full_arch_list_add_mem (tmpu32, 2)) return -1; } break; case 0x24: /* sta.s */ { - tmpu32 = moxie_process_readu (addr+2, (char *) buf, - 4, byte_order); - if (record_arch_list_add_mem (tmpu32, 2)) + tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order); + if (record_full_arch_list_add_mem (tmpu32, 2)) return -1; } break; @@ -805,16 +915,16 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x26: /* and */ case 0x27: /* lshr */ case 0x28: /* ashl */ - case 0x29: /* sub.l */ + case 0x29: /* sub */ case 0x2a: /* neg */ case 0x2b: /* or */ case 0x2c: /* not */ case 0x2d: /* ashr */ case 0x2e: /* xor */ - case 0x2f: /* mul.l */ + case 0x2f: /* mul */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; @@ -823,8 +933,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, /* We currently implement support for libgloss' system calls. */ - int inum = moxie_process_readu (addr+2, (char *) buf, - 4, byte_order); + int inum = moxie_process_readu (addr+2, buf, 4, byte_order); switch (inum) { @@ -835,7 +944,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, break; case 0x2: /* SYS_open */ { - if (record_arch_list_add_reg (regcache, RET1_REGNUM)) + if (record_full_arch_list_add_reg (regcache, RET1_REGNUM)) return -1; } break; @@ -844,25 +953,24 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, uint32_t length, ptr; /* Read buffer pointer is in $r1. */ - regcache_raw_read (regcache, 3, (gdb_byte *) & ptr); + 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 (regcache, + /* 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, (char *) buf, - 4, byte_order); + length = moxie_process_readu (tmpu32+20, buf, 4, byte_order); - if (record_arch_list_add_mem (ptr, length)) + if (record_full_arch_list_add_mem (ptr, length)) return -1; } break; case 0x5: /* SYS_write */ { - if (record_arch_list_add_reg (regcache, RET1_REGNUM)) + if (record_full_arch_list_add_reg (regcache, RET1_REGNUM)) return -1; } break; @@ -877,7 +985,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x34: /* umod.l */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; @@ -887,40 +995,40 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, case 0x36: /* ldo.b */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x37: /* sto.b */ { int reg = (inst >> 4) & 0xf; - uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4, - byte_order); - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + 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_arch_list_add_mem (tmpu32, 1)) + if (record_full_arch_list_add_mem (tmpu32, 1)) return -1; } break; case 0x38: /* ldo.s */ { int reg = (inst >> 4) & 0xf; - if (record_arch_list_add_reg (regcache, reg)) + if (record_full_arch_list_add_reg (regcache, reg)) return -1; } break; case 0x39: /* sto.s */ { int reg = (inst >> 4) & 0xf; - uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4, - byte_order); - regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32); + 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_arch_list_add_mem (tmpu32, 2)) + if (record_full_arch_list_add_mem (tmpu32, 2)) return -1; } break; @@ -930,9 +1038,9 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, } } - if (record_arch_list_add_reg (regcache, MOXIE_PC_REGNUM)) + if (record_full_arch_list_add_reg (regcache, MOXIE_PC_REGNUM)) return -1; - if (record_arch_list_add_end ()) + if (record_full_arch_list_add_end ()) return -1; return 0; } @@ -951,12 +1059,11 @@ 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); @@ -968,26 +1075,23 @@ 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); @@ -999,8 +1103,9 @@ moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Register this machine's init routine. */ +void _initialize_moxie_tdep (); void -_initialize_moxie_tdep (void) +_initialize_moxie_tdep () { register_gdbarch_init (bfd_arch_moxie, moxie_gdbarch_init); }