harvey/sys/src/libmach/7db.c

#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*, ulong, Rgetter, ulong*);
static	int	alphainst(Map*, ulong, char, char*, int);
static	int	alphadas(Map*, ulong, char*, int);
static	int	alphainstlen(Map*, ulong);
/*
 *	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 {
	ulong 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(ulong pc, Instr *i)
{
	long 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(ulong 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;
}

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)", r, i->ra);
		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, "$%lx", 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, ulong 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, ulong pc, char modifier, char *buf, int n)
{
	USED(modifier);
	return printins(map, pc, buf, n);
}

static int
alphadas(Map *map, ulong 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, ulong pc)
{
	Instr i;

	mymap = map;
	if (mkinstr(pc, &i) < 0)
		return -1;
	return i.size*4;
}

static int
alphafoll(Map *map, ulong pc, Rgetter rget, ulong *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;
	}
}