/* 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.
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "gdbcore.h"
-#include "gdb_string.h"
#include "value.h"
#include "inferior.h"
#include "symfile.h"
#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 <algorithm>
/* Use an invalid address value as 'not available' marker. */
enum { REG_UNAVAIL = (CORE_ADDR) -1 };
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",
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);
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);
}
}
{
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;
/* 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;
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;
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
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
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)
+ if (sym && sym->language () != language_asm)
{
sal = find_pc_line (func_addr, 0);
if (sal.end && sal.end < func_end)
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<CORE_ADDR>
+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<CORE_ADDR> 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',
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)
{
int i;
if (*this_cache)
- return *this_cache;
+ return (struct moxie_frame_cache *) *this_cache;
cache = moxie_alloc_frame_cache ();
*this_cache = 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. */
static const struct frame_unwind moxie_frame_unwind = {
NORMAL_FRAME,
+ default_frame_unwind_stop_reason,
moxie_frame_this_id,
moxie_frame_prev_register,
NULL,
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. */
-int
+static int
moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
CORE_ADDR addr)
{
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);
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;
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;
{
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;
{
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:
}
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;
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;
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;
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;
/* 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)
{
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;
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,
+ 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;
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;
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;
}
}
- 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;
}
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_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);
/* 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);
}
projects / deliverable / binutils-gdb.git / blobdiff