|
|
@@ -0,0 +1,925 @@
|
|
|
+#include <u.h>
|
|
|
+#include <libc.h>
|
|
|
+#include <bio.h>
|
|
|
+#include <mach.h>
|
|
|
+/*
|
|
|
+ * Alpha-specific debugger interface
|
|
|
+ */
|
|
|
+
|
|
|
+static char *alphaexcep(Map*, Rgetter);
|
|
|
+static int alphafoll(Map*, uvlong, Rgetter, uvlong*);
|
|
|
+static int alphainst(Map*, uvlong, char, char*, int);
|
|
|
+static int alphadas(Map*, uvlong, char*, int);
|
|
|
+static int alphainstlen(Map*, uvlong);
|
|
|
+/*
|
|
|
+ * Debugger interface
|
|
|
+ */
|
|
|
+Machdata alphamach =
|
|
|
+{
|
|
|
+ {0x80, 0, 0, 0}, /* break point */
|
|
|
+ 4, /* break point size */
|
|
|
+
|
|
|
+ leswab, /* short to local byte order */
|
|
|
+ leswal, /* long to local byte order */
|
|
|
+ leswav, /* vlong to local byte order */
|
|
|
+ risctrace, /* C traceback */
|
|
|
+ riscframe, /* Frame finder */
|
|
|
+ alphaexcep, /* print exception */
|
|
|
+ 0, /* breakpoint fixup */
|
|
|
+ leieeesftos, /* single precision float printer */
|
|
|
+ leieeedftos, /* double precisioin float printer */
|
|
|
+ alphafoll, /* following addresses */
|
|
|
+ alphainst, /* print instruction */
|
|
|
+ alphadas, /* dissembler */
|
|
|
+ alphainstlen, /* instruction size */
|
|
|
+};
|
|
|
+
|
|
|
+static char *illegaltype[] = {
|
|
|
+ "breakpoint",
|
|
|
+ "bugchk",
|
|
|
+ "gentrap",
|
|
|
+ "fen",
|
|
|
+ "illegal instruction",
|
|
|
+};
|
|
|
+
|
|
|
+static char *
|
|
|
+alphaexcep(Map *map, Rgetter rget)
|
|
|
+{
|
|
|
+ ulong type, a0, a1;
|
|
|
+ static char buf[256];
|
|
|
+
|
|
|
+ type = (*rget)(map, "TYPE");
|
|
|
+ a0 = (*rget)(map, "A0");
|
|
|
+ a1 = (*rget)(map, "A1");
|
|
|
+/* a2 = (*rget)(map, "A2"); */
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+ case 1: /* arith */
|
|
|
+ sprint(buf, "trap: arithmetic trap 0x%lux", a0);
|
|
|
+ break;
|
|
|
+ case 2: /* bad instr or FEN */
|
|
|
+ if (a0 <= 4)
|
|
|
+ return illegaltype[a0];
|
|
|
+ else
|
|
|
+ sprint(buf, "illegal instr trap, unknown type %lud", a0);
|
|
|
+ break;
|
|
|
+ case 3: /* intr */
|
|
|
+ sprint(buf, "interrupt type %lud", a0);
|
|
|
+ break;
|
|
|
+ case 4: /* memory fault */
|
|
|
+ sprint(buf, "fault %s addr=0x%lux", (a1&1)?"write":"read", a0);
|
|
|
+ break;
|
|
|
+ case 5: /* syscall() */
|
|
|
+ return "system call";
|
|
|
+ case 6: /* alignment fault */
|
|
|
+ sprint(buf, "unaligned op 0x%lux addr 0x%lux", a1, a0);
|
|
|
+ break;
|
|
|
+ default: /* cannot happen */
|
|
|
+ sprint(buf, "unknown exception type %lud", type);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return buf;
|
|
|
+}
|
|
|
+
|
|
|
+ /* alpha disassembler and related functions */
|
|
|
+
|
|
|
+static char FRAMENAME[] = ".frame";
|
|
|
+
|
|
|
+typedef struct {
|
|
|
+ uvlong addr;
|
|
|
+ uchar op; /* bits 31-26 */
|
|
|
+ uchar ra; /* bits 25-21 */
|
|
|
+ uchar rb; /* bits 20-16 */
|
|
|
+ uchar rc; /* bits 4-0 */
|
|
|
+ long mem; /* bits 15-0 */
|
|
|
+ long branch; /* bits 20-0 */
|
|
|
+ uchar function; /* bits 11-5 */
|
|
|
+ uchar literal; /* bits 20-13 */
|
|
|
+ uchar islit; /* bit 12 */
|
|
|
+ uchar fpfn; /* bits 10-5 */
|
|
|
+ uchar fpmode; /* bits 15-11 */
|
|
|
+ long w0;
|
|
|
+ long w1;
|
|
|
+ int size; /* instruction size */
|
|
|
+ char *curr; /* fill point in buffer */
|
|
|
+ char *end; /* end of buffer */
|
|
|
+ char *err; /* error message */
|
|
|
+} Instr;
|
|
|
+
|
|
|
+static Map *mymap;
|
|
|
+
|
|
|
+static int
|
|
|
+decode(uvlong pc, Instr *i)
|
|
|
+{
|
|
|
+ ulong w;
|
|
|
+
|
|
|
+ if (get4(mymap, pc, &w) < 0) {
|
|
|
+ werrstr("can't read instruction: %r");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ i->addr = pc;
|
|
|
+ i->size = 1;
|
|
|
+ i->op = (w >> 26) & 0x3F;
|
|
|
+ i->ra = (w >> 21) & 0x1F;
|
|
|
+ i->rb = (w >> 16) & 0x1F;
|
|
|
+ i->rc = w & 0x1F;
|
|
|
+ i->function = (w >> 5) & 0x7F;
|
|
|
+ i->mem = w & 0xFFFF;
|
|
|
+ if (i->mem & 0x8000)
|
|
|
+ i->mem -= 0x10000;
|
|
|
+ i->branch = w & 0x1FFFFF;
|
|
|
+ if (i->branch & 0x100000)
|
|
|
+ i->branch -= 0x200000;
|
|
|
+ i->function = (w >> 5) & 0x7F;
|
|
|
+ i->literal = (w >> 13) & 0xFF;
|
|
|
+ i->islit = (w >> 12) & 0x01;
|
|
|
+ i->fpfn = (w >> 5) & 0x3F;
|
|
|
+ i->fpmode = (w >> 11) & 0x1F;
|
|
|
+ i->w0 = w;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+mkinstr(uvlong pc, Instr *i)
|
|
|
+{
|
|
|
+/* Instr x; */
|
|
|
+
|
|
|
+ if (decode(pc, i) < 0)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+#ifdef frommips
|
|
|
+/* we probably want to do something like this for alpha... */
|
|
|
+ /*
|
|
|
+ * if it's a LUI followed by an ORI,
|
|
|
+ * it's an immediate load of a large constant.
|
|
|
+ * fix the LUI immediate in any case.
|
|
|
+ */
|
|
|
+ if (i->op == 0x0F) {
|
|
|
+ if (decode(pc+4, &x) < 0)
|
|
|
+ return 0;
|
|
|
+ i->immediate <<= 16;
|
|
|
+ if (x.op == 0x0D && x.rs == x.rt && x.rt == i->rt) {
|
|
|
+ i->immediate |= (x.immediate & 0xFFFF);
|
|
|
+ i->w1 = x.w0;
|
|
|
+ i->size++;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+#pragma varargck argpos bprint 2
|
|
|
+
|
|
|
+static void
|
|
|
+bprint(Instr *i, char *fmt, ...)
|
|
|
+{
|
|
|
+ va_list arg;
|
|
|
+
|
|
|
+ va_start(arg, fmt);
|
|
|
+ i->curr = vseprint(i->curr, i->end, fmt, arg);
|
|
|
+ va_end(arg);
|
|
|
+}
|
|
|
+
|
|
|
+typedef struct Opcode Opcode;
|
|
|
+
|
|
|
+struct Opcode {
|
|
|
+ char *mnemonic;
|
|
|
+ void (*f)(Opcode *, Instr *);
|
|
|
+ char *ken;
|
|
|
+};
|
|
|
+
|
|
|
+static void format(char *, Instr *, char *);
|
|
|
+
|
|
|
+static int
|
|
|
+plocal(Instr *i, char *m, char r, int store)
|
|
|
+{
|
|
|
+ int offset;
|
|
|
+ char *reg;
|
|
|
+ Symbol s;
|
|
|
+
|
|
|
+ if (!findsym(i->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s))
|
|
|
+ return 0;
|
|
|
+ if (s.value > i->mem) {
|
|
|
+ if(!getauto(&s, s.value-i->mem, CAUTO, &s))
|
|
|
+ return 0;
|
|
|
+ reg = "(SP)";
|
|
|
+ offset = i->mem;
|
|
|
+ } else {
|
|
|
+ offset = i->mem-s.value-8;
|
|
|
+ if (!getauto(&s, offset, CPARAM, &s))
|
|
|
+ return 0;
|
|
|
+ reg = "(FP)";
|
|
|
+ }
|
|
|
+ if (store)
|
|
|
+ bprint(i, "%s\t%c%d,%s+%d%s", m, r, i->ra, s.name, offset, reg);
|
|
|
+ else
|
|
|
+ bprint(i, "%s\t%s+%d%s,%c%d", m, s.name, offset, reg, r, i->ra);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+_load(Opcode *o, Instr *i, char r)
|
|
|
+{
|
|
|
+ char *m;
|
|
|
+
|
|
|
+ m = o->mnemonic;
|
|
|
+ if (i->rb == 30 && plocal(i, m, r, 0))
|
|
|
+ return;
|
|
|
+ if (i->rb == 29 && mach->sb) {
|
|
|
+ bprint(i, "%s\t", m);
|
|
|
+ i->curr += symoff(i->curr, i->end-i->curr, i->mem+mach->sb, CANY);
|
|
|
+ bprint(i, "(SB),%c%d", r, i->ra);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ format(m, i, o->ken);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+load(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ _load(o, i, 'R');
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+loadf(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ _load(o, i, 'F');
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+_store(Opcode *o, Instr *i, char r)
|
|
|
+{
|
|
|
+ char *m;
|
|
|
+
|
|
|
+ m = o->mnemonic;
|
|
|
+ if (i->rb == 30 && plocal(i, m, r, 1))
|
|
|
+ return;
|
|
|
+ if (i->rb == 29 && mach->sb) {
|
|
|
+ bprint(i, "%s\t%c%d,", m, r, i->ra);
|
|
|
+ i->curr += symoff(i->curr, i->end-i->curr, i->mem+mach->sb, CANY);
|
|
|
+ bprint(i, "(SB)");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ format(o->mnemonic, i, o->ken);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+store(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ _store(o, i, 'R');
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+storef(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ _store(o, i, 'F');
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+misc(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ char *f;
|
|
|
+
|
|
|
+ USED(o);
|
|
|
+ switch (i->mem&0xFFFF) {
|
|
|
+ case 0x0000:
|
|
|
+ f = "TRAPB";
|
|
|
+ break;
|
|
|
+ case 0x4000:
|
|
|
+ f = "MB";
|
|
|
+ break;
|
|
|
+ case 0x8000:
|
|
|
+ f = "FETCH\t0(R%b)";
|
|
|
+ break;
|
|
|
+ case 0xA000:
|
|
|
+ f = "FETCH_M\t0(R%b)";
|
|
|
+ break;
|
|
|
+ case 0xC000:
|
|
|
+ f = "RPCC\tR%a";
|
|
|
+ break;
|
|
|
+ case 0xE000:
|
|
|
+ f = "RC\tR%a";
|
|
|
+ break;
|
|
|
+ case 0xF000:
|
|
|
+ f = "RS\tR%a";
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ f = "%w";
|
|
|
+ }
|
|
|
+ format(0, i, f);
|
|
|
+}
|
|
|
+
|
|
|
+static char *jmpcode[4] = { "JMP", "JSR", "RET", "JSR_COROUTINE" };
|
|
|
+
|
|
|
+static void
|
|
|
+jmp(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ int hint;
|
|
|
+ char *m;
|
|
|
+
|
|
|
+ USED(o);
|
|
|
+ hint = (i->mem >> 14) & 3;
|
|
|
+ m = jmpcode[hint];
|
|
|
+ if (i->ra == 31) {
|
|
|
+ if (hint == 2 && i->rb == 29)
|
|
|
+ bprint(i, m);
|
|
|
+ else
|
|
|
+ format(m, i, "(R%b)");
|
|
|
+ }
|
|
|
+ else
|
|
|
+ format(m, i, "R%a,(R%b)");
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+br(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ if (i->ra == 31)
|
|
|
+ format(o->mnemonic, i, "%B");
|
|
|
+ else
|
|
|
+ format(o->mnemonic, i, o->ken);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+bsr(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ if (i->ra == 26)
|
|
|
+ format(o->mnemonic, i, "%B");
|
|
|
+ else
|
|
|
+ format(o->mnemonic, i, o->ken);
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+mult(Opcode *o, Instr *i)
|
|
|
+{
|
|
|
+ char *m;
|
|
|
+
|
|
|
+ switch (i->function) {
|
|
|
+ case 0x00:
|
|
|
+ m = "MULL";
|
|
|
+ break;
|
|
|
+ case 0x20:
|
|
|
+ m = "MULQ";
|
|
|
+ break;
|
|
|
+ case 0x40:
|
|
|
+ m = "MULL/V";
|
|
|
+ break;
|
|
|
+ case 0x60:
|
|
|
+ m = "MULQ/V";
|
|
|
+ break;
|
|
|
+ case 0x30:
|
|
|
+ m = "UMULH";
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ format("???", i, "%w");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ format(m, i, o->ken);
|
|
|
+}
|
|
|
+
|
|
|
+static char alphaload[] = "%l,R%a";
|
|
|
+static char alphafload[] = "%l,F%a";
|
|
|
+static char alphastore[] = "R%a,%l";
|
|
|
+static char alphafstore[] = "F%a,%l";
|
|
|
+static char alphabranch[] = "R%a,%B";
|
|
|
+static char alphafbranch[] = "F%a,%B";
|
|
|
+static char alphaint[] = "%v,R%a,R%c";
|
|
|
+static char alphafp[] = "F%b,F%a,F%c";
|
|
|
+static char alphafp2[] = "F%b,F%c";
|
|
|
+static char alphaxxx[] = "%w";
|
|
|
+
|
|
|
+static Opcode opcodes[64] = {
|
|
|
+ "PAL", 0, alphaxxx,
|
|
|
+ "OPC01", 0, alphaxxx,
|
|
|
+ "OPC02", 0, alphaxxx,
|
|
|
+ "OPC03", 0, alphaxxx,
|
|
|
+ "OPC04", 0, alphaxxx,
|
|
|
+ "OPC05", 0, alphaxxx,
|
|
|
+ "OPC06", 0, alphaxxx,
|
|
|
+ "OPC07", 0, alphaxxx,
|
|
|
+ "MOVQA", load, alphaload,
|
|
|
+ "MOVQAH", load, alphaload,
|
|
|
+ "MOVBU", load, alphaload, /* v 3 */
|
|
|
+ "MOVQU", load, alphaload,
|
|
|
+ "MOVWU", load, alphaload, /* v 3 */
|
|
|
+ "MOVWU", store, alphastore, /* v 3 */
|
|
|
+ "MOVBU", store, alphastore, /* v 3 */
|
|
|
+ "MOVQU", store, alphastore,
|
|
|
+ 0, 0, 0, /* int arith */
|
|
|
+ 0, 0, 0, /* logical */
|
|
|
+ 0, 0, 0, /* shift */
|
|
|
+ 0, mult, alphaint,
|
|
|
+ "OPC14", 0, alphaxxx,
|
|
|
+ "vax", 0, alphafp, /* vax */
|
|
|
+ 0, 0, 0, /* ieee */
|
|
|
+ 0, 0, 0, /* fp */
|
|
|
+ 0, misc, alphaxxx,
|
|
|
+ "PAL19 [HW_MFPR]",0, alphaxxx,
|
|
|
+ "JSR", jmp, 0,
|
|
|
+ "PAL1B [HW_LD]",0, alphaxxx,
|
|
|
+ "OPC1C", 0, alphaxxx,
|
|
|
+ "PAL1D [HW_MTPR]",0, alphaxxx,
|
|
|
+ "PAL1E [HW_REI]",0, alphaxxx,
|
|
|
+ "PAL1F [HW_ST]",0, alphaxxx,
|
|
|
+ "MOVF", loadf, alphafload,
|
|
|
+ "MOVG", loadf, alphafload,
|
|
|
+ "MOVS", loadf, alphafload,
|
|
|
+ "MOVT", loadf, alphafload,
|
|
|
+ "MOVF", storef, alphafstore,
|
|
|
+ "MOVG", storef, alphafstore,
|
|
|
+ "MOVS", storef, alphafstore,
|
|
|
+ "MOVT", storef, alphafstore,
|
|
|
+ "MOVL", load, alphaload,
|
|
|
+ "MOVQ", load, alphaload,
|
|
|
+ "MOVLL", load, alphaload,
|
|
|
+ "MOVQL", load, alphaload,
|
|
|
+ "MOVL", store, alphastore,
|
|
|
+ "MOVQ", store, alphastore,
|
|
|
+ "MOVLC", store, alphastore,
|
|
|
+ "MOVQC", store, alphastore,
|
|
|
+ "JMP", br, alphabranch,
|
|
|
+ "FBEQ", 0, alphafbranch,
|
|
|
+ "FBLT", 0, alphafbranch,
|
|
|
+ "FBLE", 0, alphafbranch,
|
|
|
+ "JSR", bsr, alphabranch,
|
|
|
+ "FBNE", 0, alphafbranch,
|
|
|
+ "FBGE", 0, alphafbranch,
|
|
|
+ "FBGT", 0, alphafbranch,
|
|
|
+ "BLBC", 0, alphafbranch,
|
|
|
+ "BEQ", 0, alphabranch,
|
|
|
+ "BLT", 0, alphabranch,
|
|
|
+ "BLE", 0, alphabranch,
|
|
|
+ "BLBS", 0, alphabranch,
|
|
|
+ "BNE", 0, alphabranch,
|
|
|
+ "BGE", 0, alphabranch,
|
|
|
+ "BGT", 0, alphabranch,
|
|
|
+};
|
|
|
+
|
|
|
+static Opcode fpopcodes[64] = {
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+
|
|
|
+ "CVTLQ", 0, alphafp2,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+
|
|
|
+ "CPYS", 0, alphafp,
|
|
|
+ "CPYSN", 0, alphafp,
|
|
|
+ "CPYSE", 0, alphafp,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "MOVT", 0, "FPCR,F%a",
|
|
|
+ "MOVT", 0, "F%a,FPCR",
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "FCMOVEQ", 0, alphafp,
|
|
|
+ "FCMOVNE", 0, alphafp,
|
|
|
+ "FCMOVLT", 0, alphafp,
|
|
|
+ "FCMOVGE", 0, alphafp,
|
|
|
+ "FCMOVLE", 0, alphafp,
|
|
|
+ "FCMOVGT", 0, alphafp,
|
|
|
+
|
|
|
+ "CVTQL", 0, alphafp2,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+};
|
|
|
+
|
|
|
+static Opcode ieeeopcodes[64] = {
|
|
|
+ "ADDS", 0, alphafp,
|
|
|
+ "SUBS", 0, alphafp,
|
|
|
+ "MULS", 0, alphafp,
|
|
|
+ "DIVS", 0, alphafp,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+
|
|
|
+ "ADDT", 0, alphafp,
|
|
|
+ "SUBT", 0, alphafp,
|
|
|
+ "MULT", 0, alphafp,
|
|
|
+ "DIVT", 0, alphafp,
|
|
|
+ "CMPTUN", 0, alphafp,
|
|
|
+ "CMPTEQ", 0, alphafp,
|
|
|
+ "CMPTLT", 0, alphafp,
|
|
|
+ "CMPTLE", 0, alphafp,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "CVTTS", 0, alphafp2,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "CVTTQ", 0, alphafp2,
|
|
|
+
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "CVTQS", 0, alphafp2,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "CVTQT", 0, alphafp2,
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+};
|
|
|
+
|
|
|
+static uchar amap[128] = {
|
|
|
+ [0x00] 1,
|
|
|
+ [0x40] 2,
|
|
|
+ [0x20] 3,
|
|
|
+ [0x60] 4,
|
|
|
+ [0x09] 5,
|
|
|
+ [0x49] 6,
|
|
|
+ [0x29] 7,
|
|
|
+ [0x69] 8,
|
|
|
+ [0x2D] 9,
|
|
|
+ [0x4D] 10,
|
|
|
+ [0x6D] 11,
|
|
|
+ [0x1D] 12,
|
|
|
+ [0x3D] 13,
|
|
|
+ [0x0F] 14,
|
|
|
+ [0x02] 15,
|
|
|
+ [0x0B] 16,
|
|
|
+ [0x12] 17,
|
|
|
+ [0x1B] 18,
|
|
|
+ [0x22] 19,
|
|
|
+ [0x2B] 20,
|
|
|
+ [0x32] 21,
|
|
|
+ [0x3B] 22,
|
|
|
+};
|
|
|
+
|
|
|
+static Opcode arithopcodes[64] = {
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "ADDL", 0, alphaint,
|
|
|
+ "ADDL/V", 0, alphaint,
|
|
|
+ "ADDQ", 0, alphaint,
|
|
|
+ "ADDQ/V", 0, alphaint,
|
|
|
+ "SUBL", 0, alphaint,
|
|
|
+ "SUBL/V", 0, alphaint,
|
|
|
+ "SUBQ", 0, alphaint,
|
|
|
+ "SUBQ/V", 0, alphaint,
|
|
|
+ "CMPEQ", 0, alphaint,
|
|
|
+ "CMPLT", 0, alphaint,
|
|
|
+ "CMPLE", 0, alphaint,
|
|
|
+ "CMPULT", 0, alphaint,
|
|
|
+ "CMPULE", 0, alphaint,
|
|
|
+ "CMPBGE", 0, alphaint,
|
|
|
+ "S4ADDL", 0, alphaint,
|
|
|
+ "S4SUBL", 0, alphaint,
|
|
|
+ "S8ADDL", 0, alphaint,
|
|
|
+ "S8SUBL", 0, alphaint,
|
|
|
+ "S4ADDQ", 0, alphaint,
|
|
|
+ "S4SUBQ", 0, alphaint,
|
|
|
+ "S8ADDQ", 0, alphaint,
|
|
|
+ "S8SUBQ", 0, alphaint,
|
|
|
+};
|
|
|
+
|
|
|
+static uchar lmap[128] = {
|
|
|
+ [0x00] 1,
|
|
|
+ [0x20] 2,
|
|
|
+ [0x40] 3,
|
|
|
+ [0x08] 4,
|
|
|
+ [0x28] 5,
|
|
|
+ [0x48] 6,
|
|
|
+ [0x24] 7,
|
|
|
+ [0x44] 8,
|
|
|
+ [0x64] 9,
|
|
|
+ [0x26] 7,
|
|
|
+ [0x46] 8,
|
|
|
+ [0x66] 9,
|
|
|
+ [0x14] 10,
|
|
|
+ [0x16] 11,
|
|
|
+};
|
|
|
+
|
|
|
+static Opcode logicalopcodes[64] = {
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "AND", 0, alphaint,
|
|
|
+ "OR", 0, alphaint,
|
|
|
+ "XOR", 0, alphaint,
|
|
|
+ "ANDNOT", 0, alphaint,
|
|
|
+ "ORNOT", 0, alphaint,
|
|
|
+ "XORNOT", 0, alphaint,
|
|
|
+ "CMOVEQ", 0, alphaint,
|
|
|
+ "CMOVLT", 0, alphaint,
|
|
|
+ "CMOVLE", 0, alphaint,
|
|
|
+ "CMOVNE", 0, alphaint,
|
|
|
+ "CMOVGE", 0, alphaint,
|
|
|
+ "CMOVGT", 0, alphaint,
|
|
|
+ "CMOVLBS", 0, alphaint,
|
|
|
+ "CMOVLBC", 0, alphaint,
|
|
|
+};
|
|
|
+
|
|
|
+static uchar smap[128] = {
|
|
|
+ [0x39] 1,
|
|
|
+ [0x3C] 2,
|
|
|
+ [0x34] 3,
|
|
|
+ [0x06] 4,
|
|
|
+ [0x16] 5,
|
|
|
+ [0x26] 6,
|
|
|
+ [0x36] 7,
|
|
|
+ [0x5A] 8,
|
|
|
+ [0x6A] 9,
|
|
|
+ [0x7A] 10,
|
|
|
+ [0x0B] 11,
|
|
|
+ [0x1B] 12,
|
|
|
+ [0x2B] 13,
|
|
|
+ [0x3B] 14,
|
|
|
+ [0x57] 15,
|
|
|
+ [0x67] 16,
|
|
|
+ [0x77] 17,
|
|
|
+ [0x02] 18,
|
|
|
+ [0x12] 19,
|
|
|
+ [0x22] 20,
|
|
|
+ [0x32] 21,
|
|
|
+ [0x52] 22,
|
|
|
+ [0x62] 23,
|
|
|
+ [0x72] 24,
|
|
|
+ [0x30] 25,
|
|
|
+ [0x31] 26,
|
|
|
+};
|
|
|
+
|
|
|
+static Opcode shiftopcodes[64] = {
|
|
|
+ "???", 0, alphaxxx,
|
|
|
+ "SLLQ", 0, alphaint,
|
|
|
+ "SRAQ", 0, alphaint,
|
|
|
+ "SRLQ", 0, alphaint,
|
|
|
+ "EXTBL", 0, alphaint,
|
|
|
+ "EXTWL", 0, alphaint,
|
|
|
+ "EXTLL", 0, alphaint,
|
|
|
+ "EXTQL", 0, alphaint,
|
|
|
+ "EXTWH", 0, alphaint,
|
|
|
+ "EXTLH", 0, alphaint,
|
|
|
+ "EXTQH", 0, alphaint,
|
|
|
+ "INSBL", 0, alphaint,
|
|
|
+ "INSWL", 0, alphaint,
|
|
|
+ "INSLL", 0, alphaint,
|
|
|
+ "INSQL", 0, alphaint,
|
|
|
+ "INSWH", 0, alphaint,
|
|
|
+ "INSLH", 0, alphaint,
|
|
|
+ "INSQH", 0, alphaint,
|
|
|
+ "MSKBL", 0, alphaint,
|
|
|
+ "MSKWL", 0, alphaint,
|
|
|
+ "MSKLL", 0, alphaint,
|
|
|
+ "MSKQL", 0, alphaint,
|
|
|
+ "MSKWH", 0, alphaint,
|
|
|
+ "MSKLH", 0, alphaint,
|
|
|
+ "MSKQH", 0, alphaint,
|
|
|
+ "ZAP", 0, alphaint,
|
|
|
+ "ZAPNOT", 0, alphaint,
|
|
|
+};
|
|
|
+
|
|
|
+static void
|
|
|
+format(char *mnemonic, Instr *i, char *f)
|
|
|
+{
|
|
|
+ if (mnemonic)
|
|
|
+ format(0, i, mnemonic);
|
|
|
+ if (f == 0)
|
|
|
+ return;
|
|
|
+ if (mnemonic)
|
|
|
+ if (i->curr < i->end)
|
|
|
+ *i->curr++ = '\t';
|
|
|
+ for ( ; *f && i->curr < i->end; f++) {
|
|
|
+ if (*f != '%') {
|
|
|
+ *i->curr++ = *f;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ switch (*++f) {
|
|
|
+
|
|
|
+ case 'a':
|
|
|
+ bprint(i, "%d", i->ra);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ bprint(i, "%d", i->rb);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'c':
|
|
|
+ bprint(i, "%d", i->rc);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'v':
|
|
|
+ if (i->islit)
|
|
|
+ bprint(i, "$%ux", i->literal);
|
|
|
+ else
|
|
|
+ bprint(i, "R%d", i->rb);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'l':
|
|
|
+ bprint(i, "%lx(R%d)", i->mem, i->rb);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'i':
|
|
|
+ bprint(i, "$%lx", i->mem);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'B':
|
|
|
+ i->curr += symoff(i->curr, i->end-i->curr,
|
|
|
+ (i->branch<<2)+i->addr+4, CANY);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'w':
|
|
|
+ bprint(i, "[%lux]", i->w0);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '\0':
|
|
|
+ *i->curr++ = '%';
|
|
|
+ return;
|
|
|
+
|
|
|
+ default:
|
|
|
+ bprint(i, "%%%c", *f);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ *i->curr = 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+printins(Map *map, uvlong pc, char *buf, int n)
|
|
|
+{
|
|
|
+ Instr i;
|
|
|
+ Opcode *o;
|
|
|
+ uchar op;
|
|
|
+
|
|
|
+ i.curr = buf;
|
|
|
+ i.end = buf+n-1;
|
|
|
+ mymap = map;
|
|
|
+ if (mkinstr(pc, &i) < 0)
|
|
|
+ return -1;
|
|
|
+ switch (i.op) {
|
|
|
+
|
|
|
+ case 0x10: /* INTA */
|
|
|
+ o = arithopcodes;
|
|
|
+ op = amap[i.function];
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 0x11: /* INTL */
|
|
|
+ o = logicalopcodes;
|
|
|
+ op = lmap[i.function];
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 0x12: /* INTS */
|
|
|
+ o = shiftopcodes;
|
|
|
+ op = smap[i.function];
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 0x16: /* FLTI */
|
|
|
+ o = ieeeopcodes;
|
|
|
+ op = i.fpfn;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 0x17: /* FLTL */
|
|
|
+ o = fpopcodes;
|
|
|
+ op = i.fpfn;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ o = opcodes;
|
|
|
+ op = i.op;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (o[op].f)
|
|
|
+ (*o[op].f)(&o[op], &i);
|
|
|
+ else
|
|
|
+ format(o[op].mnemonic, &i, o[op].ken);
|
|
|
+ return i.size*4;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+alphainst(Map *map, uvlong pc, char modifier, char *buf, int n)
|
|
|
+{
|
|
|
+ USED(modifier);
|
|
|
+ return printins(map, pc, buf, n);
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+alphadas(Map *map, uvlong pc, char *buf, int n)
|
|
|
+{
|
|
|
+ Instr i;
|
|
|
+
|
|
|
+ i.curr = buf;
|
|
|
+ i.end = buf+n;
|
|
|
+ mymap = map;
|
|
|
+ if (mkinstr(pc, &i) < 0)
|
|
|
+ return -1;
|
|
|
+ if (i.end-i.curr > 8)
|
|
|
+ i.curr = _hexify(buf, i.w0, 7);
|
|
|
+ if (i.size == 2 && i.end-i.curr > 9) {
|
|
|
+ *i.curr++ = ' ';
|
|
|
+ i.curr = _hexify(i.curr, i.w1, 7);
|
|
|
+ }
|
|
|
+ *i.curr = 0;
|
|
|
+ return i.size*4;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+alphainstlen(Map *map, uvlong pc)
|
|
|
+{
|
|
|
+ Instr i;
|
|
|
+
|
|
|
+ mymap = map;
|
|
|
+ if (mkinstr(pc, &i) < 0)
|
|
|
+ return -1;
|
|
|
+ return i.size*4;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+alphafoll(Map *map, uvlong pc, Rgetter rget, uvlong *foll)
|
|
|
+{
|
|
|
+ char buf[8];
|
|
|
+ Instr i;
|
|
|
+
|
|
|
+ mymap = map;
|
|
|
+ if (mkinstr(pc, &i) < 0)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ switch(i.op) {
|
|
|
+ case 0x1A: /* JMP/JSR/RET */
|
|
|
+ sprint(buf, "R%d", i.rb);
|
|
|
+ foll[0] = (*rget)(map, buf);
|
|
|
+ return 1;
|
|
|
+ case 0x30: /* BR */
|
|
|
+ case 0x34: /* BSR */
|
|
|
+ foll[0] = pc+4 + (i.branch<<2);
|
|
|
+ return 1;
|
|
|
+ default:
|
|
|
+ if (i.op > 0x30) { /* cond */
|
|
|
+ foll[0] = pc+4;
|
|
|
+ foll[1] = pc+4 + (i.branch<<2);
|
|
|
+ return 2;
|
|
|
+ }
|
|
|
+ foll[0] = pc+i.size*4;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+}
|
David du Colombier