20060303

51 files changed, 16323 insertions, 0 deletions

diff --git a/utils/libmach/2.c b/utils/libmach/2.c
new file mode 100644
index 00000000..2b1010f4
--- /dev/null
+++ b/utils/libmach/2.c
@@ -0,0 +1,85 @@
+/*
+ * 68020 definition
+ */
+#include <lib9.h>
+#include "ureg2.h"
+#include <bio.h>
+#include "mach.h"
+
+#define	MAXREG	0
+#define	MINREG	0
+
+#define	REGOFF(x)	(ulong)(&((struct Ureg *) 0)->x)
+
+#define	VO	REGOFF(vo)		/* vo, 2 bytes */
+#define	SR	REGOFF(sr)		/* sr, 2 bytes */
+#define	R0	REGOFF(r0)
+#define	PC	REGOFF(pc)
+#define	DBMAGIC	REGOFF(magic)
+#define	SP	REGOFF(usp)
+
+#define	REGSIZE		(R0+4)
+#define	FCTL(x)		(REGSIZE+(x)*4)
+#define	FREG(x)		(FCTL(3)+(x)*12)
+#define	FPREGSIZE	(11*12)
+
+/*
+ *	68020 register set
+ */
+Reglist m68020reglist[] = {
+	{"VO",		VO,		RINT,	'x'},
+	{"SR",		SR,		RINT,	'x'},
+	{"MAGIC",	DBMAGIC,	RINT,	'X'},
+	{"PC",		PC,		RINT,	'X'},
+	{"A7",		SP,		RINT,	'X'},
+	{"KSP",		REGOFF(sp),	RINT,	'X'},
+	{"A6",		REGOFF(a6),	RINT,	'X'},
+	{"A5",		REGOFF(a5),	RINT,	'X'},
+	{"A4",		REGOFF(a4),	RINT,	'X'},
+	{"A3",		REGOFF(a3),	RINT,	'X'},
+	{"A2",		REGOFF(a2),	RINT,	'X'},
+	{"A1",		REGOFF(a1),	RINT,	'X'},
+	{"A0",		REGOFF(a0),	RINT,	'X'},
+	{"R7",		REGOFF(r7),	RINT,	'X'},
+	{"R6",		REGOFF(r6),	RINT,	'X'},
+	{"R5",		REGOFF(r5),	RINT,	'X'},
+	{"R4",		REGOFF(r4),	RINT,	'X'},
+	{"R3",		REGOFF(r3),	RINT,	'X'},
+	{"R2",		REGOFF(r2),	RINT,	'X'},
+	{"R1",		REGOFF(r1),	RINT,	'X'},
+	{"R0",		REGOFF(r0),	RINT,	'X'},
+	{"FPCR",	FCTL(0),	RFLT,	'X'},
+	{"FPSR",	FCTL(1),	RFLT,	'X'},
+	{"FPIAR",	FCTL(2),	RFLT,	'X'},
+	{"F0",		FREG(0),	RFLT,	'8'},
+	{"F1",		FREG(1),	RFLT,	'8'},
+	{"F2",		FREG(2),	RFLT,	'8'},
+	{"F3",		FREG(3),	RFLT,	'8'},
+	{"F4",		FREG(4),	RFLT,	'8'},
+	{"F5",		FREG(5),	RFLT,	'8'},
+	{"F6",		FREG(6),	RFLT,	'8'},
+	{"F7",		FREG(7),	RFLT,	'8'},
+	{0}
+};
+
+Mach m68020 =
+{
+	"68020",
+	M68020,		/* machine type */
+	m68020reglist,	/* register list */
+	REGSIZE,	/* number of bytes in reg set */
+	FPREGSIZE,	/* number of bytes in fp reg set */
+	"PC",
+	"A7",
+	0,		/* link register */
+	"a6base",	/* static base register name */
+	0,		/* value */
+	0x2000,		/* page size */
+	0x80000000,	/* kernel base */
+	0,		/* kernel text mask */
+	2,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/2db.c b/utils/libmach/2db.c
new file mode 100644
index 00000000..5aa61fd3
--- /dev/null
+++ b/utils/libmach/2db.c
@@ -0,0 +1,2084 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+/*
+ * 68020-specific debugger interface
+ */
+
+static	char	*m68020excep(Map*, Rgetter);
+
+static	int	m68020foll(Map*, ulong, Rgetter, ulong*);
+static	int	m68020inst(Map*, ulong, char, char*, int);
+static	int	m68020das(Map*, ulong, char*, int);
+static	int	m68020instlen(Map*, ulong);
+
+Machdata m68020mach =
+{
+	{0x48,0x48,0,0},	/* break point #0 instr. */
+	2,			/* size of break point instr. */
+
+	beswab,			/* convert short to local byte order */
+	beswal,			/* convert long to local byte order */
+	beswav,			/* convert vlong to local byte order */
+	cisctrace,		/* C traceback */
+	ciscframe,		/* frame finder */
+	m68020excep,		/* print exception */
+	0,			/* breakpoint fixup */
+	beieeesftos,
+	beieeedftos,
+	m68020foll,		/* follow-set calculation */
+	m68020inst,		/* print instruction */
+	m68020das,		/* dissembler */
+	m68020instlen,		/* instruction size */
+};
+
+/*
+ * 68020 exception frames
+ */
+
+#define BPTTRAP	4		/* breakpoint gives illegal inst */
+
+static char * excep[] = {
+	0,			/* 0 */
+	0,			/* 1 */
+	"bus error",		/* 2 */
+	"address error",	/* 3 */
+	"illegal instruction",	/* 4 */
+	"zero divide",		/* 5 */
+	"CHK",			/* 6 */
+	"TRAP",			/* 7 */
+	"privilege violation",	/* 8 */
+	"Trace",		/* 9 */
+	"line 1010",		/* 10 */
+	"line 1011",		/* 11 */
+	0,			/* 12 */
+	"coprocessor protocol violation",	/* 13 */
+	0,0,0,0,0,0,0,0,0,0,	/* 14-23 */
+	"spurious",		/* 24 */
+	"incon",		/* 25 */
+	"tac",			/* 26 */
+	"auto 3",		/* 27 */
+	"clock",		/* 28 */
+	"auto 5",		/* 29 */
+	"parity",		/* 30 */
+	"mouse",		/* 31 */
+	"system call",		/* 32 */
+	"system call 1",	/* 33 */
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/* 34-47 */
+	"FPCP branch",		/* 48 */
+	"FPCP inexact",		/* 49 */
+	"FPCP zero div",	/* 50 */
+	"FPCP underflow",	/* 51 */
+	"FPCP operand err",	/* 52 */
+	"FPCP overflow",	/* 53 */
+	"FPCP signal NAN",	/* 54 */
+};
+
+static int m68020vec;
+static
+struct ftype{
+	short	fmt;
+	short	len;
+	char	*name;
+} ftype[] = {		/* section 6.5.7 page 6-24 */
+	{  0,  4*2, "Short Format" },
+	{  1,  4*2, "Throwaway" },
+	{  2,  6*2, "Instruction Exception" },
+	{  3,  6*2, "MC68040 Floating Point Exception" },
+	{  8, 29*2, "MC68010 Bus Fault" },
+	{  7, 30*2, "MC68040 Bus Fault" },
+	{  9, 10*2, "Coprocessor mid-Instruction" },
+	{ 10, 16*2, "MC68020 Short Bus Fault" },
+	{ 11, 46*2, "MC68020 Long Bus Fault" },
+	{  0,    0, 0 }
+};
+
+static int
+m68020ufix(Map *map)
+{
+	struct ftype *ft;
+	int i, size, vec;
+	ulong efl[2], stktop;
+	uchar *ef=(uchar*)efl;
+	long l;
+	short fvo;
+
+		/* The kernel proc pointer on a 68020 is always
+		 * at #8xxxxxxx; on the 68040 NeXT, the address
+		 * is always #04xxxxxx.  the sun3 port at sydney
+		 * uses 0xf8xxxxxx to 0xffxxxxxx.
+		 */
+	m68020vec = 0;
+
+	if (get4(map, mach->kbase, (&l)) < 0)
+		return -1;
+	if ((l&0xfc000000) == 0x04000000)	/* if NeXT */
+		size = 30*2;
+	else
+		size = 46*2;		/* 68020 */
+	USED(size);	/* kept because it might be re-used later */
+
+	stktop = mach->kbase+mach->pgsize;
+	for(i=3; i<100; i++){
+		if (get1(map, stktop-i*4, (uchar*)&l, 4)< 0)
+			return -1;
+
+		if(machdata->swal(l) == 0xBADC0C0A){
+			if (get1(map, stktop-(i-1)*4, (uchar *)&efl[0], 4) < 0)
+				return -1;
+			if (get1(map, stktop-(i-2)*4, (uchar *)&efl[1], 4) < 0)
+				return -1;
+			fvo = (ef[6]<<8)|ef[7];
+			vec = fvo & 0xfff;
+			vec >>= 2;
+			if(vec >= 256)
+				continue;
+
+			for(ft=ftype; ft->name; ft++) {
+				if(ft->fmt == ((fvo>>12) & 0xF)){
+					m68020vec = vec;
+					return 1;
+				}
+			}
+			break;
+		}
+	}
+	return -1;
+}
+
+static char *
+m68020excep(Map *map, Rgetter rget)
+{
+	ulong pc;
+	uchar buf[4];
+
+	if (m68020ufix(map) < 0)
+		return "bad exception frame";
+
+	if(excep[m68020vec] == 0)
+		return "bad exeception type";
+
+	if(m68020vec == BPTTRAP) {
+		pc = (*rget)(map, "PC");
+		if (get1(map, pc, buf, machdata->bpsize) > 0)
+		if(memcmp(buf, machdata->bpinst, machdata->bpsize) == 0)
+			return "breakpoint";
+	}
+	return excep[m68020vec];
+}
+	/* 68020 Disassembler and related functions */
+/*
+not supported: cpBcc, cpDBcc, cpGEN, cpScc, cpTRAPcc, cpRESTORE, cpSAVE 
+
+opcode:					1 1 1 1 1 1
+					5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+%y - register number						  x x x
+%f - trap vector						  x x x
+%e - destination eff addr				    x x x x x x
+%p - conditional predicate				    x x x x x x
+%s - size code						x x
+%C - cache code						x x
+%E - source eff addr.				x x x x x x
+%d - direction bit				      x
+%c - condition code				x x x x
+%x - register number				x x x
+%b - shift count				x x x
+%q - daffy 3-bit quick operand or shift count	x x x
+%i - immediate operand <varies>
+%t - offset(PC) <varies>
+
+word 1:					1 1 1 1 1 1
+					5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+%a - register number						  x x x
+%w - bit field width					      x x x x x
+%L - MMU function code (SFC/DFC/D%a/#[0-3])		      x x x x x
+%P - conditional predicate				    x x x x x x
+%k - k factor						  x x x x x x x
+%m - register mask					x x x x x x x x
+%N - control register id			x x x x x x x x x x x x
+%j - (Dq != Dr) ? Dq:Dr : Dr		  x x x			  x x x
+%K - dynamic k register					  x x x
+%h - register number					x x x
+%I - MMU function code mask			      x x x x
+%o - bit field offset				  x x x x x
+%u - register number				      x x x
+%D - float dest reg				    x x x
+%F - (fdr==fsr) ? "F%D" :"F%B,F%D" 	   x x x x x x
+%S - float source type			      x x x
+%B - float source register		      x x x
+%Z - ATC level number			      x x x
+%H - MMU register			    x x x x
+%r - register type/number		x x x x
+
+word 2:					1 1 1 1 1 1
+					5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+%A - register number						  x x x
+%U - register number				      x x x
+%R - register type,number		x x x x
+
+-----------------------------------------------------------------------------
+
+%a	-	register [word 1: 0-2]
+%c	-	condition code [opcode: 8-11]
+%d	-	direction [opcode: 8]
+%e	-	destination effective address [opcode: 0-5]
+%f	-	trap vector [opcode: 0-3]
+%h	-	register [word 1: 5-7]
+%i	-	immediate operand (1, 2, or 4 bytes)
+%j	-	Dq:Dr if Dq != Dr; else Dr => Dr [word 1: 0-2] Dq [word 1: 12-14]
+%k	-	k factor [word 1: 0-6]
+%m	-	register mask [word 1: 0-7]
+%o	-	bit field offset [word 1: 6-10]
+%p	-	conditional predicate [opcode: 0-5]
+%q	-	daffy 3-bit quick operand [opcode: 9-11]
+%r	-	register type, [word 1: 15], register [word 1: 12-14]
+%s	-	size [opcode: 6-7]
+%t	-	offset beyond pc (text address) (2 or 4 bytes)
+%u	-	register [word 1: 6-8]
+%w	-	bit field width [word 1: 0-4]
+%x	-	register [opcode: 9-11]
+%y	-	register [opcode: 0-2]
+%A	-	register [word 2: 0-2]
+%B	-	float source register [word 1: 10-12]
+%C	-	cache identifier [opcode: 6-7] (IC, DC, or BC)
+%D	-	float dest reg [word 1: 7-9]
+%E	-	dest effective address [opcode: 6-11]
+%F	-	float dest reg == float src reg => "F%D"; else "F%B,F%D"
+%H	-	MMU reg [word 1: 10-13] (see above & p 4-53/54)
+%I	-	MMU function code mask [word 1: 5-8]
+%K	-	dynamic k factor register [word 1: 4-6]
+%L	-	MMU function code [word 1: 0-4] (SFC, DFC, D%a, or #[0-3])
+%N	-	control register [word 1: 0-11]
+%P	-	conditional predicate [word 1: 0-5]
+%R	-	register type, [word 2: 15], register [word 2: 12-14]
+%S	-	float source type code [word 1: 10-12]
+%U	-	register [word 2: 6-8]
+%Z	-	ATC level number [word 1: 10-12]
+%1	-	Special case: EA as second operand
+*/
+	/* Operand classes */
+enum {
+	EAPI = 1,	/* extended address: pre decrement only */
+	EACA,		/* extended address: control alterable */
+	EACAD,		/* extended address: control alterable or Dreg */
+	EACAPI,		/* extended address: control alterable or post-incr */
+	EACAPD,		/* extended address: control alterable or pre-decr */
+	EAMA,		/* extended address: memory alterable */
+	EADA,		/* extended address: data alterable */
+	EAA,		/* extended address: alterable */
+	EAC,		/* extended address: control addressing */
+	EACPI,		/* extended address: control addressing or post-incr */
+	EACD,		/* extended address: control addressing or Dreg */
+	EAD,		/* extended address: data addressing */
+	EAM,		/* extended address: memory addressing */
+	EAM_B,		/* EAM with byte immediate data */
+	EADI,		/* extended address: data addressing or immediate */
+	EADI_L,		/* EADI with long immediate data */
+	EADI_W,		/* EADI with word immediate data */
+	EAALL,		/* extended address: all modes */
+	EAALL_L,	/* EAALL with long immediate data */
+	EAALL_W,	/* EAALL with word immediate data */
+	EAALL_B,	/* EAALL with byte immediate date */
+		/* special codes not directly used for validation */
+	EAFLT,		/* extended address: EADI for B, W, L, or S; else EAM */
+	EADDA,		/* destination extended address: EADA */
+	BREAC,		/* EAC operand for JMP or CALL */
+	OP8,		/* low 8 bits of op word */
+	I8,		/* low 8-bits of first extension word */
+	I16,		/* 16 bits in first extension word */
+	I32,		/* 32 bits in first and second extension words */
+	IV,		/* 8, 16 or 32 bit data in first & 2nd extension words */
+	C16,		/* CAS2 16 bit immediate with bits 9-11 & 3-5 zero */
+	BR8,		/* 8 bits in op word or 16 or 32 bits in extension words
+				branch instruction format (p. 2-25) */
+	BR16,		/* 16-bit branch displacement */
+	BR32,		/* 32-bit branch displacement */
+	STACK,		/* return PC on stack - follow set only */
+};
+		/* validation bit masks for various EA classes */
+enum {
+	Dn	= 0x0001,	/* Data register */
+	An	= 0x0002,	/* Address register */
+	Ind	= 0x0004,	/* Address register indirect */
+	Pinc	= 0x0008,	/* Address register indirect post-increment */
+	Pdec	= 0x0010,	/* Address register indirect pre-decrement */
+	Bdisp	= 0x0020,	/* Base/Displacement in all its forms */
+	PCrel	= 0x0040,	/* PC relative addressing in all its forms */
+	Imm	= 0x0080,	/* Immediate data */
+	Abs	= 0x0100,	/* Absolute */
+};
+	/* EA validation table indexed by operand class number */
+
+static	short	validea[] =
+{
+	0,						/* none */
+	Pdec,						/* EAPI */
+	Abs|Bdisp|Ind,					/* EACA */
+	Abs|Bdisp|Ind|Dn,				/* EACAD */
+	Abs|Bdisp|Pinc|Ind,				/* EACAPI */
+	Abs|Bdisp|Pdec|Ind,				/* EACAPD */
+	Abs|Bdisp|Pdec|Pinc|Ind,			/* EAMA */
+	Abs|Bdisp|Pdec|Pinc|Ind|Dn,			/* EADA */
+	Abs|Bdisp|Pdec|Pinc|Ind|An|Dn,			/* EAA */
+	Abs|PCrel|Bdisp|Ind,				/* EAC */
+	Abs|PCrel|Bdisp|Pinc|Ind,			/* EACPI */
+	Abs|PCrel|Bdisp|Ind|Dn,				/* EACD */
+	Abs|PCrel|Bdisp|Pdec|Pinc|Ind|Dn,		/* EAD */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind,		/* EAM */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind,		/* EAM_B */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|Dn,		/* EADI */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|Dn,		/* EADI_L */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|Dn,		/* EADI_W */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|An|Dn,	/* EAALL */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|An|Dn,	/* EAALL_L */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|An|Dn,	/* EAALL_W */
+	Abs|Imm|PCrel|Bdisp|Pdec|Pinc|Ind|An|Dn,	/* EAALL_B */
+};
+	/* EA types */
+enum
+{
+	Dreg,		/* Dn */
+	Areg,		/* An */
+	AInd,		/* (An) */
+	APdec,		/* -(An) */
+	APinc,		/* (An)+ */
+	ADisp,		/* Displacement beyond (An) */
+	BXD,		/* Base, Index, Displacement */
+	PDisp,		/* Displacement beyond PC */
+	PXD,		/* PC, Index, Displacement */
+	ABS,		/* absolute */
+	IMM,		/* immediate */
+	IREAL,		/* single precision real immediate */
+	IEXT,		/* extended precision real immediate */
+	IPACK,		/* packed real immediate */
+	IDBL,		/* double precision real immediate */
+};
+	
+typedef	struct optable	Optable;
+typedef	struct operand	Operand;
+typedef	struct inst	Inst;
+
+struct optable
+{
+	ushort	opcode;
+	ushort	mask0;
+	ushort	op2;
+	ushort	mask1;
+	char	opdata[2];
+	char	*format;
+};
+
+struct	operand
+{
+	int	eatype;
+	short	ext;
+	union {
+		long	immediate;	/* sign-extended integer byte/word/long */
+		struct	{		/* index mode displacements */
+			long	disp;
+			long	outer;
+		} s0;
+		char	floater[24];	/* floating point immediates */
+	} u0;
+};
+
+struct	inst
+{
+	int	n;		/* # bytes in instruction */
+	ulong	addr;		/* addr of start of instruction */
+	ushort	raw[4+12];	/* longest instruction: 24 byte packed immediate */
+	Operand	and[2];
+	char	*end;		/* end of print buffer */
+	char	*curr;		/* current fill point in buffer */
+	char	*errmsg;
+};
+	/* class 0: bit field, MOVEP & immediate instructions */
+static Optable t0[] = {
+{ 0x003c, 0xffff, 0x0000, 0xff00, {I8},		"ORB	%i,CCR" },
+{ 0x007c, 0xffff, 0x0000, 0x0000, {I16},	"ORW	%i,SR" },
+{ 0x023c, 0xffff, 0x0000, 0xff00, {I8},		"ANDB	%i,CCR" },
+{ 0x027c, 0xffff, 0x0000, 0x0000, {I16},	"ANDW	%i,SR" },
+{ 0x0a3c, 0xffff, 0x0000, 0xff00, {I8},		"EORB	%i,CCR" },
+{ 0x0a7c, 0xffff, 0x0000, 0x0000, {I16},	"EORW	%i,SR" },
+{ 0x0cfc, 0xffff, 0x0000, 0x0000, {C16,C16},	"CAS2W	R%a:R%A,R%u:R%U,(%r):(%R)"} ,
+{ 0x0efc, 0xffff, 0x0000, 0x0000, {C16,C16},	"CAS2L	R%a:R%A,R%u:R%U,(%r):(%R)"} ,
+
+{ 0x06c0, 0xfff8, 0x0000, 0x0000, {0},		"RTM	R%y" },
+{ 0x06c8, 0xfff8, 0x0000, 0x0000, {0},		"RTM	A%y" },
+{ 0x0800, 0xfff8, 0x0000, 0x0000, {I16},	"BTSTL	%i,R%y" },
+{ 0x0840, 0xfff8, 0x0000, 0x0000, {I16},	"BCHGL	%i,R%y" },
+{ 0x0880, 0xfff8, 0x0000, 0x0000, {I16},	"BCLRL	%i,R%y" },
+
+{ 0x00c0, 0xffc0, 0x0000, 0x0fff, {EAC},	"CMP2B	%e,%r" },
+{ 0x00c0, 0xffc0, 0x0800, 0x0fff, {EAC},	"CHK2B	%e,%r" },
+{ 0x02c0, 0xffc0, 0x0000, 0x0fff, {EAC},	"CMP2W	%e,%r" },
+{ 0x02c0, 0xffc0, 0x0800, 0x0fff, {EAC},	"CHK2W	%e,%r" },
+{ 0x04c0, 0xffc0, 0x0000, 0x0fff, {EAC},	"CMP2L	%e,%r" },
+{ 0x04c0, 0xffc0, 0x0800, 0x0fff, {EAC},	"CHK2L	%e,%r" },
+{ 0x06c0, 0xffc0, 0x0000, 0x0000, {I16, BREAC},	"CALLM	%i,%e" },
+{ 0x0800, 0xffc0, 0x0000, 0x0000, {I16, EAD},	"BTSTB	%i,%e" },
+{ 0x0840, 0xffc0, 0x0000, 0x0000, {I16, EADA},	"BCHG	%i,%e" },
+{ 0x0880, 0xffc0, 0x0000, 0x0000, {I16, EADA},	"BCLR	%i,%e" },
+{ 0x08c0, 0xffc0, 0x0000, 0x0000, {I16, EADA},	"BSET	%i,%e" },
+{ 0x0ac0, 0xffc0, 0x0000, 0xfe38, {EAMA},	"CASB	R%a,R%u,%e" },
+{ 0x0cc0, 0xffc0, 0x0000, 0xfe38, {EAMA},	"CASW	R%a,R%u,%e" },
+{ 0x0ec0, 0xffc0, 0x0000, 0xfe38, {EAMA},	"CASL	R%a,R%u,%e" },
+
+{ 0x0000, 0xff00, 0x0000, 0x0000, {IV, EADA},	"OR%s	%i,%e" },
+{ 0x0200, 0xff00, 0x0000, 0x0000, {IV, EADA},	"AND%s	%i,%e" },
+{ 0x0400, 0xff00, 0x0000, 0x0000, {IV, EADA},	"SUB%s	%i,%e" },
+{ 0x0600, 0xff00, 0x0000, 0x0000, {IV, EADA},	"ADD%s	%i,%e" },
+{ 0x0a00, 0xff00, 0x0000, 0x0000, {IV, EADA},	"EOR%s	%i,%e" },
+{ 0x0c00, 0xff00, 0x0000, 0x0000, {IV, EAD},	"CMP%s	%i,%e" },
+{ 0x0e00, 0xff00, 0x0000, 0x0800, {EAMA},	"MOVES%s	%e,%r" },
+{ 0x0e00, 0xff00, 0x0800, 0x0800, {EAMA},	"MOVES%s	%r,%e" },
+
+{ 0x0108, 0xf1f8, 0x0000, 0x0000, {I16},	"MOVEPW	(%i,A%y),R%x" },
+{ 0x0148, 0xf1f8, 0x0000, 0x0000, {I16},	"MOVEPL	(%i,A%y),R%x" },
+{ 0x0188, 0xf1f8, 0x0000, 0x0000, {I16},	"MOVEPW	R%x,(%i,A%y)" },
+{ 0x01c8, 0xf1f8, 0x0000, 0x0000, {I16},	"MOVEPL	R%x,(%i,A%y)" },
+{ 0x0100, 0xf1f8, 0x0000, 0x0000, {0},		"BTSTL	R%x,R%y" },
+{ 0x0140, 0xf1f8, 0x0000, 0x0000, {0},		"BCHGL	R%x,R%y" },
+{ 0x0180, 0xf1f8, 0x0000, 0x0000, {0},		"BCLRL	R%x,R%y" },
+{ 0x01c0, 0xf1f8, 0x0000, 0x0000, {0},		"BSET	R%x,R%y" },
+
+{ 0x0100, 0xf1c0, 0x0000, 0x0000, {EAM_B},	"BTSTB	R%x,%e" },
+{ 0x0140, 0xf1c0, 0x0000, 0x0000, {EAMA},	"BCHG	R%x,%e" },
+{ 0x0180, 0xf1c0, 0x0000, 0x0000, {EAMA},	"BCLR	R%x,%e" },
+{ 0x01c0, 0xf1c0, 0x0000, 0x0000, {EAMA},	"BSET	R%x,%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 1: move byte */
+static Optable t1[] = {
+{ 0x1000, 0xf000, 0x0000, 0x0000, {EAALL_B,EADDA},"MOVB	%e,%E" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 2: move long */
+static Optable t2[] = {
+{ 0x2040, 0xf1c0, 0x0000, 0x0000, {EAALL_L},	  "MOVL	%e,A%x" },
+
+{ 0x2000, 0xf000, 0x0000, 0x0000, {EAALL_L,EADDA},"MOVL	%e,%E" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 3: move word */
+static Optable t3[] = {
+{ 0x3040, 0xf1c0, 0x0000, 0x0000, {EAALL_W},	  "MOVW	%e,A%x" },
+
+{ 0x3000, 0xf000, 0x0000, 0x0000, {EAALL_W,EADDA},"MOVW	%e,%E" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 4: miscellaneous */
+static Optable t4[] = {
+{ 0x4e75, 0xffff, 0x0000, 0x0000, {STACK},	"RTS" },
+{ 0x4e77, 0xffff, 0x0000, 0x0000, {STACK},	"RTR" },
+{ 0x4afc, 0xffff, 0x0000, 0x0000, {0},		"ILLEGAL" },
+{ 0x4e71, 0xffff, 0x0000, 0x0000, {0},		"NOP" },
+{ 0x4e74, 0xffff, 0x0000, 0x0000, {I16, STACK},	"RTD	%i" },
+{ 0x4e76, 0xffff, 0x0000, 0x0000, {0},		"TRAPV" },
+{ 0x4e70, 0xffff, 0x0000, 0x0000, {0},		"RESET" },
+{ 0x4e72, 0xffff, 0x0000, 0x0000, {I16},	"STOP	%i" },
+{ 0x4e73, 0xffff, 0x0000, 0x0000, {0},		"RTE" },
+{ 0x4e7a, 0xffff, 0x0000, 0x0000, {I16},	"MOVEL	%N,%r" },
+{ 0x4e7b, 0xffff, 0x0000, 0x0000, {I16},	"MOVEL	%r,%N" },
+
+{ 0x4808, 0xfff8, 0x0000, 0x0000, {I32},	"LINKL	A%y,%i" },
+{ 0x4840, 0xfff8, 0x0000, 0x0000, {0},		"SWAPW	R%y" },
+{ 0x4848, 0xfff8, 0x0000, 0x0000, {0},		"BKPT	#%y" },
+{ 0x4880, 0xfff8, 0x0000, 0x0000, {0},		"EXTW	R%y" },
+{ 0x48C0, 0xfff8, 0x0000, 0x0000, {0},		"EXTL	R%y" },
+{ 0x49C0, 0xfff8, 0x0000, 0x0000, {0},		"EXTBL	R%y" },
+{ 0x4e50, 0xfff8, 0x0000, 0x0000, {I16},	"LINKW	A%y,%i" },
+{ 0x4e58, 0xfff8, 0x0000, 0x0000, {0},		"UNLK	A%y" },
+{ 0x4e60, 0xfff8, 0x0000, 0x0000, {0},		"MOVEL	(A%y),USP" },
+{ 0x4e68, 0xfff8, 0x0000, 0x0000, {0},		"MOVEL	USP,(A%y)" },
+
+{ 0x4e40, 0xfff0, 0x0000, 0x0000, {0},		"SYS	%f" },
+
+{ 0x40c0, 0xffc0, 0x0000, 0x0000, {EADA},	"MOVW	SR,%e" },
+{ 0x42c0, 0xffc0, 0x0000, 0x0000, {EADA},	"MOVW	CCR,%e" },
+{ 0x44c0, 0xffc0, 0x0000, 0x0000, {EADI_W},	"MOVW	%e,CCR" },
+{ 0x46c0, 0xffc0, 0x0000, 0x0000, {EADI_W},	"MOVW	%e,SR" },
+{ 0x4800, 0xffc0, 0x0000, 0x0000, {EADA},	"NBCDB	%e" },
+{ 0x4840, 0xffc0, 0x0000, 0x0000, {EAC},	"PEA	%e" },
+{ 0x4880, 0xffc0, 0x0000, 0x0000, {I16, EACAPD},"MOVEMW	%i,%e" },
+{ 0x48c0, 0xffc0, 0x0000, 0x0000, {I16, EACAPD},"MOVEML	%i,%e" },
+{ 0x4ac0, 0xffc0, 0x0000, 0x0000, {EADA},	"TAS	%e" },
+{ 0x4a00, 0xffc0, 0x0000, 0x0000, {EAD},	"TSTB	%e" },
+{ 0x4c00, 0xffc0, 0x0000, 0x8ff8, {EADI_L},	"MULUL	%e,%r" },
+{ 0x4c00, 0xffc0, 0x0400, 0x8ff8, {EADI_L},	"MULUL	%e,R%a:%r" },
+{ 0x4c00, 0xffc0, 0x0800, 0x8ff8, {EADI_L},	"MULSL	%e,%r" },
+{ 0x4c00, 0xffc0, 0x0c00, 0x8ff8, {EADI_L},	"MULSL	%e,R%a:%r" },
+{ 0x4c40, 0xffc0, 0x0000, 0x8ff8, {EADI_L},	"DIVUL	%e,%j" },
+{ 0x4c40, 0xffc0, 0x0400, 0x8ff8, {EADI_L},	"DIVUD	%e,%r:R%a" },
+{ 0x4c40, 0xffc0, 0x0800, 0x8ff8, {EADI_L},	"DIVSL	%e,%j" },
+{ 0x4c40, 0xffc0, 0x0c00, 0x8ff8, {EADI_L},	"DIVSD	%e,%r:R%a" },
+{ 0x4c80, 0xffc0, 0x0000, 0x0000, {I16, EACPI}, "MOVEMW	%1,%i" },
+{ 0x4cc0, 0xffc0, 0x0000, 0x0000, {I16, EACPI}, "MOVEML	%1,%i" },
+{ 0x4e80, 0xffc0, 0x0000, 0x0000, {BREAC},	"JSR	%e" },
+{ 0x4ec0, 0xffc0, 0x0000, 0x0000, {BREAC},	"JMP	%e" },
+
+{ 0x4000, 0xff00, 0x0000, 0x0000, {EADA},	"NEGX%s	%e" },
+{ 0x4200, 0xff00, 0x0000, 0x0000, {EADA},	"CLR%s	%e" },
+{ 0x4400, 0xff00, 0x0000, 0x0000, {EADA},	"NEG%s	%e" },
+{ 0x4600, 0xff00, 0x0000, 0x0000, {EADA},	"NOT%s	%e" },
+{ 0x4a00, 0xff00, 0x0000, 0x0000, {EAALL},	"TST%s	%e" },
+
+{ 0x4180, 0xf1c0, 0x0000, 0x0000, {EADI_W},	"CHKW	%e,R%x" },
+{ 0x41c0, 0xf1c0, 0x0000, 0x0000, {EAC},	"LEA	%e,A%x" },
+{ 0x4100, 0xf1c0, 0x0000, 0x0000, {EADI_L},	"CHKL	%e,R%x" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 5:  miscellaneous quick, branch & trap instructions */
+static Optable t5[] = {
+{ 0x5000, 0xf1c0, 0x0000, 0x0000, {EADA},	"ADDB	$Q#%q,%e" },
+{ 0x5100, 0xf1c0, 0x0000, 0x0000, {EADA},	"SUBB	$Q#%q,%e" },
+
+{ 0x50c8, 0xf1f8, 0x0000, 0x0000, {BR16},	"DB%c	R%y,%t" },
+{ 0x51c8, 0xf1f8, 0x0000, 0x0000, {BR16},	"DB%c	R%y,%t" },
+
+{ 0x5000, 0xf1c0, 0x0000, 0x0000, {EAA},	"ADDB	$Q#%q,%e" },
+{ 0x5040, 0xf1c0, 0x0000, 0x0000, {EAA},	"ADDW	$Q#%q,%e" },
+{ 0x5080, 0xf1c0, 0x0000, 0x0000, {EAA},	"ADDL	$Q#%q,%e" },
+{ 0x5100, 0xf1c0, 0x0000, 0x0000, {EAA},	"SUBB	$Q#%q,%e" },
+{ 0x5140, 0xf1c0, 0x0000, 0x0000, {EAA},	"SUBW	$Q#%q,%e" },
+{ 0x5180, 0xf1c0, 0x0000, 0x0000, {EAA},	"SUBL	$Q#%q,%e" },
+
+{ 0x50fa, 0xf0ff, 0x0000, 0x0000, {I16},	"TRAP%cW	%i" },
+{ 0x50fb, 0xf0ff, 0x0000, 0x0000, {I32},	"TRAP%cL	%i" },
+{ 0x50fc, 0xf0ff, 0x0000, 0x0000, {0},		"TRAP%c" },
+
+{ 0x50c0, 0xf0c0, 0x0000, 0x0000, {EADA},	"S%c	%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 6: branch instructions */
+static Optable t6[] = {
+{ 0x6000, 0xff00, 0x0000, 0x0000, {BR8},	"BRA	%t" },
+{ 0x6100, 0xff00, 0x0000, 0x0000, {BR8},	"BSR	%t" },
+{ 0x6000, 0xf000, 0x0000, 0x0000, {BR8},	"B%c	%t" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 7: move quick */
+static Optable t7[] = {
+{ 0x7000, 0xf100, 0x0000, 0x0000, {OP8},	"MOVL	$Q%i,R%x" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 8: BCD operations, DIV, and OR instructions */
+static Optable t8[] = {
+{ 0x8100, 0xf1f8, 0x0000, 0x0000, {0},		"SBCDB	R%y,R%x" },
+{ 0x8108, 0xf1f8, 0x0000, 0x0000, {0},		"SBCDB	-(A%y),-(A%x)" },
+{ 0x8140, 0xf1f8, 0x0000, 0x0000, {I16},	"PACK	R%y,R%x,%i" },
+{ 0x8148, 0xf1f8, 0x0000, 0x0000, {I16},	"PACK	-(A%y),-(A%x),%i" },
+{ 0x8180, 0xf1f8, 0x0000, 0x0000, {I16},	"UNPK	R%y,R%x,%i" },
+{ 0x8188, 0xf1f8, 0x0000, 0x0000, {I16},	"UNPK	-(A%y),-(A%x),%i" },
+
+{ 0x80c0, 0xf1c0, 0x0000, 0x0000, {EADI_W},	"DIVUW	%e,R%x" },
+{ 0x81c0, 0xf1c0, 0x0000, 0x0000, {EADI_W},	"DIVSW	%e,R%x" },
+
+{ 0x8000, 0xf100, 0x0000, 0x0000, {EADI},	"OR%s	%e,R%x" },
+{ 0x8100, 0xf100, 0x0000, 0x0000, {EAMA},	"OR%s	R%x,%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class 9: subtract instruction */
+static Optable t9[] = {
+{ 0x90c0, 0xf1c0, 0x0000, 0x0000, {EAALL_W},	"SUBW	%e,A%x" },
+{ 0x91c0, 0xf1c0, 0x0000, 0x0000, {EAALL_L},	"SUBL	%e,A%x" },
+
+{ 0x9100, 0xf138, 0x0000, 0x0000, {0},		"SUBX%s	R%y,R%x" },
+{ 0x9108, 0xf138, 0x0000, 0x0000, {0},		"SUBX%s	-(A%y),-(A%x)" },
+
+{ 0x9000, 0xf100, 0x0000, 0x0000, {EAALL},	"SUB%s	%e,R%x" },
+{ 0x9100, 0xf100, 0x0000, 0x0000, {EAMA},	"SUB%s	R%x,%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class b: CMP & EOR */
+static Optable tb[] = {
+{ 0xb000, 0xf1c0, 0x0000, 0x0000, {EADI},	"CMPB	R%x,%e" },
+{ 0xb040, 0xf1c0, 0x0000, 0x0000, {EAALL_W},	"CMPW	R%x,%e" },
+{ 0xb080, 0xf1c0, 0x0000, 0x0000, {EAALL_L},	"CMPL	R%x,%e" },
+{ 0xb0c0, 0xf1c0, 0x0000, 0x0000, {EAALL_W},	"CMPW	A%x,%e" },
+{ 0xb1c0, 0xf1c0, 0x0000, 0x0000, {EAALL_L},	"CMPL	A%x,%e" },
+
+{ 0xb108, 0xf138, 0x0000, 0x0000, {0},		"CMP%s	(A%y)+,(A%x)+" },
+
+{ 0xb100, 0xf100, 0x0000, 0x0000, {EADA},	"EOR%s	%e,R%x" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class c: AND, MUL, BCD & Exchange */
+static Optable tc[] = {
+{ 0xc100, 0xf1f8, 0x0000, 0x0000, {0},		"ABCDB	R%y,R%x" },
+{ 0xc108, 0xf1f8, 0x0000, 0x0000, {0},		"ABCDB	-(A%y),-(A%x)" },
+{ 0xc140, 0xf1f8, 0x0000, 0x0000, {0},		"EXG	R%x,R%y" },
+{ 0xc148, 0xf1f8, 0x0000, 0x0000, {0},		"EXG	A%x,A%y" },
+{ 0xc188, 0xf1f8, 0x0000, 0x0000, {0},		"EXG	R%x,A%y" },
+
+{ 0xc0c0, 0xf1c0, 0x0000, 0x0000, {EADI_W},	"MULUW	%e,R%x" },
+{ 0xc1c0, 0xf1c0, 0x0000, 0x0000, {EADI_W},	"MULSW	%e,R%x" },
+
+{ 0xc000, 0xf100, 0x0000, 0x0000, {EADI},	"AND%s	%e,R%x" },
+{ 0xc100, 0xf100, 0x0000, 0x0000, {EAMA},	"AND%s	R%x,%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class d: addition  */
+static Optable td[] = {
+{ 0xd000, 0xf1c0, 0x0000, 0x0000, {EADI},	"ADDB	%e,R%x" },
+{ 0xd0c0, 0xf1c0, 0x0000, 0x0000, {EAALL_W},	"ADDW	%e,A%x" },
+{ 0xd1c0, 0xf1c0, 0x0000, 0x0000, {EAALL_L},	"ADDL	%e,A%x" },
+
+{ 0xd100, 0xf138, 0x0000, 0x0000, {0},		"ADDX%s	R%y,R%x" },
+{ 0xd108, 0xf138, 0x0000, 0x0000, {0},		"ADDX%s	-(A%y),-(A%x)" },
+
+{ 0xd000, 0xf100, 0x0000, 0x0000, {EAALL},	"ADD%s	%e,R%x" },
+{ 0xd100, 0xf100, 0x0000, 0x0000, {EAMA},	"ADD%s	R%x,%e" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class e: shift, rotate, bit field operations */
+static Optable te[] = {
+{ 0xe8c0, 0xffc0, 0x0820, 0xfe38, {EACD},	"BFTST	%e{R%u:R%a}" },
+{ 0xe8c0, 0xffc0, 0x0800, 0xfe20, {EACD},	"BFTST	%e{R%u:%w}" },
+{ 0xe8c0, 0xffc0, 0x0020, 0xf838, {EACD},	"BFTST	%e{%o:R%a}" },
+{ 0xe8c0, 0xffc0, 0x0000, 0xf820, {EACD},	"BFTST	%e{%o:%w}" },
+
+{ 0xe9c0, 0xffc0, 0x0820, 0x8e38, {EACD},	"BFEXTU	%e{R%u:R%a},%r" },
+{ 0xe9c0, 0xffc0, 0x0800, 0x8e20, {EACD},	"BFEXTU	%e{R%u:%w},%r" },
+{ 0xe9c0, 0xffc0, 0x0020, 0x8838, {EACD},	"BFEXTU	%e{%o:R%a},%r" },
+{ 0xe9c0, 0xffc0, 0x0000, 0x8820, {EACD},	"BFEXTU	%e{%o:%w},%r" },
+
+{ 0xeac0, 0xffc0, 0x0820, 0xfe38, {EACAD},	"BFCHG	%e{R%u:R%a}" },
+{ 0xeac0, 0xffc0, 0x0800, 0xfe20, {EACAD},	"BFCHG	%e{R%u:%w}" },
+{ 0xeac0, 0xffc0, 0x0020, 0xf838, {EACAD},	"BFCHG	%e{%o:R%a}" },
+{ 0xeac0, 0xffc0, 0x0000, 0xf820, {EACAD},	"BFCHG	%e{%o:%w}" },
+
+{ 0xebc0, 0xffc0, 0x0820, 0x8e38, {EACD},	"BFEXTS	%e{R%u:R%a},%r" },
+{ 0xebc0, 0xffc0, 0x0800, 0x8e20, {EACD},	"BFEXTS	%e{R%u:%w},%r" },
+{ 0xebc0, 0xffc0, 0x0020, 0x8838, {EACD},	"BFEXTS	%e{%o:R%a},%r" },
+{ 0xebc0, 0xffc0, 0x0000, 0x8820, {EACD},	"BFEXTS	%e{%o:%w},%r" },
+
+{ 0xecc0, 0xffc0, 0x0820, 0xfe38, {EACAD},	"BFCLR	%e{R%u:R%a}" },
+{ 0xecc0, 0xffc0, 0x0800, 0xfe20, {EACAD},	"BFCLR	%e{R%u:%w}" },
+{ 0xecc0, 0xffc0, 0x0020, 0xf838, {EACAD},	"BFCLR	%e{%o:R%a}" },
+{ 0xecc0, 0xffc0, 0x0000, 0xf820, {EACAD},	"BFCLR	%e{%o:%w}" },
+
+{ 0xedc0, 0xffc0, 0x0820, 0x8e38, {EACAD},	"BFFFO	%e{R%u:R%a},%r" },
+{ 0xedc0, 0xffc0, 0x0800, 0x8e20, {EACAD},	"BFFFO	%e{R%u:%w},%r" },
+{ 0xedc0, 0xffc0, 0x0020, 0x8838, {EACAD},	"BFFFO	%e{%o:R%a},%r" },
+{ 0xedc0, 0xffc0, 0x0000, 0x8820, {EACAD},	"BFFFO	%e{%o:%w},%r" },
+
+{ 0xeec0, 0xffc0, 0x0820, 0xfe38, {EACAD},	"BFSET	%e{R%u:R%a}" },
+{ 0xeec0, 0xffc0, 0x0800, 0xfe20, {EACAD},	"BFSET	%e{R%u:%w}" },
+{ 0xeec0, 0xffc0, 0x0020, 0xf838, {EACAD},	"BFSET	%e{%o:R%a}" },
+{ 0xeec0, 0xffc0, 0x0000, 0xf820, {EACAD},	"BFSET	%e{%o:%w}" },
+
+{ 0xefc0, 0xffc0, 0x0820, 0x8e38, {EACAD},	"BFINS	%r,%e{R%u:R%a}" },
+{ 0xefc0, 0xffc0, 0x0800, 0x8e20, {EACAD},	"BFINS	%r,%e{R%u:%w}" },
+{ 0xefc0, 0xffc0, 0x0020, 0x8838, {EACAD},	"BFINS	%r,%e{%o:R%a}" },
+{ 0xefc0, 0xffc0, 0x0000, 0x8820, {EACAD},	"BFINS	%r,%e{%o:%w}" },
+
+{ 0xe0c0, 0xfec0, 0x0000, 0x0000, {EAMA},	"AS%dW	%e" },
+{ 0xe2c0, 0xfec0, 0x0000, 0x0000, {EAMA},	"LS%dW	%e" },
+{ 0xe4c0, 0xfec0, 0x0000, 0x0000, {EAMA},	"ROX%dW	%e" },
+{ 0xe6c0, 0xfec0, 0x0000, 0x0000, {EAMA},	"RO%dW	%e" },
+
+{ 0xe000, 0xf038, 0x0000, 0x0000, {0},		"AS%d%s	#%q,R%y" },
+{ 0xe008, 0xf038, 0x0000, 0x0000, {0},		"LS%d%s	#%q,R%y" },
+{ 0xe010, 0xf038, 0x0000, 0x0000, {0},		"ROX%d%s	#%q,R%y" },
+{ 0xe018, 0xf038, 0x0000, 0x0000, {0},		"RO%d%s	#%q,R%y" },
+{ 0xe020, 0xf038, 0x0000, 0x0000, {0},		"AS%d%s	R%x,R%y" },
+{ 0xe028, 0xf038, 0x0000, 0x0000, {0},		"LS%d%s	R%x,R%y" },
+{ 0xe030, 0xf038, 0x0000, 0x0000, {0},		"ROX%d%s	R%x,R%y" },
+{ 0xe038, 0xf038, 0x0000, 0x0000, {0},		"RO%d%s	R%x,R%y" },
+{ 0,0,0,0,{0},0 },
+};
+	/* class f: coprocessor and mmu instructions */
+static Optable tf[] = {
+{ 0xf280, 0xffff, 0x0000, 0xffff, {0},		"FNOP" },
+{ 0xf200, 0xffff, 0x5c00, 0xfc00, {0},		"FMOVECRX	%k,F%D" },
+{ 0xf27a, 0xffff, 0x0000, 0xffc0, {I16},	"FTRAP%P	%i" },
+{ 0xf27b, 0xffff, 0x0000, 0xffc0, {I32},	"FTRAP%P	%i" },
+{ 0xf27c, 0xffff, 0x0000, 0xffc0, {0},		"FTRAP%P" },
+
+{ 0xf248, 0xfff8, 0x0000, 0xffc0, {BR16},	"FDB%P	R%y,%t" },
+{ 0xf620, 0xfff8, 0x8000, 0x8fff, {0},		"MOVE16	(A%y)+,(%r)+" },
+{ 0xf500, 0xfff8, 0x0000, 0x0000, {0},		"PFLUSHN	(A%y)" },
+{ 0xf508, 0xfff8, 0x0000, 0x0000, {0},		"PFLUSH	(A%y)" },
+{ 0xf510, 0xfff8, 0x0000, 0x0000, {0},		"PFLUSHAN" },
+{ 0xf518, 0xfff8, 0x0000, 0x0000, {0},		"PFLUSHA" },
+{ 0xf548, 0xfff8, 0x0000, 0x0000, {0},		"PTESTW	(A%y)" },
+{ 0xf568, 0xfff8, 0x0000, 0x0000, {0},		"PTESTR	(A%y)" },
+{ 0xf600, 0xfff8, 0x0000, 0x0000, {I32},	"MOVE16	(A%y)+,$%i" },
+{ 0xf608, 0xfff8, 0x0000, 0x0000, {I32},	"MOVE16	$%i,(A%y)-" },
+{ 0xf610, 0xfff8, 0x0000, 0x0000, {I32},	"MOVE16	(A%y),$%i" },
+{ 0xf618, 0xfff8, 0x0000, 0x0000, {I32},	"MOVE16	$%i,(A%y)" },
+
+{ 0xf000, 0xffc0, 0x0800, 0xffff, {EACA},	"PMOVE	%e,TT0" },
+{ 0xf000, 0xffc0, 0x0900, 0xffff, {EACA},	"PMOVEFD	%e,TT0" },
+{ 0xf000, 0xffc0, 0x0a00, 0xffff, {EACA},	"PMOVE	TT0,%e" },
+{ 0xf000, 0xffc0, 0x0b00, 0xffff, {EACA},	"PMOVEFD	TT0,%e" },
+{ 0xf000, 0xffc0, 0x0c00, 0xffff, {EACA},	"PMOVE	%e,TT1" },
+{ 0xf000, 0xffc0, 0x0d00, 0xffff, {EACA},	"PMOVEFD	%e,TT1" },
+{ 0xf000, 0xffc0, 0x0e00, 0xffff, {EACA},	"PMOVE	TT1,%e" },
+{ 0xf000, 0xffc0, 0x0f00, 0xffff, {EACA},	"PMOVEFD	TT1,%e" },
+{ 0xf000, 0xffc0, 0x2400, 0xffff, {0},		"PFLUSHA" },
+{ 0xf000, 0xffc0, 0x2800, 0xffff, {EACA},	"PVALID	VAL,%e" },
+{ 0xf000, 0xffc0, 0x6000, 0xffff, {EACA},	"PMOVE	%e,MMUSR" },
+{ 0xf000, 0xffc0, 0x6200, 0xffff, {EACA},	"PMOVE	MMUSR,%e" },
+{ 0xf000, 0xffc0, 0x2800, 0xfff8, {EACA},	"PVALID	A%a,%e" },
+{ 0xf000, 0xffc0, 0x2000, 0xffe0, {EACA},	"PLOADW	%L,%e" },
+{ 0xf000, 0xffc0, 0x2200, 0xffe0, {EACA},	"PLOADR	%L,%e" },
+{ 0xf000, 0xffc0, 0x8000, 0xffe0, {EACA},	"PTESTW	%L,%e,#0" },
+{ 0xf000, 0xffc0, 0x8200, 0xffe0, {EACA},	"PTESTR	%L,%e,#0" },
+{ 0xf000, 0xffc0, 0x3000, 0xfe00, {0},		"PFLUSH	%L,#%I" },
+{ 0xf000, 0xffc0, 0x3800, 0xfe00, {EACA},	"PFLUSH	%L,#%I,%e" },
+{ 0xf000, 0xffc0, 0x8000, 0xe300, {EACA},	"PTESTW	%L,%e,#%Z" },
+{ 0xf000, 0xffc0, 0x8100, 0xe300, {EACA},	"PTESTW	%L,%e,#%Z,A%h" },
+{ 0xf000, 0xffc0, 0x8200, 0xe300, {EACA},	"PTESTR	%L,%e,#%Z" },
+{ 0xf000, 0xffc0, 0x8300, 0xe300, {EACA},	"PTESTR	%L,%e,#%Z,A%h" },
+{ 0xf000, 0xffc0, 0x4000, 0xc3ff, {EACA},	"PMOVE	%e,%H" },
+{ 0xf000, 0xffc0, 0x4100, 0xc3ff, {EACA},	"PMOVEFD	%e,%H" },
+{ 0xf000, 0xffc0, 0x4200, 0xc3ff, {EACA},	"PMOVE	%H,%e" },
+
+	/* floating point (coprocessor 1)*/
+
+{ 0xf200, 0xffc0, 0x8400, 0xffff, {EAALL_L},	"FMOVEL	%e,FPIAR" },
+{ 0xf200, 0xffc0, 0x8800, 0xffff, {EADI_L},	"FMOVEL	%e,FPSR" },
+{ 0xf200, 0xffc0, 0x9000, 0xffff, {EADI_L},	"FMOVEL	%e,FPCR" },
+{ 0xf200, 0xffc0, 0xa400, 0xffff, {EAA},	"FMOVEL	FPIAR,%e" },
+{ 0xf200, 0xffc0, 0xa800, 0xffff, {EADA},	"FMOVEL	FPSR,%e" },
+{ 0xf200, 0xffc0, 0xb000, 0xffff, {EADA},	"FMOVEL	FPCR,%e" },
+
+{ 0xf240, 0xffc0, 0x0000, 0xffc0, {EADA},	"FS%P	%e" },
+
+{ 0xf200, 0xffc0, 0xd000, 0xff00, {EACPI},	"FMOVEMX	%e,%m" },
+{ 0xf200, 0xffc0, 0xd800, 0xff00, {EACPI},	"FMOVEMX	%e,R%K" },
+{ 0xf200, 0xffc0, 0xe000, 0xff00, {EAPI},	"FMOVEMX	%m,-(A%y)" },
+{ 0xf200, 0xffc0, 0xe800, 0xff00, {EAPI},	"FMOVEMX	R%K,-(A%y)" },
+{ 0xf200, 0xffc0, 0xf000, 0xff00, {EACAPD},	"FMOVEMX	%m,%e" },
+{ 0xf200, 0xffc0, 0xf800, 0xff00, {EACAPD},	"FMOVEMX	R%K,%e" },
+
+{ 0xf200, 0xffc0, 0x6800, 0xfc00, {EAMA},	"FMOVEX	F%D,%e" },
+{ 0xf200, 0xffc0, 0x6c00, 0xfc00, {EAMA},	"FMOVEP	F%D,%e,{%k}" },
+{ 0xf200, 0xffc0, 0x7400, 0xfc00, {EAMA},	"FMOVED	F%D,%e" },
+{ 0xf200, 0xffc0, 0x7c00, 0xfc00, {EAMA},	"FMOVEP	F%D,%e,{R%K}" },
+
+{ 0xf200, 0xffc0, 0x8000, 0xe3ff, {EAM},	"FMOVEML	#%B,%e" },
+{ 0xf200, 0xffc0, 0xa000, 0xe3ff, {EAMA},	"FMOVEML	%e,#%B" },
+
+{ 0xf200, 0xffc0, 0x0000, 0xe07f, {0},		"FMOVE	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0001, 0xe07f, {0},		"FINTX	%F" },
+{ 0xf200, 0xffc0, 0x0002, 0xe07f, {0},		"FSINHX	%F" },
+{ 0xf200, 0xffc0, 0x0003, 0xe07f, {0},		"FINTRZ	%F" },
+{ 0xf200, 0xffc0, 0x0004, 0xe07f, {0},		"FSQRTX	%F" },
+{ 0xf200, 0xffc0, 0x0006, 0xe07f, {0},		"FLOGNP1X	%F" },
+{ 0xf200, 0xffc0, 0x0009, 0xe07f, {0},		"FTANHX	%F" },
+{ 0xf200, 0xffc0, 0x000a, 0xe07f, {0},		"FATANX	%F" },
+{ 0xf200, 0xffc0, 0x000c, 0xe07f, {0},		"FASINX	%F" },
+{ 0xf200, 0xffc0, 0x000d, 0xe07f, {0},		"FATANHX	%F" },
+{ 0xf200, 0xffc0, 0x000e, 0xe07f, {0},		"FSINX	%F" },
+{ 0xf200, 0xffc0, 0x000f, 0xe07f, {0},		"FTANX	%F" },
+{ 0xf200, 0xffc0, 0x0010, 0xe07f, {0},		"FETOXX	%F" },
+{ 0xf200, 0xffc0, 0x0011, 0xe07f, {0},		"FTWOTOXX	%F" },
+{ 0xf200, 0xffc0, 0x0012, 0xe07f, {0},		"FTENTOXX	%F" },
+{ 0xf200, 0xffc0, 0x0014, 0xe07f, {0},		"FLOGNX	%F" },
+{ 0xf200, 0xffc0, 0x0015, 0xe07f, {0},		"FLOG10X	%F" },
+{ 0xf200, 0xffc0, 0x0016, 0xe07f, {0},		"FLOG2X	%F" },
+{ 0xf200, 0xffc0, 0x0018, 0xe07f, {0},		"FABSX	%F" },
+{ 0xf200, 0xffc0, 0x0019, 0xe07f, {0},		"FCOSHX	%F" },
+{ 0xf200, 0xffc0, 0x001a, 0xe07f, {0},		"FNEGX	%F" },
+{ 0xf200, 0xffc0, 0x001c, 0xe07f, {0},		"FACOSX	%F" },
+{ 0xf200, 0xffc0, 0x001d, 0xe07f, {0},		"FCOSX	%F" },
+{ 0xf200, 0xffc0, 0x001e, 0xe07f, {0},		"FGETEXPX	%F" },
+{ 0xf200, 0xffc0, 0x001f, 0xe07f, {0},		"FGETMANX	%F" },
+{ 0xf200, 0xffc0, 0x0020, 0xe07f, {0},		"FDIVX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0021, 0xe07f, {0},		"FMODX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0022, 0xe07f, {0},		"FADDX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0023, 0xe07f, {0},		"FMULX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0024, 0xe07f, {0},		"FSGLDIVX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0025, 0xe07f, {0},		"FREMX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0026, 0xe07f, {0},		"FSCALEX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0027, 0xe07f, {0},		"FSGLMULX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0028, 0xe07f, {0},		"FSUBX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0038, 0xe07f, {0},		"FCMPX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x003a, 0xe07f, {0},		"FTSTX	F%B" },
+{ 0xf200, 0xffc0, 0x0040, 0xe07f, {0},		"FSMOVE	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0041, 0xe07f, {0},		"FSSQRTX	%F"},
+{ 0xf200, 0xffc0, 0x0044, 0xe07f, {0},		"FDMOVE	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0045, 0xe07f, {0},		"FDSQRTX	%F" },
+{ 0xf200, 0xffc0, 0x0058, 0xe07f, {0},		"FSABSX	%F" },
+{ 0xf200, 0xffc0, 0x005a, 0xe07f, {0},		"FSNEGX	%F" },
+{ 0xf200, 0xffc0, 0x005c, 0xe07f, {0},		"FDABSX	%F" },
+{ 0xf200, 0xffc0, 0x005e, 0xe07f, {0},		"FDNEGX	%F" },
+{ 0xf200, 0xffc0, 0x0060, 0xe07f, {0},		"FSDIVX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0062, 0xe07f, {0},		"FSADDX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0063, 0xe07f, {0},		"FSMULX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0064, 0xe07f, {0},		"FDDIVX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0066, 0xe07f, {0},		"FDADDX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0067, 0xe07f, {0},		"FDMULX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x0068, 0xe07f, {0},		"FSSUBX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x006c, 0xe07f, {0},		"FDSUBX	F%B,F%D" },
+{ 0xf200, 0xffc0, 0x4000, 0xe07f, {EAFLT},	"FMOVE%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4001, 0xe07f, {EAFLT},	"FINT%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4002, 0xe07f, {EAFLT},	"FSINH%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4003, 0xe07f, {EAFLT},	"FINTRZ%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4004, 0xe07f, {EAFLT},	"FSQRT%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4006, 0xe07f, {EAFLT},	"FLOGNP1%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4009, 0xe07f, {EAFLT},	"FTANH%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x400a, 0xe07f, {EAFLT},	"FATAN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x400c, 0xe07f, {EAFLT},	"FASIN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x400d, 0xe07f, {EAFLT},	"FATANH%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x400e, 0xe07f, {EAFLT},	"FSIN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x400f, 0xe07f, {EAFLT},	"FTAN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4010, 0xe07f, {EAFLT},	"FETOX%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4011, 0xe07f, {EAFLT},	"FTWOTOX%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4012, 0xe07f, {EAFLT},	"FTENTOX%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4014, 0xe07f, {EAFLT},	"FLOGN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4015, 0xe07f, {EAFLT},	"FLOG10%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4016, 0xe07f, {EAFLT},	"FLOG2%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4018, 0xe07f, {EAFLT},	"FABS%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4019, 0xe07f, {EAFLT},	"FCOSH%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x401a, 0xe07f, {EAFLT},	"FNEG%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x401c, 0xe07f, {EAFLT},	"FACOS%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x401d, 0xe07f, {EAFLT},	"FCOS%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x401e, 0xe07f, {EAFLT},	"FGETEXP%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x401f, 0xe07f, {EAFLT},	"FGETMAN%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4020, 0xe07f, {EAFLT},	"FDIV%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4021, 0xe07f, {EAFLT},	"FMOD%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4022, 0xe07f, {EAFLT},	"FADD%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4023, 0xe07f, {EAFLT},	"FMUL%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4024, 0xe07f, {EAFLT},	"FSGLDIV%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4025, 0xe07f, {EAFLT},	"FREM%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4026, 0xe07f, {EAFLT},	"FSCALE%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4027, 0xe07f, {EAFLT},	"FSGLMUL%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4028, 0xe07f, {EAFLT},	"FSUB%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4038, 0xe07f, {EAFLT},	"FCMP%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x403a, 0xe07f, {EAFLT},	"FTST%S	%e" },
+{ 0xf200, 0xffc0, 0x4040, 0xe07f, {EAFLT},	"FSMOVE%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4041, 0xe07f, {EAFLT},	"FSSQRT%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4044, 0xe07f, {EAFLT},	"FDMOVE%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4045, 0xe07f, {EAFLT},	"FDSQRT%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4058, 0xe07f, {EAFLT},	"FSABS%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x405a, 0xe07f, {EAFLT},	"FSNEG%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x405c, 0xe07f, {EAFLT},	"FDABS%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x405e, 0xe07f, {EAFLT},	"FDNEG%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4060, 0xe07f, {EAFLT},	"FSDIV%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4062, 0xe07f, {EAFLT},	"FSADD%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4063, 0xe07f, {EAFLT},	"FSMUL%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4064, 0xe07f, {EAFLT},	"FDDIV%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4066, 0xe07f, {EAFLT},	"FDADD%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4067, 0xe07f, {EAFLT},	"FDMUL%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x4068, 0xe07f, {EAFLT},	"FSSUB%S	%e,F%D" },
+{ 0xf200, 0xffc0, 0x406c, 0xe07f, {EAFLT},	"FDSUB%S	%e,F%D" },
+
+{ 0xf200, 0xffc0, 0x0030, 0xe078, {0},		"FSINCOSX	F%B,F%a:F%D" },
+{ 0xf200, 0xffc0, 0x4030, 0xe078, {EAFLT},	"FSINCOS%S	%e,F%a:F%D" },
+
+{ 0xf200, 0xffc0, 0x6000, 0xe000, {EADA},	"FMOVE%S	F%D,%e" },
+
+{ 0xf300, 0xffc0, 0x0000, 0x0000, {EACAPD},	"FSAVE	%e" },
+{ 0xf340, 0xffc0, 0x0000, 0x0000, {EACAPI},	"FRESTORE	%e" },
+
+{ 0xf280, 0xffc0, 0x0000, 0x0000, {BR16},	"FB%p	%t" },
+{ 0xf2c0, 0xffc0, 0x0000, 0x0000, {BR32},	"FB%p	%t" },
+
+{ 0xf408, 0xff38, 0x0000, 0x0000, {0},		"CINVL	%C,(A%y)" },
+{ 0xf410, 0xff38, 0x0000, 0x0000, {0},		"CINVP	%C,(A%y)" },
+{ 0xf418, 0xff38, 0x0000, 0x0000, {0},		"CINVA	%C" },
+{ 0xf428, 0xff38, 0x0000, 0x0000, {0},		"CPUSHL	%C,(A%y)" },
+{ 0xf430, 0xff38, 0x0000, 0x0000, {0},		"CPUSHP	%C,(A%y)" },
+{ 0xf438, 0xff38, 0x0000, 0x0000, {0},		"CPUSHA	%C" },
+{ 0,0,0,0,{0},0 },
+};
+
+static Optable	*optables[] =
+{
+	t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, 0, tb, tc, td, te, tf,
+};
+
+static	Map	*mymap;
+
+static int
+dumpinst(Inst *ip, char *buf, int n)
+{
+	int i;
+
+	if (n <= 0)
+		return 0;
+
+	*buf++ = '#';
+	for (i = 0; i < ip->n && i*4+1 < n-4; i++, buf += 4)
+		_hexify(buf, ip->raw[i], 3);
+	*buf = 0;
+	return i*4+1;
+}
+
+static int
+getword(Inst *ip, long offset)
+{
+	if (ip->n < nelem(ip->raw)) {
+		if (get2(mymap, offset, &ip->raw[ip->n++]) > 0)
+			return 1;
+		werrstr("can't read instruction: %r");
+	} else
+		werrstr("instruction too big: %r");
+	return -1;
+}
+
+static int
+getshorts(Inst *ip, void *where, int n)
+{
+	if (ip->n+n < nelem(ip->raw)) {
+		if (get1(mymap, ip->addr+ip->n*2, (uchar*)&ip->raw[ip->n], n*2) < 0) {
+			werrstr("can't read instruction: %r");
+			return 0;
+		}
+		memmove(where, &ip->raw[ip->n], n*2);
+		ip->n += n;
+		return 1;
+	}
+	werrstr("instruction too big: %r");
+	return 0;
+}
+
+static int
+i8(Inst *ip, long *l)
+{
+	if (getword(ip, ip->addr+ip->n*2) < 0)
+		return -1;
+	*l = ip->raw[ip->n-1]&0xff;
+	if (*l&0x80)
+		*l |= ~0xff;
+	return 1;
+}
+
+static int
+i16(Inst *ip, long *l)
+{
+	if (getword(ip, ip->addr+ip->n*2) < 0)
+		return -1;
+	*l = ip->raw[ip->n-1];
+	if (*l&0x8000)
+		*l |= ~0xffff;
+	return 1;
+}
+static int
+i32(Inst *ip, long *l)
+{
+	if (getword(ip, ip->addr+ip->n*2) < 0)
+		return -1;
+	if (getword(ip, ip->addr+ip->n*2) < 0)
+		return -1;
+	*l = (ip->raw[ip->n-2]<<16)|ip->raw[ip->n-1];
+	return 1;
+}
+
+static int
+getimm(Inst *ip, Operand *ap, int mode)
+{
+	ap->eatype = IMM;
+	switch(mode)
+	{
+	case EAM_B:	/* byte */
+	case EAALL_B:
+		return i8(ip, &ap->u0.immediate);
+	case EADI_W:	/* word */
+	case EAALL_W:
+		return i16(ip, &ap->u0.immediate);
+	case EADI_L:	/* long */
+	case EAALL_L:
+		return i32(ip, &ap->u0.immediate);
+	case EAFLT:	/* floating point - size in bits 10-12 or word 1 */
+		switch((ip->raw[1]>>10)&0x07)
+		{
+		case 0:	/* long integer */
+			return i32(ip, &ap->u0.immediate);
+		case 1:	/* single precision real */
+			ap->eatype = IREAL;
+			return getshorts(ip, ap->u0.floater, 2);
+		case 2:	/* extended precision real - not supported */
+			ap->eatype = IEXT;
+			return getshorts(ip, ap->u0.floater, 6);
+		case 3: /* packed decimal real - not supported */
+			ap->eatype = IPACK;
+			return getshorts(ip, ap->u0.floater, 12);
+		case 4:	/* integer word */
+			return i16(ip, &ap->u0.immediate);
+		case 5:	/* double precision real */
+			ap->eatype = IDBL;
+			return getshorts(ip, ap->u0.floater, 4);
+		case 6:	/* integer byte */
+			return i8(ip, &ap->u0.immediate);
+		default:
+			ip->errmsg = "bad immediate float data";
+			return -1;
+		}
+		break;
+	case IV:	/* size encoded in bits 6&7 of opcode word */
+	default:
+		switch((ip->raw[0]>>6)&0x03)
+		{
+		case 0x00:	/* integer byte */
+			return i8(ip, &ap->u0.immediate);
+		case 0x01:	/* integer word */
+			return i16(ip, &ap->u0.immediate);
+		case 0x02:	/* integer long */
+			return i32(ip, &ap->u0.immediate);
+		default:
+			ip->errmsg = "bad immediate size";
+			return -1;
+		}
+		break;
+	}
+	return 1;
+}
+
+static int
+getdisp(Inst *ip, Operand *ap)
+{
+	short ext;
+
+	if (getword(ip, ip->addr+ip->n*2) < 0)
+		return -1;
+	ext = ip->raw[ip->n-1];
+	ap->ext = ext;
+	if ((ext&0x100) == 0) {		/* indexed with 7-bit displacement */
+		ap->u0.s0.disp = ext&0x7f;
+		if (ap->u0.s0.disp&0x40)
+			ap->u0.s0.disp |= ~0x7f;
+		return 1;
+	}
+	switch(ext&0x30)	/* first (inner) displacement  */
+	{
+	case 0x10:
+		break;
+	case 0x20:
+		if (i16(ip, &ap->u0.s0.disp) < 0)
+			return -1;
+		break;
+	case 0x30:
+		if (i32(ip, &ap->u0.s0.disp) < 0)
+			return -1;
+		break;
+	default:
+		ip->errmsg = "bad EA displacement";
+		return -1;
+	}
+	switch (ext&0x03)	/* outer displacement */
+	{
+	case 0x02:		/* 16 bit displacement */
+		return i16(ip, &ap->u0.s0.outer);
+	case 0x03:		/* 32 bit displacement */
+		return i32(ip, &ap->u0.s0.outer);
+	default:
+		break;
+	}
+	return 1;
+}
+
+static int
+ea(Inst *ip, int ea, Operand *ap, int mode)
+{
+	int type, size;
+
+	type = 0;
+	ap->ext = 0;
+	switch((ea>>3)&0x07)
+	{
+	case 0x00:
+		ap->eatype = Dreg;
+		type = Dn;
+		break;
+	case 0x01:
+		ap->eatype = Areg;
+		type = An;
+		break;
+	case 0x02:
+		ap->eatype = AInd;
+		type = Ind;
+		break;
+	case 0x03:
+		ap->eatype = APinc;
+		type = Pinc;
+		break;
+	case 0x04:
+		ap->eatype = APdec;
+		type = Pdec;
+		break;
+	case 0x05:
+		ap->eatype = ADisp;
+		type = Bdisp;
+		if (i16(ip, &ap->u0.s0.disp) < 0)
+			return -1;
+		break;
+	case 0x06:
+		ap->eatype = BXD;
+		type = Bdisp;
+		if (getdisp(ip, ap) < 0)
+			return -1;
+		break;
+	case 0x07:
+		switch(ea&0x07)
+		{
+		case 0x00:
+			type = Abs;
+			ap->eatype = ABS;
+			if (i16(ip, &ap->u0.immediate) < 0)
+				return -1;
+			break;
+		case 0x01:
+			type = Abs;
+			ap->eatype = ABS;
+			if (i32(ip, &ap->u0.immediate) < 0)
+				return -1;
+			break;
+		case 0x02:
+			type = PCrel;
+			ap->eatype = PDisp;
+			if (i16(ip, &ap->u0.s0.disp) < 0)
+				return -1;
+			break;
+		case 0x03:
+			type = PCrel;
+			ap->eatype = PXD;
+			if (getdisp(ip, ap) < 0)
+				return -1;
+			break;
+		case 0x04:
+			type = Imm;
+			if (getimm(ip, ap, mode) < 0)
+				return -1;
+			break;
+		default:
+			ip->errmsg = "bad EA mode";
+			return -1;
+		}
+	}
+		/* Allowable floating point EAs are restricted for packed,
+		 * extended, and double precision operands
+		 */
+	if (mode == EAFLT) {
+		size = (ip->raw[1]>>10)&0x07;
+		if (size == 2 || size == 3 || size == 5)
+			mode = EAM;
+		else
+			mode = EADI;
+	}
+	if (!(validea[mode]&type)) {
+		ip->errmsg = "invalid EA";
+		return -1;
+	}
+	return 1;
+}
+
+static int
+decode(Inst *ip, Optable *op)
+{
+	int i, t, mode;
+	Operand *ap;
+	short opcode;
+
+	opcode = ip->raw[0];
+	for (i = 0; i < nelem(op->opdata) && op->opdata[i]; i++) {
+		ap = &ip->and[i];
+		mode = op->opdata[i];
+		switch(mode)
+		{
+		case EAPI:		/* normal EA modes */
+		case EACA:
+		case EACAD:
+		case EACAPI:
+		case EACAPD:
+		case EAMA:
+		case EADA:
+		case EAA:
+		case EAC:
+		case EACPI:
+		case EACD:
+		case EAD:
+		case EAM:
+		case EAM_B:
+		case EADI:
+		case EADI_L:
+		case EADI_W:
+		case EAALL:
+		case EAALL_L:
+		case EAALL_W:
+		case EAALL_B:
+		case EAFLT:
+			if (ea(ip, opcode&0x3f, ap, mode) < 0)
+				return -1;
+			break;
+		case EADDA:	/* stupid bit flop required */
+			t = ((opcode>>9)&0x07)|((opcode>>3)&0x38);
+			if (ea(ip, t, ap, EADA)< 0)
+					return -1;
+			break;
+		case BREAC:	/* EAC JMP or CALL operand */
+			if (ea(ip, opcode&0x3f, ap, EAC) < 0)
+				return -1;
+			break;
+		case OP8:	/* weird movq instruction */
+			ap->eatype = IMM;
+			ap->u0.immediate = opcode&0xff;
+			if (opcode&0x80)
+				ap->u0.immediate |= ~0xff;
+			break;
+		case I8:	/* must be two-word opcode */
+			ap->eatype = IMM;
+			ap->u0.immediate = ip->raw[1]&0xff;
+			if (ap->u0.immediate&0x80)
+				ap->u0.immediate |= ~0xff;
+			break;
+		case I16:	/* 16 bit immediate */
+		case BR16:
+			ap->eatype = IMM;
+			if (i16(ip, &ap->u0.immediate) < 0)
+				return -1;
+			break;
+		case C16:	/* CAS2 16 bit immediate */
+			ap->eatype = IMM;
+			if (i16(ip, &ap->u0.immediate) < 0)
+				return -1;
+			if (ap->u0.immediate & 0x0e38) {
+				ip->errmsg = "bad CAS2W operand";
+				return 0;
+			}
+			break;
+		case I32:	/* 32 bit immediate */
+		case BR32:
+			ap->eatype = IMM;
+			if (i32(ip, &ap->u0.immediate) < 0)
+				return -1;
+			break;
+		case IV:	/* immediate data depends on size field */
+			if (getimm(ip, ap, IV) < 0)
+				return -1;
+			break;
+		case BR8:	/* branch displacement format */
+			ap->eatype = IMM;
+			ap->u0.immediate = opcode&0xff;
+			if (ap->u0.immediate == 0) {
+				if (i16(ip, &ap->u0.immediate) < 0)
+					return -1;
+			} else if (ap->u0.immediate == 0xff) {
+				if (i32(ip, &ap->u0.immediate) < 0)
+					return -1;
+			} else if (ap->u0.immediate & 0x80)
+				ap->u0.immediate |= ~0xff;
+			break;
+		case STACK:	/* Dummy operand type for Return instructions */
+		default:
+			break;
+		}
+	}
+	return 1;
+}
+
+static Optable *
+instruction(Inst *ip)
+{
+	ushort opcode, op2;
+	Optable *op;
+	int class;
+
+	ip->n = 0;
+	if (getword(ip, ip->addr) < 0)
+		return 0;
+	opcode = ip->raw[0];
+	if (get2(mymap, ip->addr+2, &op2) < 0)
+		op2 = 0;
+	class = (opcode>>12)&0x0f;
+	for (op = optables[class]; op && op->format; op++) {
+		if (op->opcode != (opcode&op->mask0))
+			continue;
+		if (op->op2 != (op2&op->mask1))
+			continue;
+		if (op->mask1)
+			ip->raw[ip->n++] = op2;
+		return op;
+	}
+	ip->errmsg = "Invalid opcode";
+	return 0;
+}
+
+static void
+bprint(Inst *i, char *fmt, ...)
+{
+	va_list arg;
+
+	va_start(arg, fmt);
+	i->curr = vseprint(i->curr, i->end, fmt, arg);
+	va_end(arg);
+}
+
+static	char	*regname[] =
+{
+	"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "A0",
+	"A1", "A2", "A3", "A4", "A5", "A6", "A7", "PC", "SB"
+};
+
+static void
+plocal(Inst *ip, Operand *ap)
+{
+	int ret, offset;
+	long moved;
+	Symbol s;
+
+	offset = ap->u0.s0.disp;
+	if (!findsym(ip->addr, CTEXT, &s))
+		goto none;
+
+	moved = pc2sp(ip->addr);
+	if (moved == -1)
+		goto none;
+
+	if (offset > moved) {		/* above frame - must be argument */
+		offset -= moved;
+		ret = getauto(&s, offset-mach->szaddr, CPARAM, &s);
+	} else				/* below frame - must be automatic */
+		ret = getauto(&s, moved-offset, CPARAM, &s);
+	if (ret)
+		bprint(ip, "%s+%lux", s.name, offset);
+	else
+none:		bprint(ip, "%lux", ap->u0.s0.disp);
+}
+
+/*
+ *	this guy does all the work of printing the base and index component
+ *	of an EA.
+ */
+static int
+pidx(Inst *ip, int ext, int reg, char *bfmt, char *ifmt, char *nobase)
+{
+	char *s;
+	int printed;
+	char buf[512];
+
+	printed = 1;
+	if (ext&0x80) {				/* Base suppressed */
+		if (reg == 16)
+			bprint(ip, bfmt, "(ZPC)");
+		else if (nobase)
+			bprint(ip, nobase);
+		else
+			printed = 0;
+	} else					/* format base reg */
+		bprint(ip, bfmt, regname[reg]);
+	if (ext & 0x40)				/* index suppressed */
+		return printed;
+	switch ((ext>>9)&0x03)
+	{
+	case 0x01:
+		s = "*2";
+		break;
+	case 0x02:
+		s = "*4";
+		break;
+	case 0x03:
+		s = "*8";
+		break;
+	default:
+		if (ext&0x80)
+			s = "*1";
+		else
+			s = "";
+		break;
+	}
+	sprint(buf, "%s.%c%s", regname[(ext>>12)&0x0f], (ext&0x800) ? 'L' : 'W', s);
+	if (!printed)
+		bprint(ip, ifmt, buf);
+	else
+		bprint(ip, "(%s)", buf);
+	return 1;
+}
+
+static void
+prindex(Inst *ip, int reg, Operand *ap)
+{
+	short ext;
+	int left;
+	int disp;
+
+	left = ip->end-ip->curr;
+	if (left <= 0)
+		return;
+	ext = ap->ext;
+	disp = ap->u0.s0.disp;
+		/* look for static base register references */
+	if ((ext&0xa0) == 0x20 && reg == 14 && mach->sb && disp) {
+		reg = 17;		/* "A6" -> "SB" */
+		disp += mach->sb;
+	}
+	if ((ext&0x100) == 0) {		/* brief form */
+		if (reg == 15)
+			plocal(ip, ap);
+		else if (disp)
+			ip->curr += symoff(ip->curr, left, disp, CANY);
+		pidx(ip, ext&0xff00, reg, "(%s)", "(%s)", 0);
+		return;
+	}
+	switch(ext&0x3f)	/* bd size, && i/is */
+	{
+	case 0x10:
+		if (!pidx(ip, ext, reg, "(%s)", "(%s)", 0))
+			bprint(ip, "#0");
+		break;
+	case 0x11:
+		if (pidx(ip, ext, reg, "((%s)", "((%s)", 0))
+			bprint(ip, ")");
+		else
+			bprint(ip, "#0");
+		break;
+	case 0x12:
+	case 0x13:
+		ip->curr += symoff(ip->curr, left, ap->u0.s0.outer, CANY);
+		if (pidx(ip, ext, reg, "((%s)", "((%s)", 0))
+			bprint(ip, ")");
+		break;
+	case 0x15:
+		if (!pidx(ip, ext, reg, "((%s))", "(%s)", 0))
+			bprint(ip, "#0");
+		break;
+	case 0x16:
+	case 0x17:
+		ip->curr += symoff(ip->curr, left, ap->u0.s0.outer, CANY);
+		pidx(ip, ext, reg, "((%s))", "(%s)", 0);
+		break;
+	case 0x20:
+	case 0x30:
+		if (reg == 15)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, left, disp, CANY);
+		pidx(ip, ext, reg, "(%s)", "(%s)", 0);
+		break;
+	case 0x21:
+	case 0x31:
+		*ip->curr++ = '(';
+		if (reg == 15)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, left-1, disp, CANY);
+		pidx(ip, ext, reg, "(%s)", "(%s)", 0);
+		bprint(ip, ")");
+		break;
+	case 0x22:
+	case 0x23:
+	case 0x32:
+	case 0x33:
+		ip->curr += symoff(ip->curr, left, ap->u0.s0.outer, CANY);
+		bprint(ip, "(");
+		if (reg == 15)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, ip->end-ip->curr, disp, CANY);
+		pidx(ip, ext, reg, "(%s)", "(%s)", 0);
+		bprint(ip, ")");
+		break;
+	case 0x25:
+	case 0x35:
+		*ip->curr++ = '(';
+		if (reg == 15)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, left-1, disp, CANY);
+		if (!pidx(ip, ext, reg, "(%s))", "(%s)", "())"))
+			bprint(ip, ")");
+		break;
+	case 0x26:
+	case 0x27:
+	case 0x36:
+	case 0x37:
+		ip->curr += symoff(ip->curr, left, ap->u0.s0.outer, CANY);
+		bprint(ip, "(");
+		if (reg == 15)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, ip->end-ip->curr, disp, CANY);
+		pidx(ip, ext, reg, "(%s))", "(%s)", "())");
+		break;
+	default:
+		bprint(ip, "??%x??", ext);
+		ip->errmsg = "bad EA";
+		break;
+	}
+}
+
+static	void
+pea(int reg, Inst *ip, Operand *ap)
+{
+	int i, left;
+
+	left = ip->end-ip->curr;
+	if (left < 0)
+		return;
+	switch(ap->eatype)
+	{
+	case Dreg:
+		bprint(ip, "R%d", reg);
+		break;
+	case Areg:
+		bprint(ip, "A%d", reg);
+		break;
+	case AInd:
+		bprint(ip, "(A%d)", reg);
+		break;
+	case APinc:
+		bprint(ip, "(A%d)+", reg);
+		break;
+	case APdec:
+		bprint(ip, "-(A%d)", reg);
+		break;
+	case PDisp:
+		ip->curr += symoff(ip->curr, left, ip->addr+2+ap->u0.s0.disp, CANY);
+		break;
+	case PXD:
+		prindex(ip, 16, ap);
+		break;
+	case ADisp:	/* references off the static base */
+		if (reg == 6 && mach->sb && ap->u0.s0.disp) {
+			ip->curr += symoff(ip->curr, left, ap->u0.s0.disp+mach->sb, CANY);
+			bprint(ip, "(SB)", reg);
+			break;
+		}
+			/* reference autos and parameters off the stack */
+		if (reg == 7)
+			plocal(ip, ap);
+		else
+			ip->curr += symoff(ip->curr, left, ap->u0.s0.disp, CANY);
+		bprint(ip, "(A%d)", reg);
+		break;
+	case BXD:
+		prindex(ip, reg+8, ap);
+		break;
+	case ABS:
+		ip->curr += symoff(ip->curr, left, ap->u0.immediate, CANY);
+		bprint(ip, "($0)");
+		break;
+	case IMM:
+		*ip->curr++ = '$';
+		ip->curr += symoff(ip->curr, left-1, ap->u0.immediate, CANY);
+		break;
+	case IREAL:
+		*ip->curr++ = '$';
+		ip->curr += beieeesftos(ip->curr, left-1, (void*) ap->u0.floater);
+		break;
+	case IDBL:
+		*ip->curr++ = '$';
+		ip->curr += beieeedftos(ip->curr, left-1, (void*) ap->u0.floater);
+		break;
+	case IPACK:
+		bprint(ip, "$#");
+		for (i = 0; i < 24 && ip->curr < ip->end-1; i++) {
+			_hexify(ip->curr, ap->u0.floater[i], 1);
+			ip->curr += 2;
+		}
+		break;
+	case IEXT:
+		bprint(ip, "$#");
+		ip->curr += beieee80ftos(ip->curr, left-2, (void*)ap->u0.floater);
+		break;
+	default:
+		bprint(ip, "??%x??", ap->eatype);
+		ip->errmsg = "bad EA type";
+		break;
+	}
+}
+
+static char *cctab[]  = { "F", "T", "HI", "LS", "CC", "CS", "NE", "EQ",
+			  "VC", "VS", "PL", "MI", "GE", "LT", "GT", "LE" };
+static	char *fcond[] =
+{
+	"F",	"EQ",	"OGT",	"OGE",	"OLT",	"OLE",	"OGL", "OR",
+	"UN",	"UEQ",	"UGT",	"UGE",	"ULT",	"ULE",	"NE",	"T",
+	"SF",	"SEQ",	"GT",	"GE",	"LT",	"LE",	"GL",	"GLE",
+	"NGLE",	"NGL",	"NLE",	"NLT",	"NGE",	"NGT",	"SNE",	"ST"
+};
+static	char *cachetab[] =	{ "NC", "DC", "IC", "BC" };
+static	char *mmutab[] =	{ "TC", "??", "SRP", "CRP" };
+static	char *crtab0[] =
+{
+	"SFC", "DFC", "CACR", "TC", "ITT0", "ITT1", "DTT0", "DTT1",
+};
+static	char *crtab1[] =
+{
+	"USP", "VBR", "CAAR", "MSP", "ISP", "MMUSR", "URP", "SRP",
+};
+static	char typetab[] =	{ 'L', 'S', 'X', 'P', 'W', 'D', 'B', '?', };
+static	char sztab[] =		{'?', 'B', 'W', 'L', '?' };
+
+static	void
+formatins(char *fmt, Inst *ip)
+{
+	short op, w1;
+	int r1, r2;
+	int currand;
+
+	op = ip->raw[0];
+	w1 = ip->raw[1];
+	currand = 0;
+	for (; *fmt && ip->curr < ip->end; fmt++) {
+		if (*fmt != '%')
+			*ip->curr++ = *fmt;
+		else switch(*++fmt)
+		{
+		case '%':
+			*ip->curr++ = '%';
+			break;
+		case 'a':	/* register number; word 1:[0-2] */
+			*ip->curr++ = (w1&0x07)+'0';
+			break;
+		case 'c':	/* condition code; opcode: [8-11] */
+			bprint(ip, cctab[(op>>8)&0x0f]);
+			break;
+		case 'd':	/* shift direction; opcode: [8] */
+			if (op&0x100)
+				*ip->curr++ = 'L';
+			else
+				*ip->curr++ = 'R';
+			break;
+		case 'e':	/* source effective address */
+			pea(op&0x07, ip, &ip->and[currand++]);
+			break;
+		case 'f':	/* trap vector; op code: [0-3] */
+			bprint(ip, "%x", op&0x0f);
+			break;
+		case 'h':	/* register number; word 1: [5-7] */
+			*ip->curr++ = (w1>>5)&0x07+'0';
+			break;
+		case 'i':	/* immediate operand */
+			ip->curr += symoff(ip->curr, ip->end-ip->curr,
+					ip->and[currand++].u0.immediate, CANY);
+			break;
+		case 'j':	/* data registers; word 1: [0-2] & [12-14] */
+			r1 = w1&0x07;
+			r2 = (w1>>12)&0x07;
+			if (r1 == r2)
+				bprint(ip, "R%d", r1);
+			else
+				bprint(ip, "R%d:R%d", r2, r1);
+			break;
+		case 'k':	/* k factor; word 1 [0-6] */
+			bprint(ip, "%x", w1&0x7f);
+			break;
+		case 'm':	/* register mask; word 1 [0-7] */
+			bprint(ip, "%x", w1&0xff);
+			break;
+		case 'o':	/* bit field offset; word1: [6-10] */
+			bprint(ip, "%d", (w1>>6)&0x3f);
+			break;
+		case 'p':	/* conditional predicate; opcode: [0-5]
+				   only bits 0-4 are defined  */
+			bprint(ip, fcond[op&0x1f]);
+			break;
+		case 'q':	/* 3-bit immediate value; opcode[9-11] */
+			r1 = (op>>9)&0x07;
+			if (r1 == 0)
+				*ip->curr++ = '8';
+			else
+				*ip->curr++ = r1+'0';
+			break;
+		case 'r':	/* register type & number; word 1: [12-15] */
+			bprint(ip, regname[(w1>>12)&0x0f]);
+			break;
+		case 's':	/* size; opcode [6-7] */
+			*ip->curr = sztab[((op>>6)&0x03)+1];
+			if (*ip->curr++ == '?')
+				ip->errmsg = "bad size code";
+			break;
+		case 't':	/* text offset */
+			ip->curr += symoff(ip->curr, ip->end-ip->curr,
+				ip->and[currand++].u0.immediate+ip->addr+2, CTEXT);
+			break;
+		case 'u':	/* register number; word 1: [6-8] */
+			*ip->curr++ = ((w1>>6)&0x07)+'0';
+			break;
+		case 'w':	/* bit field width; word 1: [0-4] */
+			bprint(ip, "%d", w1&0x0f);
+			break;
+		case 'x':	/* register number; opcode: [9-11] */
+			*ip->curr++ = ((op>>9)&0x07)+'0';
+			break;
+		case 'y':	/* register number; opcode: [0-2] */
+			*ip->curr++ = (op&0x07)+'0';
+			break;
+		case 'z':	/* shift count; opcode: [9-11] */	
+			*ip->curr++ = ((op>>9)&0x07)+'0';
+			break;
+		case 'A':	/* register number; word 2: [0-2] */
+			*ip->curr++ = (ip->raw[2]&0x07)+'0';
+			break;
+		case 'B':	/* float source reg; word 1: [10-12] */
+			*ip->curr++ = ((w1>>10)&0x07)+'0';
+			break;
+		case 'C':	/* cache identifier; opcode: [6-7] */
+			bprint(ip, cachetab[(op>>6)&0x03]);
+			break;
+		case 'D':	/* float dest reg; word 1: [7-9] */
+			*ip->curr++ = ((w1>>7)&0x07)+'0';
+			break;
+		case 'E':	/* destination EA; opcode: [6-11] */
+			pea((op>>9)&0x07, ip, &ip->and[currand++]);
+			break;
+		case 'F':	/* float dest register(s); word 1: [7-9] & [10-12] */
+			r1 = (w1>>7)&0x07;
+			r2 = (w1>>10)&0x07;
+			if (r1 == r2)
+				bprint(ip, "F%d", r1);
+			else
+				bprint(ip, "F%d,F%d", r2, r1);
+			break;
+		case 'H':	/* MMU register; word 1 [10-13] */
+			bprint(ip, mmutab[(w1>>10)&0x03]);
+			if (ip->curr[-1] == '?')
+				ip->errmsg = "bad mmu register";
+			break;
+		case 'I':	/* MMU function code mask; word 1: [5-8] */
+			bprint(ip, "%x", (w1>>4)&0x0f);
+			break;
+		case 'K':	/* dynamic k-factor register; word 1: [5-8] */
+			bprint(ip, "%d",  (w1>>4)&0x0f);
+			break;
+		case 'L':	/* MMU function code; word 1: [0-6] */
+			if (w1&0x10)
+				bprint(ip, "%x", w1&0x0f);
+			else if (w1&0x08)
+				bprint(ip, "R%d",w1&0x07);
+			else if (w1&0x01)
+				bprint(ip, "DFC");
+			else
+				bprint(ip, "SFC");
+			break;
+		case 'N':	/* control register; word 1: [0-11] */
+			r1 = w1&0xfff;
+			if (r1&0x800)
+				bprint(ip, crtab1[r1&0x07]);
+			else
+				bprint(ip, crtab0[r1&0x07]);
+			break;
+		case 'P':	/* conditional predicate; word 1: [0-5] */
+			bprint(ip, fcond[w1&0x1f]);
+			break;
+		case 'R':	/* register type & number; word 2 [12-15] */
+			bprint(ip, regname[(ip->raw[2]>>12)&0x0f]);
+			break;
+		case 'S':	/* float source type code; word 1: [10-12] */
+			*ip->curr = typetab[(w1>>10)&0x07];
+			if (*ip->curr++ == '?')
+				ip->errmsg = "bad float type";
+			break;
+		case 'U':	/* register number; word 2: [6-8] */
+			*ip->curr++ = ((ip->raw[2]>>6)&0x07)+'0';
+			break;
+		case 'Z':	/* ATC level number; word 1: [10-12] */
+			bprint(ip, "%x", (w1>>10)&0x07);
+			break;
+		case '1':	/* effective address in second operand*/
+			pea(op&0x07, ip, &ip->and[1]);
+			break;
+		default:
+			bprint(ip, "%%%c", *fmt);
+			break;
+		}
+	}
+	*ip->curr = 0;		/* there's always room for 1 byte */
+}
+
+static int
+dispsize(Inst *ip)
+{
+	ushort ext;
+	static int dsize[] = {0, 0, 1, 2};	/* in words */
+
+	if (get2(mymap, ip->addr+ip->n*2, &ext) < 0)
+		return -1;
+	if ((ext&0x100) == 0)
+		return 1;
+	return dsize[(ext>>4)&0x03]+dsize[ext&0x03]+1;
+}
+
+static int
+immsize(Inst *ip, int mode)
+{
+	static int fsize[] = { 2, 2, 6, 12, 1, 4, 1, -1 };
+	static int isize[] = { 1, 1, 2, -1 };
+
+	switch(mode)
+	{
+	case EAM_B:			/* byte */
+	case EAALL_B:
+	case EADI_W:			/* word */
+	case EAALL_W:
+		return 1;
+	case EADI_L:			/* long */
+	case EAALL_L:
+		return 2;
+	case EAFLT:	/* floating point - size in bits 10-12 or word 1 */
+		return fsize[(ip->raw[1]>>10)&0x07];
+	case IV:	/* size encoded in bits 6&7 of opcode word */
+	default:
+		return isize[(ip->raw[0]>>6)&0x03];
+	}
+	return -1;
+}
+
+static int
+easize(Inst *ip, int ea, int mode)
+{
+	switch((ea>>3)&0x07)
+	{
+	case 0x00:
+	case 0x01:
+	case 0x02:
+	case 0x03:
+	case 0x04:
+		return 0;
+	case 0x05:
+		return 1;
+	case 0x06:
+		return dispsize(ip);
+	case 0x07:
+		switch(ea&0x07)
+		{
+		case 0x00:
+		case 0x02:
+			return 1;
+		case 0x01:
+			return 2;
+		case 0x03:
+			return dispsize(ip);
+		case 0x04:
+			return immsize(ip, mode);
+		default:
+			return -1;
+		}
+	}
+	return -1;
+}
+
+static int
+instrsize(Inst *ip, Optable *op)
+{
+	int i, t, mode;
+	short opcode;
+
+	opcode = ip->raw[0];
+	for (i = 0; i < nelem(op->opdata) && op->opdata[i]; i++) {
+		mode = op->opdata[i];
+		switch(mode)
+		{
+		case EAPI:		/* normal EA modes */
+		case EACA:
+		case EACAD:
+		case EACAPI:
+		case EACAPD:
+		case EAMA:
+		case EADA:
+		case EAA:
+		case EAC:
+		case EACPI:
+		case EACD:
+		case EAD:
+		case EAM:
+		case EAM_B:
+		case EADI:
+		case EADI_L:
+		case EADI_W:
+		case EAALL:
+		case EAALL_L:
+		case EAALL_W:
+		case EAALL_B:
+		case EAFLT:
+			t = easize(ip, opcode&0x3f, mode);
+			if (t < 0)
+				return -1;
+			ip->n += t;
+			break;
+		case EADDA:	/* stupid bit flop required */
+			t = ((opcode>>9)&0x07)|((opcode>>3)&0x38);
+			t = easize(ip, t, mode);
+			if (t < 0)
+				return -1;
+			ip->n += t;
+			break;
+		case BREAC:	/* EAC JMP or CALL operand */
+				/* easy displacements for follow set */
+			if ((opcode&0x038) == 0x28 || (opcode&0x3f) == 0x3a) {
+				if (i16(ip, &ip->and[i].u0.immediate) < 0)
+					return -1;
+			} else {
+				t = easize(ip, opcode&0x3f, mode);
+				if (t < 0)
+					return -1;
+				ip->n += t;
+			}
+			break;
+		case I16:	/* 16 bit immediate */
+		case C16:	/* CAS2 16 bit immediate */
+			ip->n++;
+			break;
+		case BR16:	/* 16 bit branch displacement */
+			if (i16(ip, &ip->and[i].u0.immediate) < 0)
+				return -1;
+			break;
+		case BR32:	/* 32 bit branch displacement */
+			if (i32(ip, &ip->and[i].u0.immediate) < 0)
+				return -1;
+			break;
+		case I32:	/* 32 bit immediate */
+			ip->n += 2;
+			break;
+		case IV:	/* immediate data depends on size field */
+			t = (ip->raw[0]>>6)&0x03;
+			if (t < 2)
+				ip->n++;
+			else if (t == 2)
+				ip->n += 2;
+			else 
+				return -1;
+			break;
+		case BR8:	/* loony branch displacement format */
+			t = opcode&0xff;
+			if (t == 0) {
+				if (i16(ip, &ip->and[i].u0.immediate) < 0)
+					return -1;
+			} else if (t == 0xff) {
+				if (i32(ip, &ip->and[i].u0.immediate) < 0)
+					return -1;
+			} else {
+				ip->and[i].u0.immediate = t;
+				if (t & 0x80)
+					ip->and[i].u0.immediate |= ~0xff;
+			}
+			break;
+		case STACK:	/* Dummy operand for Return instructions */
+		case OP8:	/* weird movq instruction */
+		case I8:	/* must be two-word opcode */
+		default:
+			break;
+		}
+	}
+	return 1;
+}
+
+static int
+eaval(Inst *ip, Operand *ap, Rgetter rget)
+{
+	int reg;
+	char buf[8];
+
+	reg = ip->raw[0]&0x07;
+	switch(ap->eatype)
+	{
+	case AInd:
+		sprint(buf, "A%d", reg);
+		return (*rget)(mymap, buf);
+	case PDisp:
+		return ip->addr+2+ap->u0.s0.disp;
+	case ADisp:
+		sprint(buf, "A%d", reg);
+		return ap->u0.s0.disp+(*rget)(mymap, buf);
+	case ABS:
+		return ap->u0.immediate;
+	default:
+		return 0;
+	}
+}
+
+static int
+m68020instlen(Map *map, ulong pc)
+{
+	Inst i;
+	Optable *op;
+
+	mymap = map;
+	i.addr = pc;
+	i.errmsg = 0;
+	op = instruction(&i);
+	if (op && instrsize(&i, op) > 0)
+			return i.n*2;
+	return -1;
+}
+
+static int
+m68020foll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	int j;
+	Inst i;
+	Optable *op;
+
+	mymap = map;
+	i.addr = pc;
+	i.errmsg = 0;
+	op = instruction(&i);
+	if (op == 0  || instrsize(&i, op) < 0)
+		return -1;
+	for (j = 0; j < nelem(op->opdata) && op->opdata[j]; j++) {
+		switch(op->opdata[j])
+		{
+		case BREAC:	/* CALL, JMP, JSR */
+			foll[0] = pc+2+eaval(&i, &i.and[j], rget);
+			return 1;
+		case BR8:	/* Bcc, BSR, & BRA */
+		case BR16:	/* FBcc, FDBcc, DBcc */
+		case BR32:	/* FBcc */
+			foll[0] = pc+i.n*2;
+			foll[1] = pc+2+i.and[j].u0.immediate;
+			return 2;
+		case STACK:	/* RTR, RTS, RTD */
+			if (get4(map, (*rget)(map, mach->sp), (long*) foll) < 0)
+				return -1;
+			return 1;
+		default:
+			break;
+		}
+	}
+	foll[0] = pc+i.n*2;			
+	return 1;
+}
+
+static int
+m68020inst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	Inst i;
+	Optable *op;
+
+	USED(modifier);
+	mymap = map;
+	i.addr = pc;
+	i.curr = buf;
+	i.end = buf+n-1;
+	i.errmsg = 0;
+	op = instruction(&i);
+	if (!op)
+		return -1;
+	if (decode(&i, op) > 0)
+		formatins(op->format, &i);
+	if (i.errmsg) {
+		if (i.curr != buf)
+			bprint(&i, "\t\t;");
+		bprint(&i, "%s: ", i.errmsg);
+		dumpinst(&i, i.curr, i.end-i.curr);
+	}
+	return i.n*2;
+}
+
+static int
+m68020das(Map *map, ulong pc, char *buf, int n)
+{
+	Inst i;
+	Optable *op;
+
+	mymap = map;
+	i.addr = pc;
+	i.curr = buf;
+	i.end = buf+n-1;
+	i.errmsg = 0;
+	
+	op = instruction(&i);
+	if (!op)
+		return -1;
+	decode(&i, op);
+	if (i.errmsg)
+		bprint(&i, "%s: ", i.errmsg);
+	dumpinst(&i, i.curr, i.end-i.curr);
+	return i.n*2;
+}
diff --git a/utils/libmach/2obj.c b/utils/libmach/2obj.c
new file mode 100644
index 00000000..368e1ec7
--- /dev/null
+++ b/utils/libmach/2obj.c
@@ -0,0 +1,137 @@
+/*
+ * 2obj.c - identify and parse a 68020 object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "2c/2.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	sym;
+	char	flags;
+};
+static Addr addr(Biobuf *);
+static char type2char(int);
+static void skip(Biobuf*, int);
+
+int
+_is2(char *t)
+{
+	uchar *s = (uchar *)t;
+
+	return  s[0] == (ANAME&0xff)			/* aslo = ANAME */
+		&& s[1] == ((ANAME>>8)&0xff)		/* ashi = ANAME */
+		&& s[2] == D_FILE			/* type */
+		&& s[3] == 1				/* sym */
+		&& s[4] == '<';				/* name of file */
+}
+
+int
+_read2(Biobuf *bp, Prog *p)
+{
+	int as, n, c;
+	Addr a;
+
+	as = Bgetc(bp);		/* as(low) */
+	if(as < 0)
+		return 0;
+	c = Bgetc(bp);		/* as(high) */
+	if(c < 0)
+		return 0;
+	as |= ((c & 0xff) << 8);
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 4);		/*lineno: low, high, lowhigh, highigh*/
+	a = addr(bp);
+	addr(bp);
+	if(!(a.flags & T_SYM))
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	int t;
+	long off;
+
+	a.flags = Bgetc(bp);			/* flags */
+	a.sym = -1;
+	off = 0;
+	if(a.flags & T_FIELD)
+		skip(bp, 2);
+	if(a.flags & T_INDEX)
+		skip(bp, 7);
+	if(a.flags & T_OFFSET){
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+	}
+	if(a.flags & T_SYM)
+		a.sym = Bgetc(bp);
+	if(a.flags & T_FCONST)
+		skip(bp, 8);
+	else if(a.flags & T_SCONST)
+		skip(bp, NSNAME);
+	else{
+		t = Bgetc(bp);
+		if(a.flags & T_TYPE)
+			t |= Bgetc(bp) << 8;
+		t &= D_MASK;
+		if(a.sym > 0 && (t==D_PARAM || t==D_AUTO))
+			_offset(a.sym, off);
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/4.c b/utils/libmach/4.c
new file mode 100644
index 00000000..3b1f38dd
--- /dev/null
+++ b/utils/libmach/4.c
@@ -0,0 +1,139 @@
+/*
+ * mips definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "ureg4.h"
+#include "mach.h"
+
+#define	FPREGBYTES	4
+#define	REGOFF(x)	(ulong)(&((struct Ureg *) 0)->x)
+
+#define SP		REGOFF(u0.sp)
+#define PC		REGOFF(pc)
+#define	R1		REGOFF(hr1)
+#define	R31		REGOFF(hr31)
+#define	FP_REG(x)	(R1+8+FPREGBYTES*(x))
+
+#define	REGSIZE		sizeof(struct Ureg)
+#define	FPREGSIZE	(FPREGBYTES*33)
+
+Reglist mips2reglist[] = {
+	{"STATUS",	REGOFF(status),		RINT|RRDONLY, 'X'},
+	{"CAUSE",	REGOFF(cause),		RINT|RRDONLY, 'X'},
+	{"BADVADDR",	REGOFF(badvaddr),	RINT|RRDONLY, 'X'},
+	{"TLBVIRT",	REGOFF(tlbvirt),	RINT|RRDONLY, 'X'},
+	{"HI",		REGOFF(hhi),		RINT|RRDONLY, 'Y'},
+	{"LO",		REGOFF(hlo),		RINT|RRDONLY, 'Y'},
+	{"PC",		PC,		RINT, 'X'},
+	{"SP",		SP,		RINT, 'X'},
+	{"R31",		R31,		RINT, 'Y'},
+	{"R30",		REGOFF(hr30),	RINT, 'Y'},
+	{"R28",		REGOFF(hr28),	RINT, 'Y'},
+	{"R27",		REGOFF(hr27),	RINT, 'Y'},
+	{"R26",		REGOFF(hr26),	RINT, 'Y'},
+	{"R25",		REGOFF(hr25),	RINT, 'Y'},
+	{"R24",		REGOFF(hr24),	RINT, 'Y'},
+	{"R23",		REGOFF(hr23),	RINT, 'Y'},
+	{"R22",		REGOFF(hr22),	RINT, 'Y'},
+	{"R21",		REGOFF(hr21),	RINT, 'Y'},
+	{"R20",		REGOFF(hr20),	RINT, 'Y'},
+	{"R19",		REGOFF(hr19),	RINT, 'Y'},
+	{"R18",		REGOFF(hr18),	RINT, 'Y'},
+	{"R17",		REGOFF(hr17),	RINT, 'Y'},
+	{"R16",		REGOFF(hr16),	RINT, 'Y'},
+	{"R15",		REGOFF(hr15),	RINT, 'Y'},
+	{"R14",		REGOFF(hr14),	RINT, 'Y'},
+	{"R13",		REGOFF(hr13),	RINT, 'Y'},
+	{"R12",		REGOFF(hr12),	RINT, 'Y'},
+	{"R11",		REGOFF(hr11),	RINT, 'Y'},
+	{"R10",		REGOFF(hr10),	RINT, 'Y'},
+	{"R9",		REGOFF(hr9),	RINT, 'Y'},
+	{"R8",		REGOFF(hr8),	RINT, 'Y'},
+	{"R7",		REGOFF(hr7),	RINT, 'Y'},
+	{"R6",		REGOFF(hr6),	RINT, 'Y'},
+	{"R5",		REGOFF(hr5),	RINT, 'Y'},
+	{"R4",		REGOFF(hr4),	RINT, 'Y'},
+	{"R3",		REGOFF(hr3),	RINT, 'Y'},
+	{"R2",		REGOFF(hr2),	RINT, 'Y'},
+	{"R1",		REGOFF(hr1),	RINT, 'Y'},
+	{"F0",		FP_REG(0),	RFLT, 'F'},
+	{"F1",		FP_REG(1),	RFLT, 'f'},
+	{"F2",		FP_REG(2),	RFLT, 'F'},
+	{"F3",		FP_REG(3),	RFLT, 'f'},
+	{"F4",		FP_REG(4),	RFLT, 'F'},
+	{"F5",		FP_REG(5),	RFLT, 'f'},
+	{"F6",		FP_REG(6),	RFLT, 'F'},
+	{"F7",		FP_REG(7),	RFLT, 'f'},
+	{"F8",		FP_REG(8),	RFLT, 'F'},
+	{"F9",		FP_REG(9),	RFLT, 'f'},
+	{"F10",		FP_REG(10),	RFLT, 'F'},
+	{"F11",		FP_REG(11),	RFLT, 'f'},
+	{"F12",		FP_REG(12),	RFLT, 'F'},
+	{"F13",		FP_REG(13),	RFLT, 'f'},
+	{"F14",		FP_REG(14),	RFLT, 'F'},
+	{"F15",		FP_REG(15),	RFLT, 'f'},
+	{"F16",		FP_REG(16),	RFLT, 'F'},
+	{"F17",		FP_REG(17),	RFLT, 'f'},
+	{"F18",		FP_REG(18),	RFLT, 'F'},
+	{"F19",		FP_REG(19),	RFLT, 'f'},
+	{"F20",		FP_REG(20),	RFLT, 'F'},
+	{"F21",		FP_REG(21),	RFLT, 'f'},
+	{"F22",		FP_REG(22),	RFLT, 'F'},
+	{"F23",		FP_REG(23),	RFLT, 'f'},
+	{"F24",		FP_REG(24),	RFLT, 'F'},
+	{"F25",		FP_REG(25),	RFLT, 'f'},
+	{"F26",		FP_REG(26),	RFLT, 'F'},
+	{"F27",		FP_REG(27),	RFLT, 'f'},
+	{"F28",		FP_REG(28),	RFLT, 'F'},
+	{"F29",		FP_REG(29),	RFLT, 'f'},
+	{"F30",		FP_REG(30),	RFLT, 'F'},
+	{"F31",		FP_REG(31),	RFLT, 'f'},
+	{"FPCR",	FP_REG(32),	RFLT, 'X'},
+	{  0 }
+};
+
+	/* the machine description */
+Mach mmips2be =
+{
+	"mips2",
+	MMIPS2,		/* machine type */
+	mips2reglist,	/* register set */
+	REGSIZE,	/* number of bytes in reg set */
+	FPREGSIZE,	/* number of bytes in fp reg set */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"R31",		/* name of link register */
+	"setR30",	/* static base register name */
+	0,		/* SB value */
+	0x1000,		/* page size */
+	0xC0000000,	/* kernel base */
+	0x40000000,	/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	8,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
+
+Mach mmips2le =
+{
+	"mips2",
+	NMIPS2,		/* machine type */
+	mips2reglist,	/* register set */
+	REGSIZE,	/* number of bytes in reg set */
+	FPREGSIZE,	/* number of bytes in fp reg set */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"R31",		/* name of link register */
+	"setR30",	/* static base register name */
+	0,		/* SB value */
+	0x1000,		/* page size */
+	0xC0000000,	/* kernel base */
+	0x40000000,	/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	8,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/4db.c b/utils/libmach/4db.c
new file mode 100644
index 00000000..d3fa97a4
--- /dev/null
+++ b/utils/libmach/4db.c
@@ -0,0 +1,57 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+/*
+ * Mips-specific debugger interface
+ */
+
+char	*mipsexcep(Map*, Rgetter);
+int	mipsfoll(Map*, ulong, Rgetter, ulong*);
+int	mipsinst(Map*, ulong, char, char*, int);
+int	mipsdas(Map*, ulong, char*, int);
+int	mipsinstlen(Map*, ulong);
+/*
+ *	Debugger interface
+ */
+Machdata mipsmach2be =
+{
+	{0, 0, 0, 0xD},		/* break point */
+	4,			/* break point size */
+
+	beswab,			/* short to local byte order */
+	beswal,			/* long to local byte order */
+	beswav,			/* vlong to local byte order */
+	risctrace,		/* C traceback */
+	riscframe,		/* Frame finder */
+	mipsexcep,		/* print exception */
+	0,			/* breakpoint fixup */
+	beieeesftos,		/* single precision float printer */
+	beieeedftos,		/* double precisioin float printer */
+	mipsfoll,		/* following addresses */
+	mipsinst,		/* print instruction */
+	mipsdas,		/* dissembler */
+	mipsinstlen,		/* instruction size */
+};
+
+/*
+ *	Debugger interface
+ */
+Machdata mipsmach2le =
+{
+	{0, 0, 0, 0xD},		/* 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 */
+	mipsexcep,		/* print exception */
+	0,			/* breakpoint fixup */
+	leieeesftos,		/* single precision float printer */
+	leieeedftos,		/* double precisioin float printer */
+	mipsfoll,		/* following addresses */
+	mipsinst,		/* print instruction */
+	mipsdas,		/* dissembler */
+	mipsinstlen,		/* instruction size */
+};
diff --git a/utils/libmach/5.c b/utils/libmach/5.c
new file mode 100644
index 00000000..1210d7f2
--- /dev/null
+++ b/utils/libmach/5.c
@@ -0,0 +1,64 @@
+/*
+ * arm definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "ureg5.h"
+#include "mach.h"
+
+
+#define	REGOFF(x)	(ulong) (&((struct Ureg *) 0)->x)
+
+#define SP		REGOFF(r13)
+#define PC		REGOFF(pc)
+
+#define	REGSIZE		sizeof(struct Ureg)
+
+Reglist armreglist[] =
+{
+	{"LINK",	REGOFF(link),		RINT|RRDONLY, 'X'},
+	{"TYPE",	REGOFF(type),		RINT|RRDONLY, 'X'},
+	{"PSR",		REGOFF(psr),		RINT|RRDONLY, 'X'},
+	{"PC",		PC,			RINT, 'X'},
+	{"SP",		SP,			RINT, 'X'},
+	{"R15",		PC,			RINT, 'X'},
+	{"R14",		REGOFF(r14),		RINT, 'X'},
+	{"R13",		REGOFF(r13),		RINT, 'X'},
+	{"R12",		REGOFF(r12),		RINT, 'X'},
+	{"R11",		REGOFF(r11),		RINT, 'X'},
+	{"R10",		REGOFF(r10),		RINT, 'X'},
+	{"R9",		REGOFF(r9),		RINT, 'X'},
+	{"R8",		REGOFF(r8),		RINT, 'X'},
+	{"R7",		REGOFF(r7),		RINT, 'X'},
+	{"R6",		REGOFF(r6),		RINT, 'X'},
+	{"R5",		REGOFF(r5),		RINT, 'X'},
+	{"R4",		REGOFF(r4),		RINT, 'X'},
+	{"R3",		REGOFF(r3),		RINT, 'X'},
+	{"R2",		REGOFF(r2),		RINT, 'X'},
+	{"R1",		REGOFF(r1),		RINT, 'X'},
+	{"R0",		REGOFF(r0),		RINT, 'X'},
+	{  0 }
+};
+
+	/* the machine description */
+Mach marm =
+{
+	"arm",
+	MARM,		/* machine type */
+	armreglist,	/* register set */
+	REGSIZE,	/* register set size */
+	0,		/* fp register set size */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"R15",		/* name of link register */
+	"setR12",	/* static base register name */
+	0,		/* static base register value */
+	0x1000,		/* page size */
+	0xC0000000,	/* kernel base */
+	0,		/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/5db.c b/utils/libmach/5db.c
new file mode 100644
index 00000000..1a125042
--- /dev/null
+++ b/utils/libmach/5db.c
@@ -0,0 +1,1063 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+static int debug = 0;
+
+#define	BITS(a, b)	((1<<(b+1))-(1<<a))
+
+#define LSR(v, s)	((ulong)(v) >> (s))
+#define ASR(v, s)	((long)(v) >> (s))
+#define ROR(v, s)	(LSR((v), (s)) | (((v) & ((1 << (s))-1)) << (32 - (s))))
+
+
+
+typedef struct	Instr	Instr;
+struct	Instr
+{
+	Map	*map;
+	ulong	w;
+	ulong	addr;
+	uchar	op;			/* super opcode */
+
+	uchar	cond;			/* bits 28-31 */
+	uchar	store;			/* bit 20 */
+
+	uchar	rd;			/* bits 12-15 */
+	uchar	rn;			/* bits 16-19 */
+	uchar	rs;			/* bits 0-11 (shifter operand) */
+
+	long	imm;			/* rotated imm */
+	char*	curr;			/* fill point in buffer */
+	char*	end;			/* end of buffer */
+	char*	err;			/* error message */
+};
+
+typedef struct Opcode Opcode;
+struct Opcode
+{
+	char*	o;
+	void	(*fmt)(Opcode*, Instr*);
+	ulong	(*foll)(Map*, Rgetter, Instr*, ulong);
+	char*	a;
+};
+
+static	void	format(char*, Instr*, char*);
+static	char	FRAMENAME[] = ".frame";
+
+/*
+ * Arm-specific debugger interface
+ */
+
+extern	char	*armexcep(Map*, Rgetter);
+static	int	armfoll(Map*, ulong, Rgetter, ulong*);
+static	int	arminst(Map*, ulong, char, char*, int);
+static	int	armdas(Map*, ulong, char*, int);
+static	int	arminstlen(Map*, ulong);
+
+/*
+ *	Debugger interface
+ */
+Machdata armmach =
+{
+	{0, 0, 0, 0xD},		/* break point */
+	4,			/* break point size */
+
+	leswab,			/* short to local byte order */
+	leswal,			/* long to local byte order */
+	leswav,			/* long to local byte order */
+	risctrace,		/* C traceback */
+	riscframe,		/* Frame finder */
+	armexcep,			/* print exception */
+	0,			/* breakpoint fixup */
+	0,			/* single precision float printer */
+	0,			/* double precision float printer */
+	armfoll,		/* following addresses */
+	arminst,		/* print instruction */
+	armdas,			/* dissembler */
+	arminstlen,		/* instruction size */
+};
+
+char*
+armexcep(Map *map, Rgetter rget)
+{
+	long c;
+
+	c = (*rget)(map, "TYPE");
+	switch (c&0x1f) {
+	case 0x11:
+		return "Fiq interrupt";
+	case 0x12:
+		return "Mirq interrupt";
+	case 0x13:
+		return "SVC/SWI Exception";
+	case 0x17:
+		return "Prefetch Abort/Data Abort";
+	case 0x18:
+		return "Data Abort";
+	case 0x1b:
+		return "Undefined instruction/Breakpoint";
+	case 0x1f:
+		return "Sys trap";
+	default:
+		return "Undefined trap";
+	}
+}
+
+static
+char*	cond[16] =
+{
+	"EQ",	"NE",	"CS",	"CC",
+	"MI",	"PL",	"VS",	"VC",
+	"HI",	"LS",	"GE",	"LT",
+	"GT",	"LE",	0,	"NV"
+};
+
+static
+char*	shtype[4] =
+{
+	"<<",	">>",	"->",	"@>"
+};
+
+static
+char *hb[4] =
+{
+	"???",	"HU", "B", "H"
+};
+
+static
+char*	addsub[2] =
+{
+	"-",	"+",
+};
+
+int
+armclass(long w)
+{
+	int op;
+
+	op = (w >> 25) & 0x7;
+	switch(op) {
+	case 0:	/* data processing r,r,r */
+		op = ((w >> 4) & 0xf);
+		if(op == 0x9) {
+			op = 48+16;		/* mul */
+			if(w & (1<<24)) {
+				op += 2;
+				if(w & (1<<22))
+					op++;	/* swap */
+				break;
+			}
+			if(w & (1<<21))
+				op++;		/* mla */
+			break;
+		}
+		if ((op & 0x9) == 0x9)		/* ld/st byte/half s/u */
+		{
+			op = (48+16+4) + ((w >> 22) & 0x1) + ((w >> 19) & 0x2);
+			break;
+		}
+		op = (w >> 21) & 0xf;
+		if(w & (1<<4))
+			op += 32;
+		else
+		if(w & (31<<7))
+			op += 16;
+		break;
+	case 1:	/* data processing i,r,r */
+		op = (48) + ((w >> 21) & 0xf);
+		break;
+	case 2:	/* load/store byte/word i(r) */
+		op = (48+24) + ((w >> 22) & 0x1) + ((w >> 19) & 0x2);
+		break;
+	case 3:	/* load/store byte/word (r)(r) */
+		op = (48+24+4) + ((w >> 22) & 0x1) + ((w >> 19) & 0x2);
+		break;
+	case 4:	/* block data transfer (r)(r) */
+		op = (48+24+4+4) + ((w >> 20) & 0x1);
+		break;
+	case 5:	/* branch / branch link */
+		op = (48+24+4+4+2) + ((w >> 24) & 0x1);
+		break;
+	case 7:	/* coprocessor crap */
+		op = (48+24+4+4+2+2) + ((w >> 3) & 0x2) + ((w >> 20) & 0x1);
+		break;
+	default:
+		op = (48+24+4+4+2+2+4);
+		break;
+	}
+	return op;
+}
+
+static int
+decode(Map *map, ulong pc, Instr *i)
+{
+	long w;
+
+	if(get4(map, pc, &w) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	i->w = w;
+	i->addr = pc;
+	i->cond = (w >> 28) & 0xF;
+	i->op = armclass(w);
+	i->map = map;
+	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);
+}
+
+static int
+plocal(Instr *i)
+{
+	char *reg;
+	Symbol s;
+	char *fn;
+	int class;
+	int offset;
+
+	if(!findsym(i->addr, CTEXT, &s)) {
+		if(debug)fprint(2,"fn not found @%lux: %r\n", i->addr);
+		return 0;
+	}
+	fn = s.name;
+	if (!findlocal(&s, FRAMENAME, &s)) {
+		if(debug)fprint(2,"%s.%s not found @%s: %r\n", fn, FRAMENAME, s.name);
+			return 0;
+	}
+	if(s.value > i->imm) {
+		class = CAUTO;
+		offset = s.value-i->imm;
+		reg = "(SP)";
+	} else {
+		class = CPARAM;
+		offset = i->imm-s.value-4;
+		reg = "(FP)";
+	}
+	if(!getauto(&s, offset, class, &s)) {
+		if(debug)fprint(2,"%s %s not found @%ux: %r\n", fn,
+			class == CAUTO ? " auto" : "param", offset);
+		return 0;
+	}
+	bprint(i, "%s%c%d%s", s.name, class == CPARAM ? '+' : '-', s.value, reg);
+	return 1;
+}
+
+/*
+ * Print value v as name[+offset]
+ */
+int
+gsymoff(char *buf, int n, long v, int space)
+{
+	Symbol s;
+	int r;
+	long delta;
+
+	r = delta = 0;		/* to shut compiler up */
+	if (v) {
+		r = findsym(v, space, &s);
+		if (r)
+			delta = v-s.value;
+		if (delta < 0)
+			delta = -delta;
+	}
+	if (v == 0 || r == 0 || delta >= 4096)
+		return snprint(buf, n, "#%lux", v);
+	if (strcmp(s.name, ".string") == 0)
+		return snprint(buf, n, "#%lux", v);
+	if (!delta)
+		return snprint(buf, n, "%s", s.name);
+	if (s.type != 't' && s.type != 'T')
+		return snprint(buf, n, "%s+%lux", s.name, v-s.value);
+	else
+		return snprint(buf, n, "#%lux", v);
+}
+
+static void
+armdps(Opcode *o, Instr *i)
+{
+	i->store = (i->w >> 20) & 1;
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+	i->rs = (i->w >> 0) & 0xf;
+	if(i->rn == 15 && i->rs == 0) {
+		if(i->op == 8) {
+			format("MOVW", i,"CPSR, R%d");
+			return;
+		} else
+		if(i->op == 10) {
+			format("MOVW", i,"SPSR, R%d");
+			return;
+		}
+	} else
+	if(i->rn == 9 && i->rd == 15) {
+		if(i->op == 9) {
+			format("MOVW", i, "R%s, CPSR");
+			return;
+		} else
+		if(i->op == 11) {
+			format("MOVW", i, "R%s, SPSR");
+			return;
+		}
+	}
+	format(o->o, i, o->a);
+}
+
+static void
+armdpi(Opcode *o, Instr *i)
+{
+	ulong v;
+	int c;
+
+	v = (i->w >> 0) & 0xff;
+	c = (i->w >> 8) & 0xf;
+	while(c) {
+		v = (v<<30) | (v>>2);
+		c--;
+	}
+	i->imm = v;
+	i->store = (i->w >> 20) & 1;
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+	i->rs = i->w&0x0f;
+
+		/* RET is encoded as ADD #0,R14,R15 */
+	if((i->w & 0x0fffffff) == 0x028ef000){
+		format("RET%C", i, "");
+		return;
+	}
+	if((i->w & 0x0ff0ffff) == 0x0280f000){
+		format("B%C", i, "0(R%n)");
+		return;
+	}
+	format(o->o, i, o->a);
+}
+
+static void
+armsdti(Opcode *o, Instr *i)
+{
+	ulong v;
+
+	v = i->w & 0xfff;
+	if(!(i->w & (1<<23)))
+		v = -v;
+	i->store = ((i->w >> 23) & 0x2) | ((i->w >>21) & 0x1);
+	i->imm = v;
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+		/* RET is encoded as LW.P x,R13,R15 */
+	if ((i->w & 0x0ffff000) == 0x049df000)
+	{
+		format("RET%C%p", i, "%I");
+		return;
+	}
+	format(o->o, i, o->a);
+}
+
+/* arm V4 ld/st halfword, signed byte */
+static void
+armhwby(Opcode *o, Instr *i)
+{
+	i->store = ((i->w >> 23) & 0x2) | ((i->w >>21) & 0x1);
+	i->imm = (i->w & 0xf) | ((i->w >> 8) & 0xf);
+	if (!(i->w & (1 << 23)))
+		i->imm = - i->imm;
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+	i->rs = (i->w >> 0) & 0xf;
+	format(o->o, i, o->a);
+}
+
+static void
+armsdts(Opcode *o, Instr *i)
+{
+	i->store = ((i->w >> 23) & 0x2) | ((i->w >>21) & 0x1);
+	i->rs = (i->w >> 0) & 0xf;
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+	format(o->o, i, o->a);
+}
+
+static void
+armbdt(Opcode *o, Instr *i)
+{
+	i->store = (i->w >> 21) & 0x3;		/* S & W bits */
+	i->rn = (i->w >> 16) & 0xf;
+	i->imm = i->w & 0xffff;
+	if(i->w == 0xe8fd8000)
+		format("RFE", i, "");
+	else
+		format(o->o, i, o->a);
+}
+
+static void
+armund(Opcode *o, Instr *i)
+{
+	format(o->o, i, o->a);
+}
+
+static void
+armcdt(Opcode *o, Instr *i)
+{
+	format(o->o, i, o->a);
+}
+
+static void
+armunk(Opcode *o, Instr *i)
+{
+	format(o->o, i, o->a);
+}
+
+static void
+armb(Opcode *o, Instr *i)
+{
+	ulong v;
+
+	v = i->w & 0xffffff;
+	if(v & 0x800000)
+		v |= ~0xffffff;
+	i->imm = (v<<2) + i->addr + 8;
+	format(o->o, i, o->a);
+}
+
+static void
+armco(Opcode *o, Instr *i)		/* coprocessor instructions */
+{
+	int op, p, cp;
+
+	char buf[1024];
+
+	i->rn = (i->w >> 16) & 0xf;
+	i->rd = (i->w >> 12) & 0xf;
+	i->rs = i->w&0xf;
+	cp = (i->w >> 8) & 0xf;
+	p = (i->w >> 5) & 0x7;
+	if(i->w&(1<<4)) {
+		op = (i->w >> 21) & 0x07;
+		snprint(buf, sizeof(buf), "#%x, #%x, R%d, C(%d), C(%d), #%x\n", cp, op, i->rd, i->rn, i->rs, p);
+	} else {
+		op = (i->w >> 20) & 0x0f;
+		snprint(buf, sizeof(buf), "#%x, #%x, C(%d), C(%d), C(%d), #%x\n", cp, op, i->rd, i->rn, i->rs, p);
+	}
+	format(o->o, i, buf);
+}
+
+static int
+armcondpass(Map *map, Rgetter rget, uchar cond)
+{
+	ulong psr;
+	uchar n;
+	uchar z;
+	uchar c;
+	uchar v;
+
+	psr = rget(map, "PSR");
+	n = (psr >> 31) & 1;
+	z = (psr >> 30) & 1;
+	c = (psr >> 29) & 1;
+	v = (psr >> 28) & 1;
+
+	switch(cond) {
+		case 0:		return z;
+		case 1:		return !z;
+		case 2:		return c;
+		case 3:		return !c;
+		case 4:		return n;
+		case 5:		return !n;
+		case 6:		return v;
+		case 7:		return !v;
+		case 8:		return c && !z;
+		case 9:		return !c || z;
+		case 10:	return n == v;
+		case 11:	return n != v;
+		case 12:	return !z && (n == v);
+		case 13:	return z && (n != v);
+		case 14:	return 1;
+		case 15:	return 0;
+	}
+	return 0;
+}
+
+static ulong
+armshiftval(Map *map, Rgetter rget, Instr *i)
+{
+	if(i->w & (1 << 25)) {				/* immediate */
+		ulong imm = i->w & BITS(0, 7);
+		ulong s = (i->w & BITS(8, 11)) >> 7; /* this contains the *2 */
+		return ROR(imm, s);
+	} else {
+		char buf[8];
+		ulong v;
+		ulong s = (i->w & BITS(7,11)) >> 7;
+
+		sprint(buf, "R%ld", i->w & 0xf);
+		v = rget(map, buf);
+
+		switch((i->w & BITS(4, 6)) >> 4) {
+		case 0:					/* LSLIMM */
+			return v << s;
+		case 1:					/* LSLREG */
+			sprint(buf, "R%lud", s >> 1);
+			s = rget(map, buf) & 0xFF;
+			if(s >= 32) return 0;
+			return v << s;
+		case 2:					/* LSRIMM */
+			return LSR(v, s);
+		case 3:					/* LSRREG */
+			sprint(buf, "R%ld", s >> 1);
+			s = rget(map, buf) & 0xFF;
+			if(s >= 32) return 0;
+			return LSR(v, s);
+		case 4:					/* ASRIMM */
+			if(s == 0) {
+				if((v & (1U<<31)) == 0)
+					return 0;
+				return 0xFFFFFFFF;
+			}
+			return ASR(v, s);
+		case 5:					/* ASRREG */
+			sprint(buf, "R%ld", s >> 1);
+			s = rget(map, buf) & 0xFF;
+			if(s >= 32) {
+				if((v & (1U<<31)) == 0)
+					return 0;
+				return 0xFFFFFFFF;
+			}
+			return ASR(v, s);
+		case 6:					/* RORIMM */
+			if(s == 0) {
+				ulong c = (rget(map, "PSR") >> 29) & 1;
+
+				return (c << 31) | LSR(v, 1);
+			}
+			return ROR(v, s);
+		case 7:					/* RORREG */
+			sprint(buf, "R%ld", (s>>1)&0xF);
+			s = rget(map, buf);
+			if(s == 0 || (s & 0xF) == 0)
+				return v;
+			return ROR(v, s & 0xF);
+		}
+	}
+	return 0;
+}
+
+static int
+nbits(ulong v)
+{
+	int n = 0;
+	int i;
+
+	for(i=0; i < 32 ; i++) {
+		if(v & 1) ++n;
+		v >>= 1;
+	}
+
+	return n;
+}
+
+static ulong
+armmaddr(Map *map, Rgetter rget, Instr *i)
+{
+	ulong v;
+	ulong nb;
+	char buf[8];
+	ulong rn;
+
+	rn = (i->w >> 16) & 0xf;
+	sprint(buf,"R%ld", rn);
+
+	v = rget(map, buf);
+	nb = nbits(i->w & ((1 << 15) - 1));
+
+	switch((i->w >> 23) & 3) {
+		case 0: return (v - (nb*4)) + 4;
+		case 1: return v;
+		case 2: return v - (nb*4);
+		case 3: return v + 4;
+	}
+	return 0;
+}
+
+static ulong
+armaddr(Map *map, Rgetter rget, Instr *i)
+{
+	char buf[8];
+	ulong rn;
+
+	sprint(buf, "R%ld", (i->w >> 16) & 0xf);
+	rn = rget(map, buf);
+
+	if((i->w & (1<<24)) == 0) {			/* POSTIDX */
+		sprint(buf, "R%ld", rn);
+		return rget(map, buf);
+	}
+
+	if((i->w & (1<<25)) == 0) {			/* OFFSET */
+		sprint(buf, "R%ld", rn);
+		if(i->w & (1U<<23))
+			return rget(map, buf) + (i->w & BITS(0,11));
+		return rget(map, buf) - (i->w & BITS(0,11));
+	} else {					/* REGOFF */
+		ulong index = 0;
+		uchar c;
+		uchar rm;
+
+		sprint(buf, "R%ld", i->w & 0xf);
+		rm = rget(map, buf);
+
+		switch((i->w & BITS(5,6)) >> 5) {
+		case 0: index = rm << ((i->w & BITS(7,11)) >> 7);	break;
+		case 1: index = LSR(rm, ((i->w & BITS(7,11)) >> 7));	break;
+		case 2: index = ASR(rm, ((i->w & BITS(7,11)) >> 7));	break;
+		case 3:
+			if((i->w & BITS(7,11)) == 0) {
+				c = (rget(map, "PSR") >> 29) & 1;
+				index = c << 31 | LSR(rm, 1);
+			} else {
+				index = ROR(rm, ((i->w & BITS(7,11)) >> 7));
+			}
+			break;
+		}
+		if(i->w & (1<<23))
+			return rn + index;
+		return rn - index;
+	}
+}
+
+static ulong
+armfadd(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	char buf[8];
+	int r;
+
+	r = (i->w >> 12) & 0xf;
+	if(r != 15 || !armcondpass(map, rget, (i->w >> 28) & 0xf))
+		return pc+4;
+
+	r = (i->w >> 16) & 0xf;
+	sprint(buf, "R%d", r);
+
+	return rget(map, buf) + armshiftval(map, rget, i);
+}
+
+static ulong
+armfmovm(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	ulong v;
+	ulong addr;
+
+	v = i->w & 1<<15;
+	if(!v || !armcondpass(map, rget, (i->w>>28)&0xf))
+		return pc+4;
+
+	addr = armmaddr(map, rget, i) + nbits(i->w & BITS(0,15));
+	if(get4(map, addr, (long*)&v) < 0) {
+		werrstr("can't read addr: %r");
+		return -1;
+	}
+	return v;
+}
+
+static ulong
+armfbranch(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	if(!armcondpass(map, rget, (i->w >> 28) & 0xf))
+		return pc+4;
+
+	return pc + (((signed long)i->w << 8) >> 6) + 8;
+}
+
+static ulong
+armfmov(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	ulong rd;
+	ulong v;
+
+	rd = (i->w >> 12) & 0xf;
+	if(rd != 15 || !armcondpass(map, rget, (i->w>>28)&0xf))
+		return pc+4;
+
+	 /* LDR */
+	/* BUG: Needs LDH/B, too */
+	if((i->w>>26)&0x3 == 1) {
+		if(get4(map, armaddr(map, rget, i), (long*)&v) < 0) {
+			werrstr("can't read instruction: %r");
+			return pc+4;
+		}
+		return v;
+	}
+
+	 /* MOV */
+	v = armshiftval(map, rget, i);
+
+	return v;
+}
+
+static Opcode opcodes[] =
+{
+	"AND%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"EOR%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"SUB%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"RSB%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"ADD%C%S",	armdps, armfadd,	"R%s,R%n,R%d",
+	"ADC%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"SBC%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"RSC%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"TST%C%S",	armdps, 0,	"R%s,R%n",
+	"TEQ%C%S",	armdps, 0,	"R%s,R%n",
+	"CMP%C%S",	armdps, 0,	"R%s,R%n",
+	"CMN%C%S",	armdps, 0,	"R%s,R%n",
+	"ORR%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"MOVW%C%S",	armdps, armfmov,	"R%s,R%d",
+	"BIC%C%S",	armdps, 0,	"R%s,R%n,R%d",
+	"MVN%C%S",	armdps, 0,	"R%s,R%d",
+
+/* 16 */
+	"AND%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"EOR%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"SUB%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"RSB%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"ADD%C%S",	armdps, armfadd,	"(R%s%h%m),R%n,R%d",
+	"ADC%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"SBC%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"RSC%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"TST%C%S",	armdps, 0,	"(R%s%h%m),R%n",
+	"TEQ%C%S",	armdps, 0,	"(R%s%h%m),R%n",
+	"CMP%C%S",	armdps, 0,	"(R%s%h%m),R%n",
+	"CMN%C%S",	armdps, 0,	"(R%s%h%m),R%n",
+	"ORR%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"MOVW%C%S",	armdps, armfmov,	"(R%s%h%m),R%d",
+	"BIC%C%S",	armdps, 0,	"(R%s%h%m),R%n,R%d",
+	"MVN%C%S",	armdps, 0,	"(R%s%h%m),R%d",
+
+/* 32 */
+	"AND%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"EOR%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"SUB%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"RSB%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"ADD%C%S",	armdps, armfadd,	"(R%s%hR%M),R%n,R%d",
+	"ADC%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"SBC%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"RSC%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"TST%C%S",	armdps, 0,	"(R%s%hR%M),R%n",
+	"TEQ%C%S",	armdps, 0,	"(R%s%hR%M),R%n",
+	"CMP%C%S",	armdps, 0,	"(R%s%hR%M),R%n",
+	"CMN%C%S",	armdps, 0,	"(R%s%hR%M),R%n",
+	"ORR%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"MOVW%C%S",	armdps, armfmov,	"(R%s%hR%M),R%d",
+	"BIC%C%S",	armdps, 0,	"(R%s%hR%M),R%n,R%d",
+	"MVN%C%S",	armdps, 0,	"(R%s%hR%M),R%d",
+
+/* 48 */
+	"AND%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"EOR%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"SUB%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"RSB%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"ADD%C%S",	armdpi, armfadd,	"$#%i,R%n,R%d",
+	"ADC%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"SBC%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"RSC%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"TST%C%S",	armdpi, 0,	"$#%i,R%n",
+	"TEQ%C%S",	armdpi, 0,	"$#%i,R%n",
+	"CMP%C%S",	armdpi, 0,	"$#%i,R%n",
+	"CMN%C%S",	armdpi, 0,	"$#%i,R%n",
+	"ORR%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"MOVW%C%S",	armdpi, armfmov,	"$#%i,R%d",
+	"BIC%C%S",	armdpi, 0,	"$#%i,R%n,R%d",
+	"MVN%C%S",	armdpi, 0,	"$#%i,R%d",
+
+/* 48+16 */
+	"MUL%C%S",	armdpi, 0,	"R%s,R%M,R%n",
+	"MULA%C%S",	armdpi, 0,	"R%s,R%M,R%n,R%d",
+	"SWPW",		armdpi, 0,	"R%s,(R%n),R%d",
+	"SWPB",		armdpi, 0,	"R%s,(R%n),R%d",
+
+/* 48+16+4 */
+	"MOV%u%C%p",	armhwby, 0,	"R%d,(R%n%UR%M)",
+	"MOV%u%C%p",	armhwby, 0,	"R%d,%I",
+	"MOV%u%C%p",	armhwby, armfmov,	"(R%n%UR%M),R%d",
+	"MOV%u%C%p",	armhwby, armfmov,	"%I,R%d",
+
+/* 48+24 */
+	"MOVW%C%p",	armsdti, 0,	"R%d,%I",
+	"MOVB%C%p",	armsdti, 0,	"R%d,%I",
+	"MOVW%C%p",	armsdti, armfmov,	"%I,R%d",
+	"MOVBU%C%p",	armsdti, armfmov,	"%I,R%d",
+
+	"MOVW%C%p",	armsdts, 0,	"R%d,(R%s%h%m)(R%n)",
+	"MOVB%C%p",	armsdts, 0,	"R%d,(R%s%h%m)(R%n)",
+	"MOVW%C%p",	armsdts, armfmov,	"(R%s%h%m)(R%n),R%d",
+	"MOVBU%C%p",	armsdts, armfmov,	"(R%s%h%m)(R%n),R%d",
+
+	"MOVM%C%P%a",	armbdt, armfmovm,		"[%r],(R%n)",
+	"MOVM%C%P%a",	armbdt, armfmovm,		"(R%n),[%r]",
+
+	"B%C",		armb, armfbranch,		"%b",
+	"BL%C",		armb, armfbranch,		"%b",
+
+	"CDP%C",	armco, 0,		"",
+	"CDP%C",	armco, 0,		"",
+	"MCR%C",	armco, 0,		"",
+	"MRC%C",	armco, 0,		"",
+
+	"UNK",		armunk, 0,	"",
+};
+
+static void
+gaddr(Instr *i)
+{
+	*i->curr++ = '$';
+	i->curr += gsymoff(i->curr, i->end-i->curr, i->imm, CANY);
+}
+
+static	char *mode[] = { 0, "IA", "DB", "IB" };
+static	char *pw[] = { "P", "PW", 0, "W" };
+static	char *sw[] = { 0, "W", "S", "SW" };
+
+static void
+format(char *mnemonic, Instr *i, char *f)
+{
+	int j, k, m, n;
+	int g;
+	char *fmt;
+
+	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 'C':	/* .CONDITION */
+			if(cond[i->cond])
+				bprint(i, ".%s", cond[i->cond]);
+			break;
+
+		case 'S':	/* .STORE */
+			if(i->store)
+				bprint(i, ".S");
+			break;
+
+		case 'P':	/* P & U bits for block move */
+			n = (i->w >>23) & 0x3;
+			if (mode[n])
+				bprint(i, ".%s", mode[n]);
+			break;
+
+		case 'p':	/* P & W bits for single data xfer*/
+			if (pw[i->store])
+				bprint(i, ".%s", pw[i->store]);
+			break;
+
+		case 'a':	/* S & W bits for single data xfer*/
+			if (sw[i->store])
+				bprint(i, ".%s", sw[i->store]);
+			break;
+
+		case 's':
+			bprint(i, "%d", i->rs & 0xf);
+			break;
+				
+		case 'M':
+			bprint(i, "%d", (i->w>>8) & 0xf);
+			break;
+				
+		case 'm':
+			bprint(i, "%d", (i->w>>7) & 0x1f);
+			break;
+
+		case 'h':
+			bprint(i, shtype[(i->w>>5) & 0x3]);
+			break;
+
+		case 'u':		/* Signed/unsigned Byte/Halfword */
+			bprint(i, hb[(i->w>>5) & 0x3]);
+			break;
+
+		case 'I':
+			if (i->rn == 13) {
+				if (plocal(i))
+					break;
+			}
+			g = 0;
+			fmt = "#%lx(R%d)";
+			if (i->rn == 15) {
+				/* convert load of offset(PC) to a load immediate */
+				if (get4(i->map, i->addr+i->imm+8, &i->imm) > 0)
+				{
+					g = 1;
+					fmt = "";
+				}
+			}
+			if (mach->sb)
+			{
+				if (i->rd == 11) {
+					ulong nxti;
+
+					if (get4(i->map, i->addr+4, (long*)&nxti) > 0) {
+						if ((nxti & 0x0e0f0fff) == 0x060c000b) {
+							i->imm += mach->sb;
+							g = 1;
+							fmt = "-SB";
+						}
+					}
+				}
+				if (i->rn == 12)
+				{
+					i->imm += mach->sb;
+					g = 1;
+					fmt = "-SB(SB)";
+				}
+			}
+			if (g)
+			{
+				gaddr(i);
+				bprint(i, fmt, i->rn);
+			}
+			else
+				bprint(i, fmt, i->imm, i->rn);
+			break;
+		case 'U':		/* Add/subtract from base */
+			bprint(i, addsub[(i->w >> 23) & 1]);
+			break;
+
+		case 'n':
+			bprint(i, "%d", i->rn);
+			break;
+
+		case 'd':
+			bprint(i, "%d", i->rd);
+			break;
+
+		case 'i':
+			bprint(i, "%lux", i->imm);
+			break;
+
+		case 'b':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				i->imm, CTEXT);
+			break;
+
+		case 'g':
+			i->curr += gsymoff(i->curr, i->end-i->curr,
+				i->imm, CANY);
+			break;
+
+		case 'r':
+			n = i->imm&0xffff;
+			j = 0;
+			k = 0;
+			while(n) {
+				m = j;
+				while(n&0x1) {
+					j++;
+					n >>= 1;
+				}
+				if(j != m) {
+					if(k)
+						bprint(i, ",");
+					if(j == m+1)
+						bprint(i, "R%d", m);
+					else
+						bprint(i, "R%d-R%d", m, j-1);
+					k = 1;
+				}
+				j++;
+				n >>= 1;
+			}
+			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;
+
+	i.curr = buf;
+	i.end = buf+n-1;
+	if(decode(map, pc, &i) < 0)
+		return -1;
+
+	(*opcodes[i.op].fmt)(&opcodes[i.op], &i);
+	return 4;
+}
+
+static int
+arminst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	USED(modifier);
+	return printins(map, pc, buf, n);
+}
+
+static int
+armdas(Map *map, ulong pc, char *buf, int n)
+{
+	Instr i;
+
+	i.curr = buf;
+	i.end = buf+n;
+	if(decode(map, pc, &i) < 0)
+		return -1;
+	if(i.end-i.curr > 8)
+		i.curr = _hexify(buf, i.w, 7);
+	*i.curr = 0;
+	return 4;
+}
+
+static int
+arminstlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	if(decode(map, pc, &i) < 0)
+		return -1;
+	return 4;
+}
+
+static int
+armfoll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	ulong d;
+	Instr i;
+
+	if(decode(map, pc, &i) < 0)
+		return -1;
+
+	if(opcodes[i.op].foll) {
+		d = (*opcodes[i.op].foll)(map, rget, &i, pc);
+		if(d == -1)
+			return -1;
+	} else
+		d = pc+4;
+
+	foll[0] = d;
+	return 1;
+}
diff --git a/utils/libmach/5obj.c b/utils/libmach/5obj.c
new file mode 100644
index 00000000..e7e3437c
--- /dev/null
+++ b/utils/libmach/5obj.c
@@ -0,0 +1,133 @@
+/*
+ * 5obj.c - identify and parse a arm object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "5c/5.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	type;
+	char	sym;
+	char	name;
+};
+static Addr addr(Biobuf*);
+static char type2char(int);
+static void skip(Biobuf*, int);
+
+int
+_is5(char *s)
+{
+	return  s[0] == ANAME				/* ANAME */
+		&& s[1] == D_FILE			/* type */
+		&& s[2] == 1				/* sym */
+		&& s[3] == '<';				/* name of file */
+}
+
+int
+_read5(Biobuf *bp, Prog *p)
+{
+	int as, n;
+	Addr a;
+
+	as = Bgetc(bp);			/* as */
+	if(as < 0)
+		return 0;
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 6);		/* scond(1), reg(1), lineno(4) */
+	a = addr(bp);
+	addr(bp);
+	if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	long off;
+
+	a.type = Bgetc(bp);	/* a.type */
+	skip(bp,1);		/* reg */
+	a.sym = Bgetc(bp);	/* sym index */
+	a.name = Bgetc(bp);	/* sym type */
+	switch(a.type){
+	default:
+	case D_NONE:
+	case D_REG:
+	case D_FREG:
+	case D_PSR:
+	case D_FPCR:
+		break;
+	case D_OREG:
+	case D_CONST:
+	case D_BRANCH:
+	case D_SHIFT:
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+		if(a.sym && (a.name==D_PARAM || a.name==D_AUTO))
+			_offset(a.sym, off);
+		break;
+	case D_SCONST:
+		skip(bp, NSNAME);
+		break;
+	case D_FCONST:
+		skip(bp, 8);
+		break;
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/6.c b/utils/libmach/6.c
new file mode 100644
index 00000000..28c74a43
--- /dev/null
+++ b/utils/libmach/6.c
@@ -0,0 +1,117 @@
+/*
+ * x86-amd64 definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "ureg6.h"
+#include "mach.h"
+
+#define	REGOFF(x)	(uvlong)(&((struct Ureg *) 0)->x)
+
+#define PC		REGOFF(pc)
+#define SP		REGOFF(sp)
+#define	AX		REGOFF(ax)
+
+#define	REGSIZE		sizeof(struct Ureg)
+#define FP_CTLS(x)	(REGSIZE+2*(x))
+#define FP_CTL(x)	(REGSIZE+4*(x))
+#define FP_REG(x)	(FP_CTL(8)+16*(x))
+#define XM_REG(x)	(FP_CTL(8)+8*16+16*(x))
+
+#define	FPREGSIZE	512	/* TO DO? currently only 0x1A0 used */
+
+Reglist amd64reglist[] = {
+	{"R15",		REGOFF(r15),	RINT, 'Y'},
+	{"R14",		REGOFF(r14),	RINT, 'Y'},
+	{"R13",		REGOFF(r13),	RINT, 'Y'},
+	{"R12",		REGOFF(r12),	RINT, 'Y'},
+	{"R11",		REGOFF(r11),	RINT, 'Y'},
+	{"R10",		REGOFF(r10),	RINT, 'Y'},
+	{"R9",		REGOFF(r9),	RINT, 'Y'},
+	{"R8",		REGOFF(r8),	RINT, 'Y'},
+	{"DI",		REGOFF(di),	RINT, 'X'},
+	{"SI",		REGOFF(si),	RINT, 'Y'},
+	{"BP",		REGOFF(bp),	RINT, 'Y'},
+	{"BX",		REGOFF(bx),	RINT, 'Y'},
+	{"DX",		REGOFF(dx),	RINT, 'Y'},
+	{"CX",		REGOFF(cx),	RINT, 'Y'},
+	{"AX",		REGOFF(ax),	RINT, 'Y'},
+	{"GS",		REGOFF(gs),	RINT, 'Y'},
+	{"FS",		REGOFF(fs),	RINT, 'Y'},
+	{"ES",		REGOFF(es),	RINT, 'Y'},
+	{"DS",		REGOFF(ds),	RINT, 'Y'},
+	{"TRAP",	REGOFF(trap), 	RINT, 'Y'},
+	{"ECODE",	REGOFF(ecode),	RINT, 'Y'},
+	{"PC",		PC,		RINT, 'Y'},
+	{"CS",		REGOFF(cs),	RINT, 'Y'},
+	{"EFLAGS",	REGOFF(flags),	RINT, 'Y'},
+	{"SP",		SP,		RINT, 'Y'},
+	{"SS",		REGOFF(ss),	RINT, 'Y'},
+
+	{"FCW",		FP_CTLS(0),	RFLT, 'x'},
+	{"FSW",		FP_CTLS(1),	RFLT, 'x'},
+	{"FTW",		FP_CTLS(2),	RFLT, 'x'},
+	{"FOP",		FP_CTLS(3),	RFLT, 'x'},
+	{"FPC",		FP_CTL(2),	RFLT, 'Y'},
+	{"RDP",		FP_CTL(4),	RFLT, 'Y'},
+	{"MXCSR",		FP_CTL(6),	RFLT, 'X'},
+	{"MXCSRMSK",	FP_CTL(7),	RFLT, 'X'},
+	{"M0",		FP_REG(0),	RFLT, 'F'},	/* assumes double */
+	{"M1",		FP_REG(1),	RFLT, 'F'},
+	{"M2",		FP_REG(2),	RFLT, 'F'},
+	{"M3",		FP_REG(3),	RFLT, 'F'},
+	{"M4",		FP_REG(4),	RFLT, 'F'},
+	{"M5",		FP_REG(5),	RFLT, 'F'},
+	{"M6",		FP_REG(6),	RFLT, 'F'},
+	{"M7",		FP_REG(7),	RFLT, 'F'},
+	{"X0",		XM_REG(0),	RFLT, 'F'},	/* assumes double */
+	{"X1",		XM_REG(1),	RFLT, 'F'},
+	{"X2",		XM_REG(2),	RFLT, 'F'},
+	{"X3",		XM_REG(3),	RFLT, 'F'},
+	{"X4",		XM_REG(4),	RFLT, 'F'},
+	{"X5",		XM_REG(5),	RFLT, 'F'},
+	{"X6",		XM_REG(6),	RFLT, 'F'},
+	{"X7",		XM_REG(7),	RFLT, 'F'},
+	{"X8",		XM_REG(8),	RFLT, 'F'},
+	{"X9",		XM_REG(9),	RFLT, 'F'},
+	{"X10",		XM_REG(10),	RFLT, 'F'},
+	{"X11",		XM_REG(11),	RFLT, 'F'},
+	{"X12",		XM_REG(12),	RFLT, 'F'},
+	{"X13",		XM_REG(13),	RFLT, 'F'},
+	{"X14",		XM_REG(14),	RFLT, 'F'},
+	{"X15",		XM_REG(15),	RFLT, 'F'},
+	{"X16",		XM_REG(16),	RFLT, 'F'},
+/*
+	{"F0",		FP_REG(7),	RFLT, '3'},
+	{"F1",		FP_REG(6),	RFLT, '3'},
+	{"F2",		FP_REG(5),	RFLT, '3'},
+	{"F3",		FP_REG(4),	RFLT, '3'},
+	{"F4",		FP_REG(3),	RFLT, '3'},
+	{"F5",		FP_REG(2),	RFLT, '3'},
+	{"F6",		FP_REG(1),	RFLT, '3'},
+	{"F7",		FP_REG(0),	RFLT, '3'},
+*/
+	{  0 }
+};
+
+Mach mamd64=
+{
+	"amd64",
+	MI386,		/* machine type */	/* TO DO */
+	amd64reglist,	/* register list */
+	REGSIZE,	/* size of registers in bytes */
+	FPREGSIZE,	/* size of fp registers in bytes */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	0,		/* link register */
+	"setSB",	/* static base register name (bogus anyways) */
+	0,		/* static base register value */
+	0x1000,		/* page size */
+	0x80100000,	/* kernel base */	/* TO DO: uvlong or vlong */
+	0,		/* kernel text mask */
+	1,		/* quantization of pc */
+	8,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/6obj.c b/utils/libmach/6obj.c
new file mode 100644
index 00000000..7fb95115
--- /dev/null
+++ b/utils/libmach/6obj.c
@@ -0,0 +1,142 @@
+/*
+ * 6obj.c - identify and parse an amd64 object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "6c/6.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	sym;
+	char	flags;
+};
+static	Addr	addr(Biobuf*);
+static	char	type2char(int);
+static	void	skip(Biobuf*, int);
+
+int
+_is6(char *t)
+{
+	uchar *s = (uchar*)t;
+
+	return  s[0] == (ANAME&0xff)			/* aslo = ANAME */
+		&& s[1] == ((ANAME>>8)&0xff)
+		&& s[2] == D_FILE			/* type */
+		&& s[3] == 1				/* sym */
+		&& s[4] == '<';				/* name of file */
+}
+
+int
+_read6(Biobuf *bp, Prog* p)
+{
+	int as, n, c;
+	Addr a;
+
+	as = Bgetc(bp);		/* as(low) */
+	if(as < 0)
+		return 0;
+	c = Bgetc(bp);		/* as(high) */
+	if(c < 0)
+		return 0;
+	as |= ((c & 0xff) << 8);
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 4);		/* lineno(4) */
+	a = addr(bp);
+	addr(bp);
+	if(!(a.flags & T_SYM))
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	int t;
+	long l;
+	vlong off;
+
+	off = 0;
+	a.sym = -1;
+	a.flags = Bgetc(bp);			/* flags */
+	if(a.flags & T_INDEX)
+		skip(bp, 2);
+	if(a.flags & T_OFFSET){
+		l = Bgetc(bp);
+		l |= Bgetc(bp) << 8;
+		l |= Bgetc(bp) << 16;
+		l |= Bgetc(bp) << 24;
+		off = l;
+		if(a.flags & T_64){
+			l = Bgetc(bp);
+			l |= Bgetc(bp) << 8;
+			l |= Bgetc(bp) << 16;
+			l |= Bgetc(bp) << 24;
+			off = ((vlong)l << 32) | (off & 0xFFFFFFFF);
+		}
+		if(off < 0)
+			off = -off;
+	}
+	if(a.flags & T_SYM)
+		a.sym = Bgetc(bp);
+	if(a.flags & T_FCONST)
+		skip(bp, 8);
+	else
+	if(a.flags & T_SCONST)
+		skip(bp, NSNAME);
+	if(a.flags & T_TYPE) {
+		t = Bgetc(bp);
+		if(a.sym > 0 && (t==D_PARAM || t==D_AUTO))
+			_offset(a.sym, off);
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/8.c b/utils/libmach/8.c
new file mode 100644
index 00000000..9c7bff11
--- /dev/null
+++ b/utils/libmach/8.c
@@ -0,0 +1,78 @@
+/*
+ * 386 definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "ureg8.h"
+#include "mach.h"
+
+#define	REGOFF(x)	(ulong)(&((struct Ureg *) 0)->x)
+
+#define PC		REGOFF(pc)
+#define SP		REGOFF(u0.sp)
+#define	AX		REGOFF(ax)
+
+#define	REGSIZE		sizeof(struct Ureg)
+#define FP_CTL(x)	(REGSIZE+4*(x))
+#define FP_REG(x)	(FP_CTL(7)+10*(x))
+#define	FPREGSIZE	(6*4+8*10)
+
+Reglist i386reglist[] = {
+	{"DI",		REGOFF(di),	RINT, 'X'},
+	{"SI",		REGOFF(si),	RINT, 'X'},
+	{"BP",		REGOFF(bp),	RINT, 'X'},
+	{"BX",		REGOFF(bx),	RINT, 'X'},
+	{"DX",		REGOFF(dx),	RINT, 'X'},
+	{"CX",		REGOFF(cx),	RINT, 'X'},
+	{"AX",		REGOFF(ax),	RINT, 'X'},
+	{"GS",		REGOFF(gs),	RINT, 'X'},
+	{"FS",		REGOFF(fs),	RINT, 'X'},
+	{"ES",		REGOFF(es),	RINT, 'X'},
+	{"DS",		REGOFF(ds),	RINT, 'X'},
+	{"TRAP",	REGOFF(trap), 	RINT, 'X'},
+	{"ECODE",	REGOFF(ecode),	RINT, 'X'},
+	{"PC",		PC,		RINT, 'X'},
+	{"CS",		REGOFF(cs),	RINT, 'X'},
+	{"EFLAGS",	REGOFF(flags),	RINT, 'X'},
+	{"SP",		SP,		RINT, 'X'},
+	{"SS",		REGOFF(ss),	RINT, 'X'},
+
+	{"E0",		FP_CTL(0),	RFLT, 'X'},
+	{"E1",		FP_CTL(1),	RFLT, 'X'},
+	{"E2",		FP_CTL(2),	RFLT, 'X'},
+	{"E3",		FP_CTL(3),	RFLT, 'X'},
+	{"E4",		FP_CTL(4),	RFLT, 'X'},
+	{"E5",		FP_CTL(5),	RFLT, 'X'},
+	{"E6",		FP_CTL(6),	RFLT, 'X'},
+	{"F0",		FP_REG(7),	RFLT, '3'},
+	{"F1",		FP_REG(6),	RFLT, '3'},
+	{"F2",		FP_REG(5),	RFLT, '3'},
+	{"F3",		FP_REG(4),	RFLT, '3'},
+	{"F4",		FP_REG(3),	RFLT, '3'},
+	{"F5",		FP_REG(2),	RFLT, '3'},
+	{"F6",		FP_REG(1),	RFLT, '3'},
+	{"F7",		FP_REG(0),	RFLT, '3'},
+	{  0 }
+};
+
+Mach mi386 =
+{
+	"386",
+	MI386,		/* machine type */
+	i386reglist,	/* register list */
+	REGSIZE,	/* size of registers in bytes */
+	FPREGSIZE,	/* size of fp registers in bytes */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	0,		/* link register */
+	"setSB",	/* static base register name (bogus anyways) */
+	0,		/* static base register value */
+	0x1000,		/* page size */
+	0x80100000,	/* kernel base */
+	0,		/* kernel text mask */
+	1,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/8db.c b/utils/libmach/8db.c
new file mode 100644
index 00000000..86b6e1f2
--- /dev/null
+++ b/utils/libmach/8db.c
@@ -0,0 +1,1850 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+/*
+ * i386-specific debugger interface
+ */
+
+static	char	*i386excep(Map*, Rgetter);
+
+static	int	i386trace(Map*, ulong, ulong, ulong, Tracer);
+static	ulong	i386frame(Map*, ulong, ulong, ulong, ulong);
+static	int	i386foll(Map*, ulong, Rgetter, ulong*);
+static	int	i386inst(Map*, ulong, char, char*, int);
+static	int	i386das(Map*, ulong, char*, int);
+static	int	i386instlen(Map*, ulong);
+
+static	char	STARTSYM[] =	"_main";
+static	char	PROFSYM[] =	"_mainp";
+static	char	FRAMENAME[] =	".frame";
+static char *excname[] =
+{
+	"divide error",			/* 0 */
+	"debug exception",		/* 1 */
+	0,0,				/* 2, 3 */
+	"overflow",			/* 4 */
+	"bounds check",			/* 5 */
+	"invalid opcode",		/* 6 */
+	"math coprocessor emulation",	/* 7 */
+	"double fault",			/* 8 */
+	"math coprocessor overrun",	/* 9 */
+	"invalid TSS",			/* 10 */
+	"segment not present",		/* 11 */
+	"stack exception",		/* 12 */
+	"general protection violation",	/* 13 */
+	"page fault",			/* 14 */
+	0,				/* 15 */
+	"math coprocessor error",	/* 16 */
+	0,0,0,0,0,0,0,			/* 17-23 */
+	"clock",			/* 24 */
+	"keyboard",			/* 25 */
+	0,				/* 26 */
+	"modem status",			/* 27 */
+	"serial line status",		/* 28 */
+	0,				/* 29 */
+	"floppy disk",			/* 30 */
+	0,0,0,0,0,			/* 31-35 */
+	"mouse",			/* 36 */
+	"math coprocessor",		/* 37 */
+	"hard disk",			/* 38 */
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,/* 39-54 */
+	0,0,0,0,0,0,0,0,0,		/* 55-63 */
+	"system call",			/* 64 */
+};
+
+Machdata i386mach =
+{
+	{0xCC, 0, 0, 0},	/* break point: INT 3 */
+	1,			/* break point size */
+
+	leswab,			/* convert short to local byte order */
+	leswal,			/* convert long to local byte order */
+	leswav,			/* convert vlong to local byte order */
+	i386trace,		/* C traceback */
+	i386frame,		/* frame finder */
+	i386excep,		/* print exception */
+	0,			/* breakpoint fixup */
+	leieeesftos,		/* single precision float printer */
+	leieeedftos,		/* double precision float printer */
+	i386foll,		/* following addresses */
+	i386inst,		/* print instruction */
+	i386das,		/* dissembler */
+	i386instlen,		/* instruction size calculation */
+};
+
+static char*
+i386excep(Map *map, Rgetter rget)
+{
+	ulong c;
+	ulong pc;
+	static char buf[16];
+
+	c = (*rget)(map, "TRAP");
+	if(c > 64 || excname[c] == 0) {
+		if (c == 3) {
+			pc = (*rget)(map, "PC");
+			if (get1(map, pc, (uchar*)buf, machdata->bpsize) > 0)
+			if (memcmp(buf, machdata->bpinst, machdata->bpsize) == 0)
+				return "breakpoint";
+		}
+		sprint(buf, "exception %ld", c);
+		return buf;
+	} else
+		return excname[c];
+}
+
+static int
+i386trace(Map *map, ulong pc, ulong sp, ulong link, Tracer trace)
+{
+	int i;
+	ulong osp;
+	Symbol s, f;
+
+	USED(link);
+	i = 0;
+	osp = 0;
+	while(findsym(pc, CTEXT, &s)) {
+		if (osp == sp)
+			break;
+		osp = sp;
+
+		if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
+			break;
+
+		if(pc != s.value) {	/* not at first instruction */
+			if(findlocal(&s, FRAMENAME, &f) == 0)
+				break;
+			sp += f.value-mach->szaddr;
+		}
+
+		if (get4(map, sp, (long *) &pc) < 0)
+			break;
+
+		if(pc == 0)
+			break;
+
+		(*trace)(map, pc, sp, &s);
+		sp += mach->szaddr;
+
+		if(++i > 40)
+			break;
+	}
+	return i;
+}
+
+static ulong
+i386frame(Map *map, ulong addr, ulong pc, ulong sp, ulong link)
+{
+	Symbol s, f;
+
+	USED(link);
+	while (findsym(pc, CTEXT, &s)) {
+		if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
+			break;
+
+		if(pc != s.value) {	/* not first instruction */
+			if(findlocal(&s, FRAMENAME, &f) == 0)
+				break;
+			sp += f.value-mach->szaddr;
+		}
+
+		if (s.value == addr)
+			return sp;
+
+		if (get4(map, sp, (long *)&pc) < 0)
+			break;
+		sp += mach->szaddr;
+	}
+	return 0;
+}
+
+	/* I386/486 - Disassembler and related functions */
+
+/*
+ *  an instruction
+ */
+typedef struct Instr Instr;
+struct	Instr
+{
+	uchar	mem[1+1+1+1+2+1+1+4+4];		/* raw instruction */
+	ulong	addr;		/* address of start of instruction */
+	int	n;		/* number of bytes in instruction */
+	char	*prefix;	/* instr prefix */
+	char	*segment;	/* segment override */
+	uchar	jumptype;	/* set to the operand type for jump/ret/call */
+	char	osize;		/* 'W' or 'L' */
+	char	asize;		/* address size 'W' or 'L' */
+	uchar	mod;		/* bits 6-7 of mod r/m field */
+	uchar	reg;		/* bits 3-5 of mod r/m field */
+	char	ss;		/* bits 6-7 of SIB */
+	char	index;		/* bits 3-5 of SIB */
+	char	base;		/* bits 0-2 of SIB */
+	short	seg;		/* segment of far address */
+	ulong	disp;		/* displacement */
+	ulong 	imm;		/* immediate */
+	ulong 	imm2;		/* second immediate operand */
+	char	*curr;		/* fill level in output buffer */
+	char	*end;		/* end of output buffer */
+	char	*err;		/* error message */
+};
+
+	/* 386 register (ha!) set */
+enum{
+	AX=0,
+	CX,
+	DX,
+	BX,
+	SP,
+	BP,
+	SI,
+	DI,
+};
+	/* Operand Format codes */
+/*
+%A	-	address size register modifier (!asize -> 'E')
+%C	-	Control register CR0/CR1/CR2
+%D	-	Debug register DR0/DR1/DR2/DR3/DR6/DR7
+%I	-	second immediate operand
+%O	-	Operand size register modifier (!osize -> 'E')
+%T	-	Test register TR6/TR7
+%S	-	size code ('W' or 'L')
+%X	-	Weird opcode: OSIZE == 'W' => "CBW"; else => "CWDE"
+%d	-	displacement 16-32 bits
+%e	-	effective address - Mod R/M value
+%f	-	floating point register F0-F7 - from Mod R/M register
+%g	-	segment register
+%i	-	immediate operand 8-32 bits
+%p	-	PC-relative - signed displacement in immediate field
+%r	-	Reg from Mod R/M
+%x	-	Weird opcode: OSIZE == 'W' => "CWD"; else => "CDQ"
+*/
+
+typedef struct Optable Optable;
+struct Optable
+{
+	char	operand[2];
+	void	*proto;		/* actually either (char*) or (Optable*) */
+};
+	/* Operand decoding codes */
+enum {
+	Ib = 1,			/* 8-bit immediate - (no sign extension)*/
+	Ibs,			/* 8-bit immediate (sign extended) */
+	Jbs,			/* 8-bit sign-extended immediate in jump or call */
+	Iw,			/* 16-bit immediate -> imm */
+	Iw2,			/* 16-bit immediate -> imm2 */
+	Iwd,			/* Operand-sized immediate (no sign extension)*/
+	Awd,			/* Address offset */
+	Iwds,			/* Operand-sized immediate (sign extended) */
+	RM,			/* Word or long R/M field with register (/r) */
+	RMB,			/* Byte R/M field with register (/r) */
+	RMOP,			/* Word or long R/M field with op code (/digit) */
+	RMOPB,			/* Byte R/M field with op code (/digit) */
+	RMR,			/* R/M register only (mod = 11) */
+	RMM,			/* R/M memory only (mod = 0/1/2) */
+	R0,			/* Base reg of Mod R/M is literal 0x00 */
+	R1,			/* Base reg of Mod R/M is literal 0x01 */
+	FRMOP,			/* Floating point R/M field with opcode */
+	FRMEX,			/* Extended floating point R/M field with opcode */
+	JUMP,			/* Jump or Call flag - no operand */
+	RET,			/* Return flag - no operand */
+	OA,			/* literal 0x0a byte */
+	PTR,			/* Seg:Displacement addr (ptr16:16 or ptr16:32) */
+	AUX,			/* Multi-byte op code - Auxiliary table */
+	PRE,			/* Instr Prefix */
+	SEG,			/* Segment Prefix */
+	OPOVER,			/* Operand size override */
+	ADDOVER,		/* Address size override */
+};
+	
+static Optable optab0F00[8]=
+{
+	0,0,		"MOVW	LDT,%e",	/* 0x00 */
+	0,0,		"MOVW	TR,%e",		/* 0x01 */
+	0,0,		"MOVW	%e,LDT",	/* 0x02 */
+	0,0,		"MOVW	%e,TR",		/* 0x03 */
+	0,0,		"VERR	%e",		/* 0x04 */
+	0,0,		"VERW	%e",		/* 0x05 */
+};
+
+static Optable optab0F01[8]=
+{
+	0,0,		"MOVL	GDTR,%e",	/* 0x00 */
+	0,0,		"MOVL	IDTR,%e",	/* 0x01 */
+	0,0,		"MOVL	%e,GDTR",	/* 0x02 */
+	0,0,		"MOVL	%e,IDTR",	/* 0x03 */
+	0,0,		"MOVW	MSW,%e",	/* 0x04 */	/* word */
+	0,0,		"",			/* 0x05 */
+	0,0,		"MOVW	%e,MSW",	/* 0x06 */	/* word */
+};
+
+static Optable optab0FBA[8]=
+{
+	0,0,		"",			/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"",			/* 0x02 */
+	0,0,		"",			/* 0x03 */
+	Ib,0,		"BT%S	%i,%e",		/* 0x04 */
+	Ib,0,		"BTS%S	%i,%e",		/* 0x05 */
+	Ib,0,		"BTR%S	%i,%e",		/* 0x06 */
+	Ib,0,		"BTC%S	%i,%e",		/* 0x07 */
+};
+
+static Optable optab0F[256]=
+{
+	RMOP,0,		optab0F00,		/* 0x00 */
+	RMOP,0,		optab0F01,		/* 0x01 */
+	RM,0,		"LAR	%e,%r",		/* 0x02 */
+	RM,0,		"LSL	%e,%r",		/* 0x03 */
+	0,0,		"",			/* 0x04 */
+	0,0,		"",			/* 0x05 */
+	0,0,		"CLTS",			/* 0x06 */
+	0,0,		"",			/* 0x07 */
+	0,0,		"INVD",			/* 0x08 */
+	0,0,		"WBINVD",		/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	0,0,		"",			/* 0x0b */
+	0,0,		"",			/* 0x0c */
+	0,0,		"",			/* 0x0d */
+	0,0,		"",			/* 0x0e */
+	0,0,		"",			/* 0x0f */
+	0,0,		"",			/* 0x10 */
+	0,0,		"",			/* 0x11 */
+	0,0,		"",			/* 0x12 */
+	0,0,		"",			/* 0x13 */
+	0,0,		"",			/* 0x14 */
+	0,0,		"",			/* 0x15 */
+	0,0,		"",			/* 0x16 */
+	0,0,		"",			/* 0x17 */
+	0,0,		"",			/* 0x18 */
+	0,0,		"",			/* 0x19 */
+	0,0,		"",			/* 0x1a */
+	0,0,		"",			/* 0x1b */
+	0,0,		"",			/* 0x1c */
+	0,0,		"",			/* 0x1d */
+	0,0,		"",			/* 0x1e */
+	0,0,		"",			/* 0x1f */
+	RMR,0,		"MOVL	%C,%e",		/* 0x20 */
+	RMR,0,		"MOVL	%D,%e",		/* 0x21 */
+	RMR,0,		"MOVL	%e,%C",		/* 0x22 */
+	RMR,0,		"MOVL	%e,%D",		/* 0x23 */
+	RMR,0,		"MOVL	%T,%e",		/* 0x24 */
+	0,0,		"",			/* 0x25 */
+	RMR,0,		"MOVL	%e,%T",		/* 0x26 */
+	0,0,		"",			/* 0x27 */
+	0,0,		"",			/* 0x28 */
+	0,0,		"",			/* 0x29 */
+	0,0,		"",			/* 0x2a */
+	0,0,		"",			/* 0x2b */
+	0,0,		"",			/* 0x2c */
+	0,0,		"",			/* 0x2d */
+	0,0,		"",			/* 0x2e */
+	0,0,		"",			/* 0x2f */
+	0,0,		"WRMSR",		/* 0x30 */
+	0,0,		"RDTSC",		/* 0x31 */
+	0,0,		"RDMSR",		/* 0x32 */
+	0,0,		"",			/* 0x33 */
+	0,0,		"",			/* 0x34 */
+	0,0,		"",			/* 0x35 */
+	0,0,		"",			/* 0x36 */
+	0,0,		"",			/* 0x37 */
+	0,0,		"",			/* 0x38 */
+	0,0,		"",			/* 0x39 */
+	0,0,		"",			/* 0x3a */
+	0,0,		"",			/* 0x3b */
+	0,0,		"",			/* 0x3c */
+	0,0,		"",			/* 0x3d */
+	0,0,		"",			/* 0x3e */
+	0,0,		"",			/* 0x3f */
+	0,0,		"",			/* 0x40 */
+	0,0,		"",			/* 0x41 */
+	0,0,		"",			/* 0x42 */
+	0,0,		"",			/* 0x43 */
+	0,0,		"",			/* 0x44 */
+	0,0,		"",			/* 0x45 */
+	0,0,		"",			/* 0x46 */
+	0,0,		"",			/* 0x47 */
+	0,0,		"",			/* 0x48 */
+	0,0,		"",			/* 0x49 */
+	0,0,		"",			/* 0x4a */
+	0,0,		"",			/* 0x4b */
+	0,0,		"",			/* 0x4c */
+	0,0,		"",			/* 0x4d */
+	0,0,		"",			/* 0x4e */
+	0,0,		"",			/* 0x4f */
+	0,0,		"",			/* 0x50 */
+	0,0,		"",			/* 0x51 */
+	0,0,		"",			/* 0x52 */
+	0,0,		"",			/* 0x53 */
+	0,0,		"",			/* 0x54 */
+	0,0,		"",			/* 0x55 */
+	0,0,		"",			/* 0x56 */
+	0,0,		"",			/* 0x57 */
+	0,0,		"",			/* 0x58 */
+	0,0,		"",			/* 0x59 */
+	0,0,		"",			/* 0x5a */
+	0,0,		"",			/* 0x5b */
+	0,0,		"",			/* 0x5c */
+	0,0,		"",			/* 0x5d */
+	0,0,		"",			/* 0x5e */
+	0,0,		"",			/* 0x5f */
+	0,0,		"",			/* 0x60 */
+	0,0,		"",			/* 0x61 */
+	0,0,		"",			/* 0x62 */
+	0,0,		"",			/* 0x63 */
+	0,0,		"",			/* 0x64 */
+	0,0,		"",			/* 0x65 */
+	0,0,		"",			/* 0x66 */
+	0,0,		"",			/* 0x67 */
+	0,0,		"",			/* 0x68 */
+	0,0,		"",			/* 0x69 */
+	0,0,		"",			/* 0x6a */
+	0,0,		"",			/* 0x6b */
+	0,0,		"",			/* 0x6c */
+	0,0,		"",			/* 0x6d */
+	0,0,		"",			/* 0x6e */
+	0,0,		"",			/* 0x6f */
+	0,0,		"",			/* 0x70 */
+	0,0,		"",			/* 0x71 */
+	0,0,		"",			/* 0x72 */
+	0,0,		"",			/* 0x73 */
+	0,0,		"",			/* 0x74 */
+	0,0,		"",			/* 0x75 */
+	0,0,		"",			/* 0x76 */
+	0,0,		"",			/* 0x77 */
+	0,0,		"",			/* 0x78 */
+	0,0,		"",			/* 0x79 */
+	0,0,		"",			/* 0x7a */
+	0,0,		"",			/* 0x7b */
+	0,0,		"",			/* 0x7c */
+	0,0,		"",			/* 0x7d */
+	0,0,		"",			/* 0x7e */
+	0,0,		"",			/* 0x7f */
+	Iwds,0,		"JOS	%p",		/* 0x80 */
+	Iwds,0,		"JOC	%p",		/* 0x81 */
+	Iwds,0,		"JCS	%p",		/* 0x82 */
+	Iwds,0,		"JCC	%p",		/* 0x83 */
+	Iwds,0,		"JEQ	%p",		/* 0x84 */
+	Iwds,0,		"JNE	%p",		/* 0x85 */
+	Iwds,0,		"JLS	%p",		/* 0x86 */
+	Iwds,0,		"JHI	%p",		/* 0x87 */
+	Iwds,0,		"JMI	%p",		/* 0x88 */
+	Iwds,0,		"JPL	%p",		/* 0x89 */
+	Iwds,0,		"JPS	%p",		/* 0x8a */
+	Iwds,0,		"JPC	%p",		/* 0x8b */
+	Iwds,0,		"JLT	%p",		/* 0x8c */
+	Iwds,0,		"JGE	%p",		/* 0x8d */
+	Iwds,0,		"JLE	%p",		/* 0x8e */
+	Iwds,0,		"JGT	%p",		/* 0x8f */
+	RMB,0,		"SETOS	%e",		/* 0x90 */
+	RMB,0,		"SETOC	%e",		/* 0x91 */
+	RMB,0,		"SETCS	%e",		/* 0x92 */
+	RMB,0,		"SETCC	%e",		/* 0x93 */
+	RMB,0,		"SETEQ	%e",		/* 0x94 */
+	RMB,0,		"SETNE	%e",		/* 0x95 */
+	RMB,0,		"SETLS	%e",		/* 0x96 */
+	RMB,0,		"SETHI	%e",		/* 0x97 */
+	RMB,0,		"SETMI	%e",		/* 0x98 */
+	RMB,0,		"SETPL	%e",		/* 0x99 */
+	RMB,0,		"SETPS	%e",		/* 0x9a */
+	RMB,0,		"SETPC	%e",		/* 0x9b */
+	RMB,0,		"SETLT	%e",		/* 0x9c */
+	RMB,0,		"SETGE	%e",		/* 0x9d */
+	RMB,0,		"SETLE	%e",		/* 0x9e */
+	RMB,0,		"SETGT	%e",		/* 0x9f */
+	0,0,		"PUSHL	FS",		/* 0xa0 */
+	0,0,		"POPL	FS",		/* 0xa1 */
+	0,0,		"CPUID",		/* 0xa2 */
+	RM,0,		"BT%S	%r,%e",		/* 0xa3 */
+	RM,Ib,		"SHLD%S	%r,%i,%e",	/* 0xa4 */
+	RM,0,		"SHLD%S	%r,CL,%e",	/* 0xa5 */
+	0,0,		"",			/* 0xa6 */
+	0,0,		"",			/* 0xa7 */
+	0,0,		"PUSHL	GS",		/* 0xa8 */
+	0,0,		"POPL	GS",		/* 0xa9 */
+	0,0,		"",			/* 0xaa */
+	RM,0,		"BTS%S	%r,%e",		/* 0xab */
+	RM,Ib,		"SHRD%S	%r,%i,%e",	/* 0xac */
+	RM,0,		"SHRD%S	%r,CL,%e",	/* 0xad */
+	0,0,		"",			/* 0xae */
+	RM,0,		"IMUL%S	%e,%r",		/* 0xaf */
+	0,0,		"",			/* 0xb0 */
+	0,0,		"",			/* 0xb1 */
+	RMM,0,		"LSS	%e,%r",		/* 0xb2 */
+	RM,0,		"BTR%S	%r,%e",		/* 0xb3 */
+	RMM,0,		"LFS	%e,%r",		/* 0xb4 */
+	RMM,0,		"LGS	%e,%r",		/* 0xb5 */
+	RMB,0,		"MOVBZX	%e,%R",		/* 0xb6 */
+	RM,0,		"MOVWZX	%e,%R",		/* 0xb7 */
+	0,0,		"",			/* 0xb8 */
+	0,0,		"",			/* 0xb9 */
+	RMOP,0,		optab0FBA,		/* 0xba */
+	RM,0,		"BTC%S	%e,%r",		/* 0xbb */
+	RM,0,		"BSF%S	%e,%r",		/* 0xbc */
+	RM,0,		"BSR%S	%e,%r",		/* 0xbd */
+	RMB,0,		"MOVBSX	%e,%R",		/* 0xbe */
+	RM,0,		"MOVWSX	%e,%R",		/* 0xbf */
+};
+
+static Optable optab80[8]=
+{
+	Ib,0,		"ADDB	%i,%e",		/* 0x00 */
+	Ib,0,		"ORB	%i,%e",		/* 0x01 */
+	Ib,0,		"ADCB	%i,%e",		/* 0x02 */
+	Ib,0,		"SBBB	%i,%e",		/* 0x03 */
+	Ib,0,		"ANDB	%i,%e",		/* 0x04 */
+	Ib,0,		"SUBB	%i,%e",		/* 0x05 */
+	Ib,0,		"XORB	%i,%e",		/* 0x06 */
+	Ib,0,		"CMPB	%e,%i",		/* 0x07 */
+};
+
+static Optable optab81[8]=
+{
+	Iwd,0,		"ADD%S	%i,%e",		/* 0x00 */
+	Iwd,0,		"OR%S	%i,%e",		/* 0x01 */
+	Iwd,0,		"ADC%S	%i,%e",		/* 0x02 */
+	Iwd,0,		"SBB%S	%i,%e",		/* 0x03 */
+	Iwd,0,		"AND%S	%i,%e",		/* 0x04 */
+	Iwd,0,		"SUB%S	%i,%e",		/* 0x05 */
+	Iwd,0,		"XOR%S	%i,%e",		/* 0x06 */
+	Iwd,0,		"CMP%S	%e,%i",		/* 0x07 */
+};
+
+static Optable optab83[8]=
+{
+	Ibs,0,		"ADD%S	%i,%e",		/* 0x00 */
+	Ibs,0,		"OR%S	%i,%e",		/* 0x01 */
+	Ibs,0,		"ADC%S	%i,%e",		/* 0x02 */
+	Ibs,0,		"SBB%S	%i,%e",		/* 0x03 */
+	Ibs,0,		"AND%S	%i,%e",		/* 0x04 */
+	Ibs,0,		"SUB%S	%i,%e",		/* 0x05 */
+	Ibs,0,		"XOR%S	%i,%e",		/* 0x06 */
+	Ibs,0,		"CMP%S	%e,%i",		/* 0x07 */
+};
+
+static Optable optabC0[8] =
+{
+	Ib,0,		"ROLB	%i,%e",		/* 0x00 */
+	Ib,0,		"RORB	%i,%e",		/* 0x01 */
+	Ib,0,		"RCLB	%i,%e",		/* 0x02 */
+	Ib,0,		"RCRB	%i,%e",		/* 0x03 */
+	Ib,0,		"SHLB	%i,%e",		/* 0x04 */
+	Ib,0,		"SHRB	%i,%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	Ib,0,		"SARB	%i,%e",		/* 0x07 */
+};
+
+static Optable optabC1[8] =
+{
+	Ib,0,		"ROL%S	%i,%e",		/* 0x00 */
+	Ib,0,		"ROR%S	%i,%e",		/* 0x01 */
+	Ib,0,		"RCL%S	%i,%e",		/* 0x02 */
+	Ib,0,		"RCR%S	%i,%e",		/* 0x03 */
+	Ib,0,		"SHL%S	%i,%e",		/* 0x04 */
+	Ib,0,		"SHR%S	%i,%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	Ib,0,		"SAR%S	%i,%e",		/* 0x07 */
+};
+
+static Optable optabD0[8] =
+{
+	0,0,		"ROLB	%e",		/* 0x00 */
+	0,0,		"RORB	%e",		/* 0x01 */
+	0,0,		"RCLB	%e",		/* 0x02 */
+	0,0,		"RCRB	%e",		/* 0x03 */
+	0,0,		"SHLB	%e",		/* 0x04 */
+	0,0,		"SHRB	%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	0,0,		"SARB	%e",		/* 0x07 */
+};
+
+static Optable optabD1[8] =
+{
+	0,0,		"ROL%S	%e",		/* 0x00 */
+	0,0,		"ROR%S	%e",		/* 0x01 */
+	0,0,		"RCL%S	%e",		/* 0x02 */
+	0,0,		"RCR%S	%e",		/* 0x03 */
+	0,0,		"SHL%S	%e",		/* 0x04 */
+	0,0,		"SHR%S	%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	0,0,		"SAR%S	%e",		/* 0x07 */
+};
+
+static Optable optabD2[8] =
+{
+	0,0,		"ROLB	CL,%e",		/* 0x00 */
+	0,0,		"RORB	CL,%e",		/* 0x01 */
+	0,0,		"RCLB	CL,%e",		/* 0x02 */
+	0,0,		"RCRB	CL,%e",		/* 0x03 */
+	0,0,		"SHLB	CL,%e",		/* 0x04 */
+	0,0,		"SHRB	CL,%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	0,0,		"SARB	CL,%e",		/* 0x07 */
+};
+
+static Optable optabD3[8] =
+{
+	0,0,		"ROL%S	CL,%e",		/* 0x00 */
+	0,0,		"ROR%S	CL,%e",		/* 0x01 */
+	0,0,		"RCL%S	CL,%e",		/* 0x02 */
+	0,0,		"RCR%S	CL,%e",		/* 0x03 */
+	0,0,		"SHL%S	CL,%e",		/* 0x04 */
+	0,0,		"SHR%S	CL,%e",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	0,0,		"SAR%S	CL,%e",		/* 0x07 */
+};
+
+static Optable optabD8[8+8] =
+{
+	0,0,		"FADDF	%e,F0",		/* 0x00 */
+	0,0,		"FMULF	%e,F0",		/* 0x01 */
+	0,0,		"FCOMF	%e,F0",		/* 0x02 */
+	0,0,		"FCOMFP	%e,F0",		/* 0x03 */
+	0,0,		"FSUBF	%e,F0",		/* 0x04 */
+	0,0,		"FSUBRF	%e,F0",		/* 0x05 */
+	0,0,		"FDIVF	%e,F0",		/* 0x06 */
+	0,0,		"FDIVRF	%e,F0",		/* 0x07 */
+	0,0,		"FADDD	%f,F0",		/* 0x08 */
+	0,0,		"FMULD	%f,F0",		/* 0x09 */
+	0,0,		"FCOMD	%f,F0",		/* 0x0a */
+	0,0,		"FCOMPD	%f,F0",		/* 0x0b */
+	0,0,		"FSUBD	%f,F0",		/* 0x0c */
+	0,0,		"FSUBRD	%f,F0",		/* 0x0d */
+	0,0,		"FDIVD	%f,F0",		/* 0x0e */
+	0,0,		"FDIVRD	%f,F0",		/* 0x0f */
+};
+/*
+ *	optabD9 and optabDB use the following encoding: 
+ *	if (0 <= modrm <= 2) instruction = optabDx[modrm&0x07];
+ *	else instruction = optabDx[(modrm&0x3f)+8];
+ *
+ *	the instructions for MOD == 3, follow the 8 instructions
+ *	for the other MOD values stored at the front of the table.
+ */
+static Optable optabD9[64+8] =
+{
+	0,0,		"FMOVF	%e,F0",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"FMOVF	F0,%e",		/* 0x02 */
+	0,0,		"FMOVFP	F0,%e",		/* 0x03 */
+	0,0,		"FLDENV%S %e",		/* 0x04 */
+	0,0,		"FLDCW	%e",		/* 0x05 */
+	0,0,		"FSTENV%S %e",		/* 0x06 */
+	0,0,		"FSTCW	%e",		/* 0x07 */
+	0,0,		"FMOVD	F0,F0",		/* 0x08 */	/* Mod R/M = 11xx xxxx*/
+	0,0,		"FMOVD	F1,F0",		/* 0x09 */
+	0,0,		"FMOVD	F2,F0",		/* 0x0a */
+	0,0,		"FMOVD	F3,F0",		/* 0x0b */
+	0,0,		"FMOVD	F4,F0",		/* 0x0c */
+	0,0,		"FMOVD	F5,F0",		/* 0x0d */
+	0,0,		"FMOVD	F6,F0",		/* 0x0e */
+	0,0,		"FMOVD	F7,F0",		/* 0x0f */
+	0,0,		"FXCHD	F0,F0",		/* 0x10 */
+	0,0,		"FXCHD	F1,F0",		/* 0x11 */
+	0,0,		"FXCHD	F2,F0",		/* 0x12 */
+	0,0,		"FXCHD	F3,F0",		/* 0x13 */
+	0,0,		"FXCHD	F4,F0",		/* 0x14 */
+	0,0,		"FXCHD	F5,F0",		/* 0x15 */
+	0,0,		"FXCHD	F6,F0",		/* 0x16 */
+	0,0,		"FXCHD	F7,F0",		/* 0x17 */
+	0,0,		"FNOP",			/* 0x18 */
+	0,0,		"",			/* 0x19 */
+	0,0,		"",			/* 0x1a */
+	0,0,		"",			/* 0x1b */
+	0,0,		"",			/* 0x1c */
+	0,0,		"",			/* 0x1d */
+	0,0,		"",			/* 0x1e */
+	0,0,		"",			/* 0x1f */
+	0,0,		"",			/* 0x20 */
+	0,0,		"",			/* 0x21 */
+	0,0,		"",			/* 0x22 */
+	0,0,		"",			/* 0x23 */
+	0,0,		"",			/* 0x24 */
+	0,0,		"",			/* 0x25 */
+	0,0,		"",			/* 0x26 */
+	0,0,		"",			/* 0x27 */
+	0,0,		"FCHS",			/* 0x28 */
+	0,0,		"FABS",			/* 0x29 */
+	0,0,		"",			/* 0x2a */
+	0,0,		"",			/* 0x2b */
+	0,0,		"FTST",			/* 0x2c */
+	0,0,		"FXAM",			/* 0x2d */
+	0,0,		"",			/* 0x2e */
+	0,0,		"",			/* 0x2f */
+	0,0,		"FLD1",			/* 0x30 */
+	0,0,		"FLDL2T",		/* 0x31 */
+	0,0,		"FLDL2E",		/* 0x32 */
+	0,0,		"FLDPI",		/* 0x33 */
+	0,0,		"FLDLG2",		/* 0x34 */
+	0,0,		"FLDLN2",		/* 0x35 */
+	0,0,		"FLDZ",			/* 0x36 */
+	0,0,		"",			/* 0x37 */
+	0,0,		"F2XM1",		/* 0x38 */
+	0,0,		"FYL2X",		/* 0x39 */
+	0,0,		"FPTAN",		/* 0x3a */
+	0,0,		"FPATAN",		/* 0x3b */
+	0,0,		"FXTRACT",		/* 0x3c */
+	0,0,		"FPREM1",		/* 0x3d */
+	0,0,		"FDECSTP",		/* 0x3e */
+	0,0,		"FNCSTP",		/* 0x3f */
+	0,0,		"FPREM",		/* 0x40 */
+	0,0,		"FYL2XP1",		/* 0x41 */
+	0,0,		"FSQRT",		/* 0x42 */
+	0,0,		"FSINCOS",		/* 0x43 */
+	0,0,		"FRNDINT",		/* 0x44 */
+	0,0,		"FSCALE",		/* 0x45 */
+	0,0,		"FSIN",			/* 0x46 */
+	0,0,		"FCOS",			/* 0x47 */
+};
+
+static Optable optabDA[8+8] =
+{
+	0,0,		"FADDL	%e,F0",		/* 0x00 */
+	0,0,		"FMULL	%e,F0",		/* 0x01 */
+	0,0,		"FCOML	%e,F0",		/* 0x02 */
+	0,0,		"FCOMLP	%e,F0",		/* 0x03 */
+	0,0,		"FSUBL	%e,F0",		/* 0x04 */
+	0,0,		"FSUBRL	%e,F0",		/* 0x05 */
+	0,0,		"FDIVL	%e,F0",		/* 0x06 */
+	0,0,		"FDIVRL	%e,F0",		/* 0x07 */
+	0,0,		"",			/* 0x08 */
+	0,0,		"",			/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	0,0,		"",			/* 0x0b */
+	0,0,		"",			/* 0x0c */
+	R1,0,		"FUCOMPP",		/* 0x0d */
+};
+
+static Optable optabDB[8+64] =
+{
+	0,0,		"FMOVL	%e,F0",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"FMOVL	F0,%e",		/* 0x02 */
+	0,0,		"FMOVLP	F0,%e",		/* 0x03 */
+	0,0,		"",			/* 0x04 */
+	0,0,		"FMOVX	%e,F0",		/* 0x05 */
+	0,0,		"",			/* 0x06 */
+	0,0,		"FMOVXP	F0,%e",		/* 0x07 */
+	0,0,		"",			/* 0x08 */
+	0,0,		"",			/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	0,0,		"",			/* 0x0b */
+	0,0,		"",			/* 0x0c */
+	0,0,		"",			/* 0x0d */
+	0,0,		"",			/* 0x0e */
+	0,0,		"",			/* 0x0f */
+	0,0,		"",			/* 0x10 */
+	0,0,		"",			/* 0x11 */
+	0,0,		"",			/* 0x12 */
+	0,0,		"",			/* 0x13 */
+	0,0,		"",			/* 0x14 */
+	0,0,		"",			/* 0x15 */
+	0,0,		"",			/* 0x16 */
+	0,0,		"",			/* 0x17 */
+	0,0,		"",			/* 0x18 */
+	0,0,		"",			/* 0x19 */
+	0,0,		"",			/* 0x1a */
+	0,0,		"",			/* 0x1b */
+	0,0,		"",			/* 0x1c */
+	0,0,		"",			/* 0x1d */
+	0,0,		"",			/* 0x1e */
+	0,0,		"",			/* 0x1f */
+	0,0,		"",			/* 0x20 */
+	0,0,		"",			/* 0x21 */
+	0,0,		"",			/* 0x22 */
+	0,0,		"",			/* 0x23 */
+	0,0,		"",			/* 0x24 */
+	0,0,		"",			/* 0x25 */
+	0,0,		"",			/* 0x26 */
+	0,0,		"",			/* 0x27 */
+	0,0,		"",			/* 0x28 */
+	0,0,		"",			/* 0x29 */
+	0,0,		"FCLEX",		/* 0x2a */
+	0,0,		"FINIT",		/* 0x2b */
+};
+
+static Optable optabDC[8+8] =
+{
+	0,0,		"FADDD	%e,F0",		/* 0x00 */
+	0,0,		"FMULD	%e,F0",		/* 0x01 */
+	0,0,		"FCOMD	%e,F0",		/* 0x02 */
+	0,0,		"FCOMDP	%e,F0",		/* 0x03 */
+	0,0,		"FSUBD	%e,F0",		/* 0x04 */
+	0,0,		"FSUBRD	%e,F0",		/* 0x05 */
+	0,0,		"FDIVD	%e,F0",		/* 0x06 */
+	0,0,		"FDIVRD	%e,F0",		/* 0x07 */
+	0,0,		"FADDD	F0,%f",		/* 0x08 */
+	0,0,		"FMULD	F0,%f",		/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	0,0,		"",			/* 0x0b */
+	0,0,		"FSUBRD	F0,%f",		/* 0x0c */
+	0,0,		"FSUBD	F0,%f",		/* 0x0d */
+	0,0,		"FDIVRD	F0,%f",		/* 0x0e */
+	0,0,		"FDIVD	F0,%f",		/* 0x0f */
+};
+
+static Optable optabDD[8+8] =
+{
+	0,0,		"FMOVD	%e,F0",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"FMOVD	F0,%e",		/* 0x02 */
+	0,0,		"FMOVDP	F0,%e",		/* 0x03 */
+	0,0,		"FRSTOR%S %e",		/* 0x04 */
+	0,0,		"",			/* 0x05 */
+	0,0,		"FSAVE%S %e",		/* 0x06 */
+	0,0,		"FSTSW	%e",		/* 0x07 */
+	0,0,		"FFREED	%f",		/* 0x08 */
+	0,0,		"",			/* 0x09 */
+	0,0,		"FMOVD	%f,F0",		/* 0x0a */
+	0,0,		"FMOVDP	%f,F0",		/* 0x0b */
+	0,0,		"FUCOMD	%f,F0",		/* 0x0c */
+	0,0,		"FUCOMDP %f,F0",	/* 0x0d */
+};
+
+static Optable optabDE[8+8] =
+{
+	0,0,		"FADDW	%e,F0",		/* 0x00 */
+	0,0,		"FMULW	%e,F0",		/* 0x01 */
+	0,0,		"FCOMW	%e,F0",		/* 0x02 */
+	0,0,		"FCOMWP	%e,F0",		/* 0x03 */
+	0,0,		"FSUBW	%e,F0",		/* 0x04 */
+	0,0,		"FSUBRW	%e,F0",		/* 0x05 */
+	0,0,		"FDIVW	%e,F0",		/* 0x06 */
+	0,0,		"FDIVRW	%e,F0",		/* 0x07 */
+	0,0,		"FADDDP	F0,%f",		/* 0x08 */
+	0,0,		"FMULDP	F0,%f",		/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	R1,0,		"FCOMPDP",		/* 0x0b */
+	0,0,		"FSUBRDP F0,%f",	/* 0x0c */
+	0,0,		"FSUBDP	F0,%f",		/* 0x0d */
+	0,0,		"FDIVRDP F0,%f",	/* 0x0e */
+	0,0,		"FDIVDP	F0,%f",		/* 0x0f */
+};
+
+static Optable optabDF[8+8] =
+{
+	0,0,		"FMOVW	%e,F0",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"FMOVW	F0,%e",		/* 0x02 */
+	0,0,		"FMOVWP	F0,%e",		/* 0x03 */
+	0,0,		"FBLD	%e",		/* 0x04 */
+	0,0,		"FMOVL	%e,F0",		/* 0x05 */
+	0,0,		"FBSTP	%e",		/* 0x06 */
+	0,0,		"FMOVLP	F0,%e",		/* 0x07 */
+	0,0,		"",			/* 0x08 */
+	0,0,		"",			/* 0x09 */
+	0,0,		"",			/* 0x0a */
+	0,0,		"",			/* 0x0b */
+	R0,0,		"FSTSW	%OAX",		/* 0x0c */
+};
+
+static Optable optabF6[8] =
+{
+	Ib,0,		"TESTB	%i,%e",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"NOTB	%e",		/* 0x02 */
+	0,0,		"NEGB	%e",		/* 0x03 */
+	0,0,		"MULB	AL,%e",		/* 0x04 */
+	0,0,		"IMULB	AL,%e",		/* 0x05 */
+	0,0,		"DIVB	AL,%e",		/* 0x06 */
+	0,0,		"IDIVB	AL,%e",		/* 0x07 */
+};
+
+static Optable optabF7[8] =
+{
+	Iwd,0,		"TEST%S	%i,%e",		/* 0x00 */
+	0,0,		"",			/* 0x01 */
+	0,0,		"NOT%S	%e",		/* 0x02 */
+	0,0,		"NEG%S	%e",		/* 0x03 */
+	0,0,		"MUL%S	%OAX,%e",	/* 0x04 */
+	0,0,		"IMUL%S	%OAX,%e",	/* 0x05 */
+	0,0,		"DIV%S	%OAX,%e",	/* 0x06 */
+	0,0,		"IDIV%S	%OAX,%e",	/* 0x07 */
+};
+
+static Optable optabFE[8] =
+{
+	0,0,		"INCB	%e",		/* 0x00 */
+	0,0,		"DECB	%e",		/* 0x01 */
+};
+
+static Optable optabFF[8] =
+{
+	0,0,		"INC%S	%e",		/* 0x00 */
+	0,0,		"DEC%S	%e",		/* 0x01 */
+	JUMP,0,		"CALL*%S %e",		/* 0x02 */
+	JUMP,0,		"CALLF*%S %e",		/* 0x03 */
+	JUMP,0,		"JMP*%S	%e",		/* 0x04 */
+	JUMP,0,		"JMPF*%S %e",		/* 0x05 */
+	0,0,		"PUSHL	%e",		/* 0x06 */
+};
+
+static Optable optable[256] =
+{
+	RMB,0,		"ADDB	%r,%e",		/* 0x00 */
+	RM,0,		"ADD%S	%r,%e",		/* 0x01 */
+	RMB,0,		"ADDB	%e,%r",		/* 0x02 */
+	RM,0,		"ADD%S	%e,%r",		/* 0x03 */
+	Ib,0,		"ADDB	%i,AL",		/* 0x04 */
+	Iwd,0,		"ADD%S	%i,%OAX",	/* 0x05 */
+	0,0,		"PUSHL	ES",		/* 0x06 */
+	0,0,		"POPL	ES",		/* 0x07 */
+	RMB,0,		"ORB	%r,%e",		/* 0x08 */
+	RM,0,		"OR%S	%r,%e",		/* 0x09 */
+	RMB,0,		"ORB	%e,%r",		/* 0x0a */
+	RM,0,		"OR%S	%e,%r",		/* 0x0b */
+	Ib,0,		"ORB	%i,AL",		/* 0x0c */
+	Iwd,0,		"OR%S	%i,%OAX",	/* 0x0d */
+	0,0,		"PUSHL	CS",		/* 0x0e */
+	AUX,0,		optab0F,		/* 0x0f */
+	RMB,0,		"ADCB	%r,%e",		/* 0x10 */
+	RM,0,		"ADC%S	%r,%e",		/* 0x11 */
+	RMB,0,		"ADCB	%e,%r",		/* 0x12 */
+	RM,0,		"ADC%S	%e,%r",		/* 0x13 */
+	Ib,0,		"ADCB	%i,AL",		/* 0x14 */
+	Iwd,0,		"ADC%S	%i,%OAX",	/* 0x15 */
+	0,0,		"PUSHL	SS",		/* 0x16 */
+	0,0,		"POPL	SS",		/* 0x17 */
+	RMB,0,		"SBBB	%r,%e",		/* 0x18 */
+	RM,0,		"SBB%S	%r,%e",		/* 0x19 */
+	RMB,0,		"SBBB	%e,%r",		/* 0x1a */
+	RM,0,		"SBB%S	%e,%r",		/* 0x1b */
+	Ib,0,		"SBBB	%i,AL",		/* 0x1c */
+	Iwd,0,		"SBB%S	%i,%OAX",	/* 0x1d */
+	0,0,		"PUSHL	DS",		/* 0x1e */
+	0,0,		"POPL	DS",		/* 0x1f */
+	RMB,0,		"ANDB	%r,%e",		/* 0x20 */
+	RM,0,		"AND%S	%r,%e",		/* 0x21 */
+	RMB,0,		"ANDB	%e,%r",		/* 0x22 */
+	RM,0,		"AND%S	%e,%r",		/* 0x23 */
+	Ib,0,		"ANDB	%i,AL",		/* 0x24 */
+	Iwd,0,		"AND%S	%i,%OAX",	/* 0x25 */
+	SEG,0,		"ES:",			/* 0x26 */
+	0,0,		"DAA",			/* 0x27 */
+	RMB,0,		"SUBB	%r,%e",		/* 0x28 */
+	RM,0,		"SUB%S	%r,%e",		/* 0x29 */
+	RMB,0,		"SUBB	%e,%r",		/* 0x2a */
+	RM,0,		"SUB%S	%e,%r",		/* 0x2b */
+	Ib,0,		"SUBB	%i,AL",		/* 0x2c */
+	Iwd,0,		"SUB%S	%i,%OAX",	/* 0x2d */
+	SEG,0,		"CS:",			/* 0x2e */
+	0,0,		"DAS",			/* 0x2f */
+	RMB,0,		"XORB	%r,%e",		/* 0x30 */
+	RM,0,		"XOR%S	%r,%e",		/* 0x31 */
+	RMB,0,		"XORB	%e,%r",		/* 0x32 */
+	RM,0,		"XOR%S	%e,%r",		/* 0x33 */
+	Ib,0,		"XORB	%i,AL",		/* 0x34 */
+	Iwd,0,		"XOR%S	%i,%OAX",	/* 0x35 */
+	SEG,0,		"SS:",			/* 0x36 */
+	0,0,		"AAA",			/* 0x37 */
+	RMB,0,		"CMPB	%r,%e",		/* 0x38 */
+	RM,0,		"CMP%S	%r,%e",		/* 0x39 */
+	RMB,0,		"CMPB	%e,%r",		/* 0x3a */
+	RM,0,		"CMP%S	%e,%r",		/* 0x3b */
+	Ib,0,		"CMPB	%i,AL",		/* 0x3c */
+	Iwd,0,		"CMP%S	%i,%OAX",	/* 0x3d */
+	SEG,0,		"DS:",			/* 0x3e */
+	0,0,		"AAS",			/* 0x3f */
+	0,0,		"INC%S	%OAX",		/* 0x40 */
+	0,0,		"INC%S	%OCX",		/* 0x41 */
+	0,0,		"INC%S	%ODX",		/* 0x42 */
+	0,0,		"INC%S	%OBX",		/* 0x43 */
+	0,0,		"INC%S	%OSP",		/* 0x44 */
+	0,0,		"INC%S	%OBP",		/* 0x45 */
+	0,0,		"INC%S	%OSI",		/* 0x46 */
+	0,0,		"INC%S	%ODI",		/* 0x47 */
+	0,0,		"DEC%S	%OAX",		/* 0x48 */
+	0,0,		"DEC%S	%OCX",		/* 0x49 */
+	0,0,		"DEC%S	%ODX",		/* 0x4a */
+	0,0,		"DEC%S	%OBX",		/* 0x4b */
+	0,0,		"DEC%S	%OSP",		/* 0x4c */
+	0,0,		"DEC%S	%OBP",		/* 0x4d */
+	0,0,		"DEC%S	%OSI",		/* 0x4e */
+	0,0,		"DEC%S	%ODI",		/* 0x4f */
+	0,0,		"PUSH%S	%OAX",		/* 0x50 */
+	0,0,		"PUSH%S	%OCX",		/* 0x51 */
+	0,0,		"PUSH%S	%ODX",		/* 0x52 */
+	0,0,		"PUSH%S	%OBX",		/* 0x53 */
+	0,0,		"PUSH%S	%OSP",		/* 0x54 */
+	0,0,		"PUSH%S	%OBP",		/* 0x55 */
+	0,0,		"PUSH%S	%OSI",		/* 0x56 */
+	0,0,		"PUSH%S	%ODI",		/* 0x57 */
+	0,0,		"POP%S	%OAX",		/* 0x58 */
+	0,0,		"POP%S	%OCX",		/* 0x59 */
+	0,0,		"POP%S	%ODX",		/* 0x5a */
+	0,0,		"POP%S	%OBX",		/* 0x5b */
+	0,0,		"POP%S	%OSP",		/* 0x5c */
+	0,0,		"POP%S	%OBP",		/* 0x5d */
+	0,0,		"POP%S	%OSI",		/* 0x5e */
+	0,0,		"POP%S	%ODI",		/* 0x5f */
+	0,0,		"PUSHA%S",		/* 0x60 */
+	0,0,		"POPA%S",		/* 0x61 */
+	RMM,0,		"BOUND	%e,%r",		/* 0x62 */
+	RM,0,		"ARPL	%r,%e",		/* 0x63 */
+	SEG,0,		"FS:",			/* 0x64 */
+	SEG,0,		"GS:",			/* 0x65 */
+	OPOVER,0,	"",			/* 0x66 */
+	ADDOVER,0,	"",			/* 0x67 */
+	Iwd,0,		"PUSH%S	%i",		/* 0x68 */
+	RM,Iwd,		"IMUL%S	%e,%i,%r",	/* 0x69 */
+	Ib,0,		"PUSH%S	%i",		/* 0x6a */
+	RM,Ibs,		"IMUL%S	%e,%i,%r",	/* 0x6b */
+	0,0,		"INSB	DX,(%ODI)",	/* 0x6c */
+	0,0,		"INS%S	DX,(%ODI)",	/* 0x6d */
+	0,0,		"OUTSB	(%ASI),DX",	/* 0x6e */
+	0,0,		"OUTS%S	(%ASI),DX",	/* 0x6f */
+	Jbs,0,		"JOS	%p",		/* 0x70 */
+	Jbs,0,		"JOC	%p",		/* 0x71 */
+	Jbs,0,		"JCS	%p",		/* 0x72 */
+	Jbs,0,		"JCC	%p",		/* 0x73 */
+	Jbs,0,		"JEQ	%p",		/* 0x74 */
+	Jbs,0,		"JNE	%p",		/* 0x75 */
+	Jbs,0,		"JLS	%p",		/* 0x76 */
+	Jbs,0,		"JHI	%p",		/* 0x77 */
+	Jbs,0,		"JMI	%p",		/* 0x78 */
+	Jbs,0,		"JPL	%p",		/* 0x79 */
+	Jbs,0,		"JPS	%p",		/* 0x7a */
+	Jbs,0,		"JPC	%p",		/* 0x7b */
+	Jbs,0,		"JLT	%p",		/* 0x7c */
+	Jbs,0,		"JGE	%p",		/* 0x7d */
+	Jbs,0,		"JLE	%p",		/* 0x7e */
+	Jbs,0,		"JGT	%p",		/* 0x7f */
+	RMOPB,0,	optab80,		/* 0x80 */
+	RMOP,0,		optab81,		/* 0x81 */
+	0,0,		"",			/* 0x82 */
+	RMOP,0,		optab83,		/* 0x83 */
+	RMB,0,		"TESTB	%r,%e",		/* 0x84 */
+	RM,0,		"TEST%S	%r,%e",		/* 0x85 */
+	RMB,0,		"XCHGB	%r,%e",		/* 0x86 */
+	RM,0,		"XCHG%S	%r,%e",		/* 0x87 */
+	RMB,0,		"MOVB	%r,%e",		/* 0x88 */
+	RM,0,		"MOV%S	%r,%e",		/* 0x89 */
+	RMB,0,		"MOVB	%e,%r",		/* 0x8a */
+	RM,0,		"MOV%S	%e,%r",		/* 0x8b */
+	RM,0,		"MOVW	%g,%e",		/* 0x8c */
+	RM,0,		"LEA	%e,%r",		/* 0x8d */
+	RM,0,		"MOVW	%e,%g",		/* 0x8e */
+	RM,0,		"POP%S	%e",		/* 0x8f */
+	0,0,		"NOP",			/* 0x90 */
+	0,0,		"XCHG	%OCX,%OAX",	/* 0x91 */
+	0,0,		"XCHG	%OCX,%OAX",	/* 0x92 */
+	0,0,		"XCHG	%OCX,%OAX",	/* 0x93 */
+	0,0,		"XCHG	%OSP,%OAX",	/* 0x94 */
+	0,0,		"XCHG	%OBP,%OAX",	/* 0x95 */
+	0,0,		"XCHG	%OSI,%OAX",	/* 0x96 */
+	0,0,		"XCHG	%ODI,%OAX",	/* 0x97 */
+	0,0,		"%X",			/* 0x98 */	/* miserable CBW or CWDE */
+	0,0,		"%x",			/* 0x99 */	/* idiotic CWD or CDQ */
+	PTR,0,		"CALL%S	%d",		/* 0x9a */
+	0,0,		"WAIT",			/* 0x9b */
+	0,0,		"PUSHF",		/* 0x9c */
+	0,0,		"POPF",			/* 0x9d */
+	0,0,		"SAHF",			/* 0x9e */
+	0,0,		"LAHF",			/* 0x9f */
+	Awd,0,		"MOVB	%i,AL",		/* 0xa0 */
+	Awd,0,		"MOV%S	%i,%OAX",	/* 0xa1 */
+	Awd,0,		"MOVB	AL,%i",		/* 0xa2 */
+	Awd,0,		"MOV%S	%OAX,%i",	/* 0xa3 */
+	0,0,		"MOVSB	(%ASI),(%ADI)",	/* 0xa4 */
+	0,0,		"MOVS%S	(%ASI),(%ADI)",	/* 0xa5 */
+	0,0,		"CMPSB	(%ASI),(%ADI)",	/* 0xa6 */
+	0,0,		"CMPS%S	(%ASI),(%ADI)",	/* 0xa7 */
+	Ib,0,		"TESTB	%i,AL",		/* 0xa8 */
+	Iwd,0,		"TEST%S	%i,%OAX",	/* 0xa9 */
+	0,0,		"STOSB	AL,(%ADI)",	/* 0xaa */
+	0,0,		"STOS%S	%OAX,(%ADI)",	/* 0xab */
+	0,0,		"LODSB	(%ASI),AL",	/* 0xac */
+	0,0,		"LODS%S	(%ASI),%OAX",	/* 0xad */
+	0,0,		"SCASB	(%ADI),AL",	/* 0xae */
+	0,0,		"SCAS%S	(%ADI),%OAX",	/* 0xaf */
+	Ib,0,		"MOVB	%i,AL",		/* 0xb0 */
+	Ib,0,		"MOVB	%i,CL",		/* 0xb1 */
+	Ib,0,		"MOVB	%i,DL",		/* 0xb2 */
+	Ib,0,		"MOVB	%i,BL",		/* 0xb3 */
+	Ib,0,		"MOVB	%i,AH",		/* 0xb4 */
+	Ib,0,		"MOVB	%i,CH",		/* 0xb5 */
+	Ib,0,		"MOVB	%i,DH",		/* 0xb6 */
+	Ib,0,		"MOVB	%i,BH",		/* 0xb7 */
+	Iwd,0,		"MOV%S	%i,%OAX",	/* 0xb8 */
+	Iwd,0,		"MOV%S	%i,%OCX",	/* 0xb9 */
+	Iwd,0,		"MOV%S	%i,%ODX",	/* 0xba */
+	Iwd,0,		"MOV%S	%i,%OBX",	/* 0xbb */
+	Iwd,0,		"MOV%S	%i,%OSP",	/* 0xbc */
+	Iwd,0,		"MOV%S	%i,%OBP",	/* 0xbd */
+	Iwd,0,		"MOV%S	%i,%OSI",	/* 0xbe */
+	Iwd,0,		"MOV%S	%i,%ODI",	/* 0xbf */
+	RMOPB,0,	optabC0,		/* 0xc0 */
+	RMOP,0,		optabC1,		/* 0xc1 */
+	Iw,0,		"RET	%i",		/* 0xc2 */
+	RET,0,		"RET",			/* 0xc3 */
+	RM,0,		"LES	%e,%r",		/* 0xc4 */
+	RM,0,		"LDS	%e,%r",		/* 0xc5 */
+	RMB,Ib,		"MOVB	%i,%e",		/* 0xc6 */
+	RM,Iwd,		"MOV%S	%i,%e",		/* 0xc7 */
+	Iw2,Ib,		"ENTER	%i,%I",		/* 0xc8 */	/* loony ENTER */
+	RET,0,		"LEAVE",		/* 0xc9 */	/* bizarre LEAVE */
+	Iw,0,		"RETF	%i",		/* 0xca */
+	RET,0,		"RETF",			/* 0xcb */
+	0,0,		"INT	3",		/* 0xcc */
+	Ib,0,		"INTB	%i",		/* 0xcd */
+	0,0,		"INTO",			/* 0xce */
+	0,0,		"IRET",			/* 0xcf */
+	RMOPB,0,	optabD0,		/* 0xd0 */
+	RMOP,0,		optabD1,		/* 0xd1 */
+	RMOPB,0,	optabD2,		/* 0xd2 */
+	RMOP,0,		optabD3,		/* 0xd3 */
+	OA,0,		"AAM",			/* 0xd4 */
+	OA,0,		"AAD",			/* 0xd5 */
+	0,0,		"",			/* 0xd6 */
+	0,0,		"XLAT",			/* 0xd7 */
+	FRMOP,0,	optabD8,		/* 0xd8 */
+	FRMEX,0,	optabD9,		/* 0xd9 */
+	FRMOP,0,	optabDA,		/* 0xda */
+	FRMEX,0,	optabDB,		/* 0xdb */
+	FRMOP,0,	optabDC,		/* 0xdc */
+	FRMOP,0,	optabDD,		/* 0xdd */
+	FRMOP,0,	optabDE,		/* 0xde */
+	FRMOP,0,	optabDF,		/* 0xdf */
+	Jbs,0,		"LOOPNE	%p",		/* 0xe0 */
+	Jbs,0,		"LOOPE	%p",		/* 0xe1 */
+	Jbs,0,		"LOOP	%p",		/* 0xe2 */
+	Jbs,0,		"JCXZ	%p",		/* 0xe3 */
+	Ib,0,		"INB	%i,AL",		/* 0xe4 */
+	Ib,0,		"IN%S	%i,%OAX",	/* 0xe5 */
+	Ib,0,		"OUTB	AL,%i",		/* 0xe6 */
+	Ib,0,		"OUT%S	%OAX,%i",	/* 0xe7 */
+	Iwds,0,		"CALL	%p",		/* 0xe8 */
+	Iwds,0,		"JMP	%p",		/* 0xe9 */
+	PTR,0,		"JMP	%d",		/* 0xea */
+	Jbs,0,		"JMP	%p",		/* 0xeb */
+	0,0,		"INB	DX,AL",		/* 0xec */
+	0,0,		"IN%S	DX,%OAX",	/* 0xed */
+	0,0,		"OUTB	AL,DX",		/* 0xee */
+	0,0,		"OUT%S	%OAX,DX",	/* 0xef */
+	PRE,0,		"LOCK",			/* 0xf0 */
+	0,0,		"",			/* 0xf1 */	
+	PRE,0,		"REPNE",		/* 0xf2 */
+	PRE,0,		"REP",			/* 0xf3 */
+	0,0,		"HALT",			/* 0xf4 */
+	0,0,		"CMC",			/* 0xf5 */
+	RMOPB,0,	optabF6,		/* 0xf6 */
+	RMOP,0,		optabF7,		/* 0xf7 */
+	0,0,		"CLC",			/* 0xf8 */
+	0,0,		"STC",			/* 0xf9 */
+	0,0,		"CLI",			/* 0xfa */
+	0,0,		"STI",			/* 0xfb */
+	0,0,		"CLD",			/* 0xfc */
+	0,0,		"STD",			/* 0xfd */
+	RMOPB,0,	optabFE,		/* 0xfe */
+	RMOP,0,		optabFF,		/* 0xff */
+};
+
+/*
+ *  get a byte of the instruction
+ */
+static int
+igetc(Map * map, Instr *ip, uchar *c)
+{
+	if(ip->n+1 > sizeof(ip->mem)){
+		werrstr("instruction too long");
+		return -1;
+	}
+	if (get1(map, ip->addr+ip->n, c, 1) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	ip->mem[ip->n++] = *c;
+	return 1;
+}
+
+/*
+ *  get two bytes of the instruction
+ */
+static int
+igets(Map *map, Instr *ip, ushort *sp)
+{
+	uchar	c;
+	ushort s;
+
+	if (igetc(map, ip, &c) < 0)
+		return -1;
+	s = c;
+	if (igetc(map, ip, &c) < 0)
+		return -1;
+	s |= (c<<8);
+	*sp = s;
+	return 1;
+}
+
+/*
+ *  get 4 bytes of the instruction
+ */
+static int
+igetl(Map *map, Instr *ip, ulong *lp)
+{
+	ushort s;
+	long	l;
+
+	if (igets(map, ip, &s) < 0)
+		return -1;
+	l = s;
+	if (igets(map, ip, &s) < 0)
+		return -1;
+	l |= (s<<16);
+	*lp = l;
+	return 1;
+}
+
+static int
+getdisp(Map *map, Instr *ip, int mod, int rm, int code)
+{
+	uchar c;
+	ushort s;
+
+	if (mod > 2)
+		return 1;
+	if (mod == 1) {
+		if (igetc(map, ip, &c) < 0)
+			return -1;
+		if (c&0x80)
+			ip->disp = c|0xffffff00;
+		else
+			ip->disp = c&0xff;
+	} else if (mod == 2 || rm == code) {
+		if (ip->asize == 'E') {
+			if (igetl(map, ip, &ip->disp) < 0)
+				return -1;
+		} else {
+			if (igets(map, ip, &s) < 0)
+				return -1;
+			if (s&0x8000)
+				ip->disp = s|0xffff0000;
+			else
+				ip->disp = s;
+		}
+		if (mod == 0)
+			ip->base = -1;
+	}
+	return 1;
+}
+
+static int
+modrm(Map *map, Instr *ip, uchar c)
+{
+	uchar rm, mod;
+
+	mod = (c>>6)&3;
+	rm = c&7;
+	ip->mod = mod;
+	ip->base = rm;
+	ip->reg = (c>>3)&7;
+	if (mod == 3)			/* register */
+		return 1;
+	if (ip->asize == 0) {		/* 16-bit mode */
+		switch(rm)
+		{
+		case 0:
+			ip->base = BX; ip->index = SI;
+			break;
+		case 1:
+			ip->base = BX; ip->index = DI;
+			break;
+		case 2:
+			ip->base = BP; ip->index = SI;
+			break;
+		case 3:
+			ip->base = BP; ip->index = DI;
+			break;
+		case 4:
+			ip->base = SI;
+			break;
+		case 5:
+			ip->base = DI;
+			break;
+		case 6:
+			ip->base = BP;
+			break;
+		case 7:
+			ip->base = BX;
+			break;
+		default:
+			break;
+		}
+		return getdisp(map, ip, mod, rm, 6);
+	}
+	if (rm == 4) {	/* scummy sib byte */
+		if (igetc(map, ip, &c) < 0)
+			return -1;
+		ip->ss = (c>>6)&0x03;
+		ip->index = (c>>3)&0x07;
+		if (ip->index == 4)
+			ip->index = -1;
+		ip->base = c&0x07;
+		return getdisp(map, ip, mod, ip->base, 5);
+	}
+	return getdisp(map, ip, mod, rm, 5);
+}
+
+static Optable *
+mkinstr(Map *map, Instr *ip, ulong pc)
+{
+	int i, n;
+	uchar c;
+	ushort s;
+	Optable *op, *obase;
+	char buf[128];
+
+	memset(ip, 0, sizeof(*ip));
+	ip->base = -1;
+	ip->index = -1;
+	if(asstype == AI8086)
+		ip->osize = 'W';
+	else {
+		ip->osize = 'L';
+		ip->asize = 'E';
+	}
+	ip->addr = pc;
+	if (igetc(map, ip, &c) < 0)
+		return 0;
+	obase = optable;
+newop:
+	op = &obase[c];
+	if (op->proto == 0) {
+badop:
+		n = snprint(buf, sizeof(buf), "opcode: ??");
+		for (i = 0; i < ip->n && n < sizeof(buf)-3; i++, n+=2)
+			_hexify(buf+n, ip->mem[i], 1);
+		strcpy(buf+n, "??");
+		werrstr(buf);
+		return 0;
+	}
+	for(i = 0; i < 2 && op->operand[i]; i++) {
+		switch(op->operand[i])
+		{
+		case Ib:	/* 8-bit immediate - (no sign extension)*/
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			ip->imm = c&0xff;
+			break;
+		case Jbs:	/* 8-bit jump immediate (sign extended) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (c&0x80)
+				ip->imm = c|0xffffff00;
+			else
+				ip->imm = c&0xff;
+			ip->jumptype = Jbs;
+			break;
+		case Ibs:	/* 8-bit immediate (sign extended) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (c&0x80)
+				if (ip->osize == 'L')
+					ip->imm = c|0xffffff00;
+				else
+					ip->imm = c|0xff00;
+			else
+				ip->imm = c&0xff;
+			break;
+		case Iw:	/* 16-bit immediate -> imm */
+			if (igets(map, ip, &s) < 0)
+				return 0;
+			ip->imm = s&0xffff;
+			ip->jumptype = Iw;
+			break;
+		case Iw2:	/* 16-bit immediate -> in imm2*/
+			if (igets(map, ip, &s) < 0)
+				return 0;
+			ip->imm2 = s&0xffff;
+			break;
+		case Iwd:	/* Operand-sized immediate (no sign extension)*/
+			if (ip->osize == 'L') {
+				if (igetl(map, ip, &ip->imm) < 0)
+					return 0;
+			} else {
+				if (igets(map, ip, &s)< 0)
+					return 0;
+				ip->imm = s&0xffff;
+			}
+			break;
+		case Awd:	/* Address-sized immediate (no sign extension)*/
+			if (ip->asize == 'E') {
+				if (igetl(map, ip, &ip->imm) < 0)
+					return 0;
+			} else {
+				if (igets(map, ip, &s)< 0)
+					return 0;
+				ip->imm = s&0xffff;
+			}
+			break;
+		case Iwds:	/* Operand-sized immediate (sign extended) */
+			if (ip->osize == 'L') {
+				if (igetl(map, ip, &ip->imm) < 0)
+					return 0;
+			} else {
+				if (igets(map, ip, &s)< 0)
+					return 0;
+				if (s&0x8000)
+					ip->imm = s|0xffff0000;
+				else
+					ip->imm = s&0xffff;
+			}
+			ip->jumptype = Iwds;
+			break;
+		case OA:	/* literal 0x0a byte */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (c != 0x0a)
+				goto badop;
+			break;
+		case R0:	/* base register must be R0 */
+			if (ip->base != 0)
+				goto badop;
+			break;
+		case R1:	/* base register must be R1 */
+			if (ip->base != 1)
+				goto badop;
+			break;
+		case RMB:	/* R/M field with byte register (/r)*/
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			ip->osize = 'B';
+			break;
+		case RM:	/* R/M field with register (/r) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			break;
+		case RMOPB:	/* R/M field with op code (/digit) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			c = ip->reg;		/* secondary op code */
+			obase = (Optable*)op->proto;
+			ip->osize = 'B';
+			goto newop;
+		case RMOP:	/* R/M field with op code (/digit) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			c = ip->reg;
+			obase = (Optable*)op->proto;
+			goto newop;
+		case FRMOP:	/* FP R/M field with op code (/digit) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			if ((c&0xc0) == 0xc0)
+				c = ip->reg+8;		/* 16 entry table */
+			else
+				c = ip->reg;
+			obase = (Optable*)op->proto;
+			goto newop;
+		case FRMEX:	/* Extended FP R/M field with op code (/digit) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			if ((c&0xc0) == 0xc0)
+				c = (c&0x3f)+8;		/* 64-entry table */
+			else
+				c = ip->reg;
+			obase = (Optable*)op->proto;
+			goto newop;
+		case RMR:	/* R/M register only (mod = 11) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if ((c&0xc0) != 0xc0) {
+				werrstr("invalid R/M register: %x", c);
+				return 0;
+			}
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			break;
+		case RMM:	/* R/M register only (mod = 11) */
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			if ((c&0xc0) == 0xc0) {
+				werrstr("invalid R/M memory mode: %x", c);
+				return 0;
+			}
+			if (modrm(map, ip, c) < 0)
+				return 0;
+			break;
+		case PTR:	/* Seg:Displacement addr (ptr16:16 or ptr16:32) */
+			if (ip->osize == 'L') {
+				if (igetl(map, ip, &ip->disp) < 0)
+					return 0;
+			} else {
+				if (igets(map, ip, &s)< 0)
+					return 0;
+				ip->disp = s&0xffff;
+			}
+			if (igets(map, ip, (ushort*)&ip->seg) < 0)
+				return 0;
+			ip->jumptype = PTR;
+			break;
+		case AUX:	/* Multi-byte op code - Auxiliary table */
+			obase = (Optable*)op->proto;
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			goto newop;
+		case PRE:	/* Instr Prefix */
+			ip->prefix = (char*)op->proto;
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			goto newop;
+		case SEG:	/* Segment Prefix */
+			ip->segment = (char*)op->proto;
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			goto newop;
+		case OPOVER:	/* Operand size override */
+			ip->osize = 'W';
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			goto newop;
+		case ADDOVER:	/* Address size override */
+			ip->asize = 0;
+			if (igetc(map, ip, &c) < 0)
+				return 0;
+			goto newop;
+		case JUMP:	/* mark instruction as JUMP or RET */
+		case RET:
+			ip->jumptype = op->operand[i];
+			break;
+		default:
+			werrstr("bad operand type %d", op->operand[i]);
+			return 0;
+		}
+	}
+	return op;
+}
+
+static void
+bprint(Instr *ip, char *fmt, ...)
+{
+	va_list arg;
+
+	va_start(arg, fmt);
+	ip->curr = vseprint(ip->curr, ip->end, fmt, arg);
+	va_end(arg);
+}
+
+/*
+ *  if we want to call 16 bit regs AX,BX,CX,...
+ *  and 32 bit regs EAX,EBX,ECX,... then
+ *  change the defs of ANAME and ONAME to:
+ *  #define	ANAME(ip)	((ip->asize == 'E' ? "E" : "")
+ *  #define	ONAME(ip)	((ip)->osize == 'L' ? "E" : "")
+ */
+#define	ANAME(ip)	""
+#define	ONAME(ip)	""
+
+static char *reg[] =  {
+	"AX",		/* 0 */
+	"CX",		/* 1 */
+	"DX",		/* 2 */
+	"BX",		/* 3 */
+	"SP",		/* 4 */
+	"BP",		/* 5 */
+	"SI",		/* 6 */
+	"DI",		/* 7 */
+};
+
+static char *breg[] = { "AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH" };
+static char *sreg[] = { "ES", "CS", "SS", "DS", "FS", "GS" };
+
+static void
+plocal(Instr *ip)
+{
+	int ret, offset;
+	Symbol s;
+	char *reg;
+
+	offset = ip->disp;
+	if (!findsym(ip->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s)) {
+		bprint(ip, "%lux(SP)", offset);
+		return;
+	}
+
+	if (s.value > ip->disp) {
+		ret = getauto(&s, s.value-ip->disp-mach->szaddr, CAUTO, &s);
+		reg = "(SP)";
+	} else {
+		offset -= s.value;
+		ret = getauto(&s, offset, CPARAM, &s);
+		reg = "(FP)";
+	}
+	if (ret)
+		bprint(ip, "%s+", s.name);
+	else
+		offset = ip->disp;
+	bprint(ip, "%lux%s", offset, reg);
+}
+
+static void
+pea(Instr *ip)
+{
+	if (ip->mod == 3) {
+		if (ip->osize == 'B')
+			bprint(ip, breg[ip->base]);
+		else
+			bprint(ip, "%s%s", ANAME(ip), reg[ip->base]);
+		return;
+	}
+	if (ip->segment)
+		bprint(ip, ip->segment);
+	if (ip->asize == 'E' && ip->base == SP)
+		plocal(ip);
+	else {
+		bprint(ip,"%lux", ip->disp);
+		if (ip->base >= 0)
+			bprint(ip,"(%s%s)", ANAME(ip), reg[ip->base]);
+	}
+	if (ip->index >= 0)
+		bprint(ip,"(%s%s*%d)", ANAME(ip), reg[ip->index], 1<<ip->ss);
+}
+
+static void
+immediate(Instr *ip, long val)
+{
+	Symbol s;
+	long w;
+
+	if (findsym(val, CANY, &s)) {
+		w = val - s.value;
+		if (w < 0)
+			w = -w;
+		if (w < 4096) {
+			if (w)
+				bprint(ip, "%s+%lux(SB)", s.name, w);
+			else
+				bprint(ip, "%s(SB)", s.name);
+			return;
+		}
+	}
+	bprint(ip, "%lux", val);
+}
+
+static void
+prinstr(Instr *ip, char *fmt)
+{
+	if (ip->prefix)
+		bprint(ip, "%s ", ip->prefix);
+	for (; *fmt && ip->curr < ip->end; fmt++) {
+		if (*fmt != '%')
+			*ip->curr++ = *fmt;
+		else switch(*++fmt)
+		{
+		case '%':
+			*ip->curr++ = '%';
+			break;
+		case 'A':
+			bprint(ip, "%s", ANAME(ip));
+			break;
+		case 'C':
+			bprint(ip, "CR%d", ip->reg);
+			break;
+		case 'D':
+			if (ip->reg < 4 || ip->reg == 6 || ip->reg == 7)
+				bprint(ip, "DR%d",ip->reg);
+			else
+				bprint(ip, "???");
+			break;
+		case 'I':
+			bprint(ip, "$");
+			immediate(ip, ip->imm2);
+			break;
+		case 'O':
+			bprint(ip,"%s", ONAME(ip));
+			break;
+		case 'i':
+			bprint(ip, "$");
+			immediate(ip,ip->imm);
+			break;
+		case 'R':
+			bprint(ip, "%s%s", ONAME(ip), reg[ip->reg]);
+			break;
+		case 'S':
+			bprint(ip, "%c", ip->osize);
+			break;
+		case 'T':
+			if (ip->reg == 6 || ip->reg == 7)
+				bprint(ip, "TR%d",ip->reg);
+			else
+				bprint(ip, "???");
+			break;
+		case 'X':
+			if (ip->osize == 'L')
+				bprint(ip,"CWDE");
+			else
+				bprint(ip, "CBW");
+			break;
+		case 'd':
+			bprint(ip,"%lux:%lux",ip->seg,ip->disp);
+			break;
+		case 'e':
+			pea(ip);
+			break;
+		case 'f':
+			bprint(ip, "F%d", ip->base);
+			break;
+		case 'g':
+			if (ip->reg < 6)
+				bprint(ip,"%s",sreg[ip->reg]);
+			else
+				bprint(ip,"???");
+			break;
+		case 'p':
+			immediate(ip, ip->imm+ip->addr+ip->n);
+			break;
+		case 'r':
+			if (ip->osize == 'B')
+				bprint(ip,"%s",breg[ip->reg]);
+			else
+				bprint(ip, reg[ip->reg]);
+			break;
+		case 'x':
+			if (ip->osize == 'L')
+				bprint(ip,"CDQ");
+			else
+				bprint(ip, "CWD");
+			break;
+		default:
+			bprint(ip, "%%%c", *fmt);
+			break;
+		}
+	}
+	*ip->curr = 0;		/* there's always room for 1 byte */
+}
+
+static int
+i386inst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	Instr	instr;
+	Optable *op;
+
+	USED(modifier);
+	op = mkinstr(map, &instr, pc);
+	if (op == 0) {
+		buf[0] = 0;
+		errstr(buf, n);
+		return -1;
+	}
+	instr.curr = buf;
+	instr.end = buf+n-1;
+	prinstr(&instr, op->proto);
+	return instr.n;
+}
+
+static int
+i386das(Map *map, ulong pc, char *buf, int n)
+{
+	Instr	instr;
+	int i;
+
+	if (mkinstr(map, &instr, pc) == 0) {
+		buf[0] = 0;
+		errstr(buf, n);
+		return -1;
+	}
+	for(i = 0; i < instr.n && n > 2; i++) {
+		_hexify(buf, instr.mem[i], 1);
+		buf += 2;
+		n -= 2;
+	}
+	*buf = 0;
+	return instr.n;
+}
+
+static int
+i386instlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	if (mkinstr(map, &i, pc))
+		return i.n;
+	return -1;
+}
+
+static int
+i386foll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	Instr i;
+	Optable *op;
+	ushort s;
+	ulong l, addr;
+	int n;
+
+	op = mkinstr(map, &i, pc);
+	if (!op)
+		return -1;
+
+	n = 0;
+
+	switch(i.jumptype) {
+	case RET:		/* RETURN or LEAVE */
+	case Iw:		/* RETURN */
+		if (strcmp(op->proto, "LEAVE") == 0) {
+			if (get4(map, (*rget)(map, "BP"), (long*)&l) < 0)
+				return -1;
+		} else if (get4(map, (*rget)(map, mach->sp), (long*)&l) < 0)
+			return -1;
+		foll[0] = l;
+		return 1;
+	case Iwds:		/* pc relative JUMP or CALL*/
+	case Jbs:		/* pc relative JUMP or CALL */
+		foll[0] = pc+i.imm+i.n;
+		n = 1;
+		break;
+	case PTR:		/* seg:displacement JUMP or CALL */
+		foll[0] = (i.seg<<4)+i.disp;
+		return 1;
+	case JUMP:		/* JUMP or CALL EA */
+
+		if(i.mod == 3) {
+			foll[0] = (*rget)(map, reg[i.base]);
+			return 1;
+		}
+			/* calculate the effective address */
+		addr = i.disp;
+		if (i.base >= 0) {
+			if (get4(map, (*rget)(map, reg[i.base]), (long*)&l) < 0)
+				return -1;
+			addr += l;
+		}
+		if (i.index >= 0) {
+			if (get4(map, (*rget)(map, reg[i.index]), (long*)&l) < 0)
+				return -1;
+			addr += l*(1<<i.ss);
+		}
+			/* now retrieve a seg:disp value at that address */
+		if (get2(map, addr, &s) < 0)		/* seg */
+			return -1;
+		foll[0] = s<<4;
+		addr += 2;
+		if (i.asize == 'L') {
+			if (get4(map, addr, (long*)&l) < 0)	/* disp32 */
+				return -1;
+			foll[0] += l;
+		} else {					/* disp16 */
+			if (get2(map, addr, &s) < 0)
+				return -1;
+			foll[0] += s;
+		}
+		return 1;
+	default:
+		break;
+	}		
+	if (strncmp(op->proto,"JMP", 3) == 0 || strncmp(op->proto,"CALL", 4) == 0)
+		return 1;
+	foll[n++] = pc+i.n;
+	return n;
+}
diff --git a/utils/libmach/8obj.c b/utils/libmach/8obj.c
new file mode 100644
index 00000000..9e322f12
--- /dev/null
+++ b/utils/libmach/8obj.c
@@ -0,0 +1,133 @@
+/*
+ * 8obj.c - identify and parse a 386 object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "8c/8.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	sym;
+	char	flags;
+};
+static	Addr	addr(Biobuf*);
+static	char	type2char(int);
+static	void	skip(Biobuf*, int);
+
+int
+_is8(char *t)
+{
+	uchar *s = (uchar*)t;
+
+	return  s[0] == (ANAME&0xff)			/* aslo = ANAME */
+		&& s[1] == ((ANAME>>8)&0xff)
+		&& s[2] == D_FILE			/* type */
+		&& s[3] == 1				/* sym */
+		&& s[4] == '<';				/* name of file */
+}
+
+int
+_read8(Biobuf *bp, Prog* p)
+{
+	int as, n, c;
+	Addr a;
+
+	as = Bgetc(bp);		/* as(low) */
+	if(as < 0)
+		return 0;
+	c = Bgetc(bp);		/* as(high) */
+	if(c < 0)
+		return 0;
+	as |= ((c & 0xff) << 8);
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 4);		/* lineno(4) */
+	a = addr(bp);
+	addr(bp);
+	if(!(a.flags & T_SYM))
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	int t;
+	long off;
+
+	off = 0;
+	a.sym = -1;
+	a.flags = Bgetc(bp);			/* flags */
+	if(a.flags & T_INDEX)
+		skip(bp, 2);
+	if(a.flags & T_OFFSET){
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+	}
+	if(a.flags & T_SYM)
+		a.sym = Bgetc(bp);
+	if(a.flags & T_FCONST)
+		skip(bp, 8);
+	else
+	if(a.flags & T_SCONST)
+		skip(bp, NSNAME);
+	if(a.flags & T_TYPE) {
+		t = Bgetc(bp);
+		if(a.sym > 0 && (t==D_PARAM || t==D_AUTO))
+			_offset(a.sym, off);
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/NOTICE b/utils/libmach/NOTICE
new file mode 100644
index 00000000..53798daf
--- /dev/null
+++ b/utils/libmach/NOTICE
@@ -0,0 +1,31 @@
+This copyright NOTICE applies to all files in this directory and
+subdirectories, unless another copyright notice appears in a given
+file or subdirectory.  If you take substantial code from this software to use in
+other programs, you must somehow include with it an appropriate
+copyright notice that includes the copyright notice and the other
+notices below.  It is fine (and often tidier) to do that in a separate
+file such as NOTICE, LICENCE or COPYING.
+
+	Copyright © 1994-1999 Lucent Technologies Inc.
+	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+	Portions Copyright © 1997-1999 Vita Nuova Limited.
+	Portions Copyright © 2000-2006 Vita Nuova Holdings Limited (www.vitanuova.com).
+	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/utils/libmach/a.out.h b/utils/libmach/a.out.h
new file mode 100644
index 00000000..8c0b7137
--- /dev/null
+++ b/utils/libmach/a.out.h
@@ -0,0 +1,45 @@
+typedef	struct	Exec	Exec;
+struct	Exec
+{
+	long	magic;		/* magic number */
+	long	text;	 	/* size of text segment */
+	long	data;	 	/* size of initialized data */
+	long	bss;	  	/* size of uninitialized data */
+	long	syms;	 	/* size of symbol table */
+	long	entry;	 	/* entry point */
+	long	spsz;		/* size of pc/sp offset table */
+	long	pcsz;		/* size of pc/line number table */
+};
+
+
+#define HDR_MAGIC	0x00008000		/* header expansion */
+
+#define	_MAGIC(f, b)	((f)|((((4*(b))+0)*(b))+7))
+#define	A_MAGIC		_MAGIC(0, 8)		/* 68020 */
+#define	I_MAGIC		_MAGIC(0, 11)		/* intel 386 */
+#define	J_MAGIC		_MAGIC(0, 12)		/* intel 960 (retired) */
+#define	K_MAGIC		_MAGIC(0, 13)		/* sparc */
+#define	V_MAGIC		_MAGIC(0, 16)		/* mips 3000 BE */
+#define	X_MAGIC		_MAGIC(0, 17)		/* att dsp 3210 (retired) */
+#define	M_MAGIC		_MAGIC(0, 18)		/* mips 4000 BE */
+#define	D_MAGIC		_MAGIC(0, 19)		/* amd 29000 (retired) */
+#define	E_MAGIC		_MAGIC(0, 20)		/* arm */
+#define	Q_MAGIC		_MAGIC(0, 21)		/* powerpc */
+#define	N_MAGIC		_MAGIC(0, 22)		/* mips 4000 LE */
+#define	L_MAGIC		_MAGIC(0, 23)		/* dec alpha */
+#define	P_MAGIC		_MAGIC(0, 24)		/* mips 3000 LE */
+#define	U_MAGIC		_MAGIC(0, 25)		/* sparc64 */
+#define	S_MAGIC		_MAGIC(HDR_MAGIC, 26)	/* amd64 */
+
+#define	MIN_MAGIC	8
+#define	MAX_MAGIC	26			/* <= 90 */
+
+#define	DYN_MAGIC	0x80000000	/* or'd in for dynamically loaded modules */
+
+typedef	struct	Sym	Sym;
+struct	Sym
+{
+	long	value;
+	char	type;
+	char	*name;
+};
diff --git a/utils/libmach/access.c b/utils/libmach/access.c
new file mode 100644
index 00000000..6a58cdea
--- /dev/null
+++ b/utils/libmach/access.c
@@ -0,0 +1,215 @@
+/*
+ * functions to read and write an executable or file image
+ */
+
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+static	int	mget(Map*, ulong, char*, int);
+static	int	mput(Map*, ulong, char*, int);
+struct segment*	reloc(Map*, ulong, long*);
+
+/*
+ * routines to get/put various types
+ */
+
+int
+get8(Map *map, ulong addr, vlong *x)
+{
+	if (!map) {
+		werrstr("get8: invalid map");
+		return -1;
+	}
+
+	if (map->nsegs == 1 && map->seg[0].fd < 0) {
+		*x = (vlong)addr;
+		return 1;
+	}
+	if (mget(map, addr, (char *)x, 8) < 0)
+		return -1;
+	*x = machdata->swav(*x);
+	return (1);
+}
+
+int
+get4(Map *map, ulong addr, long *x)
+{
+	if (!map) {
+		werrstr("get4: invalid map");
+		return -1;
+	}
+
+	if (map->nsegs == 1 && map->seg[0].fd < 0) {
+		*x = addr;
+		return 1;
+	}
+	if (mget(map, addr, (char *)x, 4) < 0)
+		return -1;
+	*x = machdata->swal(*x);
+	return (1);
+}
+
+int
+get2(Map *map, ulong addr, ushort *x)
+{
+	if (!map) {
+		werrstr("get2: invalid map");
+		return -1;
+	}
+
+	if (map->nsegs == 1 && map->seg[0].fd < 0) {
+		*x = addr;
+		return 1;
+	}
+	if (mget(map, addr, (char *)x, 2) < 0)
+		return -1;
+	*x = machdata->swab(*x);
+	return (1);
+}
+
+int
+get1(Map *map, ulong addr, uchar *x, int size)
+{
+	uchar *cp;
+
+	if (!map) {
+		werrstr("get1: invalid map");
+		return -1;
+	}
+
+	if (map->nsegs == 1 && map->seg[0].fd < 0) {
+		cp = (uchar*)&addr;
+		while (cp < (uchar*)(&addr+1) && size-- > 0)
+			*x++ = *cp++;
+		while (size-- > 0)
+			*x++ = 0;
+	} else
+		return mget(map, addr, (char*)x, size);
+	return 1;
+}
+
+int
+put8(Map *map, ulong addr, vlong v)
+{
+	if (!map) {
+		werrstr("put8: invalid map");
+		return -1;
+	}
+	v = machdata->swav(v);
+	return mput(map, addr, (char *)&v, 8);
+}
+
+int
+put4(Map *map, ulong addr, long v)
+{
+	if (!map) {
+		werrstr("put4: invalid map");
+		return -1;
+	}
+	v = machdata->swal(v);
+	return mput(map, addr, (char *)&v, 4);
+}
+
+int
+put2(Map *map, ulong addr, ushort v)
+{
+	if (!map) {
+		werrstr("put2: invalid map");
+		return -1;
+	}
+	v = machdata->swab(v);
+	return mput(map, addr, (char *)&v, 2);
+}
+
+int
+put1(Map *map, ulong addr, uchar *v, int size)
+{
+	if (!map) {
+		werrstr("put1: invalid map");
+		return -1;
+	}
+	return mput(map, addr, (char *)v, size);
+}
+
+static int
+mget(Map *map, ulong addr, char *buf, int size)
+{
+	long off;
+	int i, j, k;
+	struct segment *s;
+
+	s = reloc(map, addr, &off);
+	if (!s)
+		return -1;
+	if (s->fd < 0) {
+		werrstr("unreadable map");
+		return -1;
+	}
+	if (s->mget)
+		return s->mget(s, addr, off, buf, size);
+	seek(s->fd, off, 0);
+	for (i = j = 0; i < 2; i++) {	/* in case read crosses page */
+		k = read(s->fd, buf, size-j);
+		if (k < 0) {
+			werrstr("can't read address %lux: %r", addr);
+			return -1;
+		}
+		j += k;
+		if (j == size)
+			return j;
+	}
+	werrstr("partial read at address %lux", addr);
+	return -1;
+}
+
+static int
+mput(Map *map, ulong addr, char *buf, int size)
+{
+	long off;
+	int i, j, k;
+	struct segment *s;
+
+	s = reloc(map, addr, &off);
+	if (!s)
+		return -1;
+	if (s->fd < 0) {
+		werrstr("unwritable map");
+		return -1;
+	}
+	if (s->mput)
+		return s->mput(s, addr, off, buf, size);
+
+	seek(s->fd, off, 0);
+	for (i = j = 0; i < 2; i++) {	/* in case read crosses page */
+		k = write(s->fd, buf, size-j);
+		if (k < 0) {
+			werrstr("can't write address %lux: %r", addr);
+			return -1;
+		}
+		j += k;
+		if (j == size)
+			return j;
+	}
+	werrstr("partial write at address %lux", addr);
+	return -1;
+}
+
+/*
+ *	convert address to file offset; returns nonzero if ok
+ */
+struct segment*
+reloc(Map *map, ulong addr, long *offp)
+{
+	int i;
+
+	for (i = 0; i < map->nsegs; i++) {
+		if (map->seg[i].inuse)
+		if (map->seg[i].b <= addr && addr < map->seg[i].e) {
+			*offp = addr + map->seg[i].f - map->seg[i].b;
+			return &map->seg[i];
+		}
+	}
+	werrstr("can't translate address %lux", addr);
+	return 0;
+}
diff --git a/utils/libmach/ar.h b/utils/libmach/ar.h
new file mode 100644
index 00000000..71ffff12
--- /dev/null
+++ b/utils/libmach/ar.h
@@ -0,0 +1,18 @@
+#define	ARMAG	"!<arch>\n"
+#define	SARMAG	8
+
+#define	ARFMAG	"`\n"
+#define SARNAME	16
+
+struct	ar_hdr
+{
+	char	name[SARNAME];
+	char	date[12];
+	char	uid[6];
+	char	gid[6];
+	char	mode[8];
+	char	size[10];
+	char	fmag[2];
+};
+#define	SAR_HDR	60
+
diff --git a/utils/libmach/bootexec.h b/utils/libmach/bootexec.h
new file mode 100644
index 00000000..a844ec7c
--- /dev/null
+++ b/utils/libmach/bootexec.h
@@ -0,0 +1,172 @@
+struct coffsect
+{
+	char	name[8];
+	ulong	phys;
+	ulong	virt;
+	ulong	size;
+	ulong	fptr;
+	ulong	fptrreloc;
+	ulong	fptrlineno;
+	ulong	nrelocnlineno;
+	ulong	flags;
+};
+
+/*
+ * proprietary exec headers, needed to bootstrap various machines
+ */
+struct mipsexec
+{
+	short	mmagic;		/* (0x160) mips magic number */
+	short	nscns;		/* (unused) number of sections */
+	long	timdat;		/* (unused) time & date stamp */
+	long	symptr;		/* offset to symbol table */
+	long	nsyms;		/* size of symbol table */
+	short	opthdr;		/* (0x38) sizeof(optional hdr) */
+	short	pcszs;		/* flags */
+	short	amagic;		/* see above */
+	short	vstamp;		/* version stamp */
+	long	tsize;		/* text size in bytes */
+	long	dsize;		/* initialized data */
+	long	bsize;		/* uninitialized data */
+	long	mentry;		/* entry pt.				*/
+	long	text_start;	/* base of text used for this file	*/
+	long	data_start;	/* base of data used for this file	*/
+	long	bss_start;	/* base of bss used for this file	*/
+	long	gprmask;	/* general purpose register mask	*/
+union{
+	long	mcprmask[4];	/* co-processor register masks		*/
+	long	mpcsize;
+} u0;
+	long	gp_value;	/* the gp value used for this object    */
+};
+
+struct mips4kexec
+{
+	struct mipsexec	h;
+	struct coffsect	itexts;
+	struct coffsect idatas;
+	struct coffsect ibsss;
+};
+
+struct sparcexec
+{
+	short	sjunk;		/* dynamic bit and version number */
+	short	smagic;		/* 0407 */
+	ulong	stext;
+	ulong	sdata;
+	ulong	sbss;
+	ulong	ssyms;
+	ulong	sentry;
+	ulong	strsize;
+	ulong	sdrsize;
+};
+
+struct nextexec
+{
+	struct	nexthdr{
+		ulong	nmagic;
+		ulong	ncputype;
+		ulong	ncpusubtype;
+		ulong	nfiletype;
+		ulong	ncmds;
+		ulong	nsizeofcmds;
+		ulong	nflags;
+	}texth;
+
+	struct nextcmd{
+		ulong	cmd;
+		ulong	cmdsize;
+		uchar	segname[16];
+		ulong	vmaddr;
+		ulong	vmsize;
+		ulong	fileoff;
+		ulong	filesize;
+		ulong	maxprot;
+		ulong	initprot;
+		ulong	nsects;
+		ulong	flags;
+	}textc;
+	struct nextsect{
+		char	sectname[16];
+		char	segname[16];
+		ulong	addr;
+		ulong	size;
+		ulong	offset;
+		ulong	align;
+		ulong	reloff;
+		ulong	nreloc;
+		ulong	flags;
+		ulong	reserved1;
+		ulong	reserved2;
+	}texts;
+	struct nextcmd	datac;
+	struct nextsect	datas;
+	struct nextsect	bsss;
+	struct nextsym{
+		ulong	cmd;
+		ulong	cmdsize;
+		ulong	symoff;
+		ulong	nsyms;
+		ulong	spoff;
+		ulong	pcoff;
+	}symc;
+};
+
+struct i386exec
+{
+	struct	i386coff{
+		ulong	isectmagic;
+		ulong	itime;
+		ulong	isyms;
+		ulong	insyms;
+		ulong	iflags;
+	} icoff;
+	struct	i386hdr{
+		ulong	imagic;
+		ulong	itextsize;
+		ulong	idatasize;
+		ulong	ibsssize;
+		ulong	ientry;
+		ulong	itextstart;
+		ulong	idatastart;
+	} ihdr;
+	struct coffsect	itexts;
+	struct coffsect idatas;
+	struct coffsect ibsss;
+	struct coffsect icomments;
+};
+
+struct i960exec
+{
+	struct	i960coff{
+		ulong	i6sectmagic;
+		ulong	i6time;
+		ulong	i6syms;
+		ulong	i6nsyms;
+		ulong	i6opthdrflags;
+	}i6coff;
+	struct	i960hdr{
+		ulong	i6magic;
+		ulong	i6textsize;
+		ulong	i6datasize;
+		ulong	i6bsssize;
+		ulong	i6entry;
+		ulong	i6textstart;
+		ulong	i6datastart;
+		ulong	i6tagentries;
+	}i6hdr;
+	struct i960sect{
+		char	name[8];
+		ulong	phys;
+		ulong	virt;
+		ulong	size;
+		ulong	fptr;
+		ulong	fptrreloc;
+		ulong	fptrlineno;
+		ulong	nrelocnlineno;
+		ulong	flags;
+		ulong	align;
+	}i6texts;
+	struct i960sect i6datas;
+};
+
diff --git a/utils/libmach/elf.h b/utils/libmach/elf.h
new file mode 100644
index 00000000..b182135b
--- /dev/null
+++ b/utils/libmach/elf.h
@@ -0,0 +1,101 @@
+/*
+ *	Definitions needed for  accessing Irix ELF headers
+ */
+typedef struct {
+	unsigned char	ident[16];	/* ident bytes */
+	ushort		type;		/* file type */
+	ushort		machine;	/* target machine */
+	int		version;	/* file version */
+	ulong		elfentry;	/* start address */
+	ulong		phoff;		/* phdr file offset */
+	ulong		shoff;		/* shdr file offset */
+	int		flags;		/* file flags */
+	ushort		ehsize;		/* sizeof ehdr */
+	ushort		phentsize;	/* sizeof phdr */
+	ushort		phnum;		/* number phdrs */
+	ushort		shentsize;	/* sizeof shdr */
+	ushort		shnum;		/* number shdrs */
+	ushort		shstrndx;	/* shdr string index */
+} Ehdr;
+
+typedef struct {
+	int	type;		/* entry type */
+	ulong	offset;		/* file offset */
+	ulong	vaddr;		/* virtual address */
+	ulong	paddr;		/* physical address */
+	int	filesz;		/* file size */
+	ulong	memsz;		/* memory size */
+	int	flags;		/* entry flags */
+	int	align;		/* memory/file alignment */
+} Phdr;
+
+typedef struct {
+	ulong	name;		/* section name */
+	ulong	type;		/* SHT_... */
+	ulong	flags;		/* SHF_... */
+	ulong	addr;		/* virtual address */
+	ulong	offset;		/* file offset */
+	ulong	size;		/* section size */
+	ulong	link;		/* misc info */
+	ulong	info;		/* misc info */
+	ulong	addralign;	/* memory alignment */
+	ulong	entsize;	/* entry size if table */
+} Shdr;
+
+enum {
+	/* Ehdr codes */
+	MAG0 = 0,		/* ident[] indexes */
+	MAG1 = 1,
+	MAG2 = 2,
+	MAG3 = 3,
+	CLASS = 4,
+	DATA = 5,
+	VERSION = 6,
+
+	ELFCLASSNONE = 0,	/* ident[CLASS] */
+	ELFCLASS32 = 1,
+	ELFCLASS64 = 2,
+	ELFCLASSNUM = 3,
+
+	ELFDATANONE = 0,	/* ident[DATA] */
+	ELFDATA2LSB = 1,
+	ELFDATA2MSB = 2,
+	ELFDATANUM = 3,
+
+	NOETYPE = 0,		/* type */
+	REL = 1,
+	EXEC = 2,
+	DYN = 3,
+	CORE = 4,
+
+	NONE = 0,		/* machine */
+	M32 = 1,		/* AT&T WE 32100 */
+	SPARC = 2,		/* Sun SPARC */
+	I386 = 3,		/* Intel 80386 */
+	M68K = 4,		/* Motorola 68000 */
+	M88K = 5,		/* Motorola 88000 */
+	I486 = 6,		/* Intel 80486 */
+	I860 = 7,		/* Intel i860 */
+	MIPS = 8,		/* Mips R2000 */
+	S370 = 9,		/* Amdhal	*/
+	POWER = 20,		/* PowerPC */
+	AMD64 = 62,		/* Amd64 */
+
+	NO_VERSION = 0,		/* version, ident[VERSION] */
+	CURRENT = 1,
+
+	/* Phdr Codes */
+	NOPTYPE = 0,		/* type */
+	LOAD = 1,
+	DYNAMIC = 2,
+	INTERP = 3,
+	NOTE = 4,
+	SHLIB = 5,
+	PHDR = 6,
+
+	R = 0x4,		/* flags */
+	W = 0x2,
+	X = 0x1,
+};
+
+#define	ELF_MAG		((0x7f<<24) | ('E'<<16) | ('L'<<8) | 'F')
diff --git a/utils/libmach/executable.c b/utils/libmach/executable.c
new file mode 100644
index 00000000..a17d6ae2
--- /dev/null
+++ b/utils/libmach/executable.c
@@ -0,0 +1,570 @@
+#include	<lib9.h>
+#include	<bio.h>
+#include	"bootexec.h"
+#include	"mach.h"
+#include	"elf.h"
+
+/*
+ *	All a.out header types.  The dummy entry allows canonical
+ *	processing of the union as a sequence of longs
+ */
+
+typedef struct {
+	union{
+		Exec exec;			/* in a.out.h */
+		Ehdr ehdr;			/* in elf.h */
+		struct mipsexec mipsexec;
+		struct mips4kexec mips4kexec;
+		struct sparcexec sparcexec;
+		struct nextexec nextexec;
+	} e;
+	long dummy;		/* padding to ensure extra long */
+} ExecHdr;
+
+static	int	nextboot(int, Fhdr*, ExecHdr*);
+static	int	sparcboot(int, Fhdr*, ExecHdr*);
+static	int	mipsboot(int, Fhdr*, ExecHdr*);
+static	int	mips4kboot(int, Fhdr*, ExecHdr*);
+static	int	common(int, Fhdr*, ExecHdr*);
+static	int	adotout(int, Fhdr*, ExecHdr*);
+static	int	elfdotout(int, Fhdr*, ExecHdr*);
+static	int	armdotout(int, Fhdr*, ExecHdr*);
+static	void	setsym(Fhdr*, long, long, long, long);
+static	void	setdata(Fhdr*, long, long, long, long);
+static	void	settext(Fhdr*, long, long, long, long);
+static	void	hswal(long*, int, long(*)(long));
+static	long	_round(long, long);
+
+/*
+ *	definition of per-executable file type structures
+ */
+
+typedef struct Exectable{
+	long	magic;			/* big-endian magic number of file */
+	char	*name;			/* executable identifier */
+	int	type;			/* Internal code */
+	Mach	*mach;			/* Per-machine data */
+	ulong	hsize;			/* header size */
+	long	(*swal)(long);		/* beswal or leswal */
+	int	(*hparse)(int, Fhdr*, ExecHdr*);
+} ExecTable;
+
+extern	Mach	mmips;
+extern	Mach	mmips2le;
+extern	Mach	mmips2be;
+extern	Mach	msparc;
+extern	Mach	m68020;
+extern	Mach	mi386;
+extern	Mach	marm;
+extern	Mach	mpower;
+
+ExecTable exectab[] =
+{
+	{ V_MAGIC,			/* Mips v.out */
+		"mips plan 9 executable",
+		FMIPS,
+		&mmips,
+		sizeof(Exec),
+		beswal,
+		adotout },
+	{ M_MAGIC,			/* Mips 4.out */
+		"mips 4k plan 9 executable BE",
+		FMIPS2BE,
+		&mmips2be,
+		sizeof(Exec),
+		beswal,
+		adotout },
+	{ N_MAGIC,			/* Mips 0.out */
+		"mips 4k plan 9 executable LE",
+		FMIPS2LE,
+		&mmips2le,
+		sizeof(Exec),
+		beswal,
+		adotout },
+	{ 0x160<<16,			/* Mips boot image */
+		"mips plan 9 boot image",
+		FMIPSB,
+		&mmips,
+		sizeof(struct mipsexec),
+		beswal,
+		mipsboot },
+	{ (0x160<<16)|3,		/* Mips boot image */
+		"mips 4k plan 9 boot image",
+		FMIPSB,
+		&mmips,
+		sizeof(struct mips4kexec),
+		beswal,
+		mips4kboot },
+	{ K_MAGIC,			/* Sparc k.out */
+		"sparc plan 9 executable",
+		FSPARC,
+		&msparc,
+		sizeof(Exec),
+		beswal,
+		adotout },
+	{ 0x01030107, 			/* Sparc boot image */
+		"sparc plan 9 boot image",
+		FSPARCB,
+		&msparc,
+		sizeof(struct sparcexec),
+		beswal,
+		sparcboot },
+	{ A_MAGIC,			/* 68020 2.out & boot image */
+		"68020 plan 9 executable",
+		F68020,
+		&m68020,
+		sizeof(Exec),
+		beswal,
+		common },
+	{ 0xFEEDFACE,			/* Next boot image */
+		"next plan 9 boot image",
+		FNEXTB,
+		&m68020,
+		sizeof(struct nextexec),
+		beswal,
+		nextboot },
+	{ I_MAGIC,			/* I386 8.out & boot image */
+		"386 plan 9 executable",
+		FI386,
+		&mi386,
+		sizeof(Exec),
+		beswal,
+		common },
+	{ ELF_MAG,
+		"Irix 5.X Elf executable",
+		FMIPS,
+		&mmips,
+		sizeof(Ehdr),
+		beswal,
+		elfdotout },
+	{ E_MAGIC,			/* Arm 5.out */
+		"Arm plan 9 executable",
+		FARM,
+		&marm,
+		sizeof(Exec),
+		beswal,
+		common },
+	{ (143<<16)|0413,		/* (Free|Net)BSD Arm */
+		"Arm *BSD executable",
+		FARM,
+		&marm,
+		sizeof(Exec),
+		leswal,
+		armdotout },
+	{ Q_MAGIC,			/* PowerPC q.out */
+		"power plan 9 executable",
+		FPOWER,
+		&mpower,
+		sizeof(Exec),
+		beswal,
+		common },
+	{ 0 },
+};
+
+Mach	*mach = &mmips;			/* Global current machine table */
+
+ExecTable*
+couldbe4k(ExecTable *mp)
+{
+	Dir *d;
+	ExecTable *f;
+
+	if((d=dirstat("/proc/1/regs")) == nil)
+		return mp;
+	if(d->length < 32*8){		/* R3000 */
+		free(d);
+		return mp;
+	}
+	free(d);
+	for (f = exectab; f->magic; f++)
+		if(f->magic == M_MAGIC) {
+			f->name = "mips plan 9 executable on mips2 kernel";
+			return f;
+		}
+	return mp;
+}
+
+
+int
+crackhdr(int fd, Fhdr *fp)
+{
+	ExecTable *mp;
+	ExecHdr d;
+	int nb, magic, ret;
+
+	fp->type = FNONE;
+	nb = read(fd, (char *)&d.e, sizeof(d.e));
+	if (nb <= 0)
+		return 0;
+
+	ret = 0;
+	fp->magic = magic = beswal(d.e.exec.magic);		/* big-endian */
+	for (mp = exectab; mp->magic; mp++) {
+		if (mp->magic == magic && nb >= mp->hsize) {
+			if(mp->magic == V_MAGIC)
+				mp = couldbe4k(mp);
+
+			hswal((long *) &d, sizeof(d.e)/sizeof(long), mp->swal);
+			fp->type = mp->type;
+			fp->name = mp->name;
+			fp->hdrsz = mp->hsize;		/* zero on bootables */
+			mach = mp->mach;
+			ret  = mp->hparse(fd, fp, &d);
+			seek(fd, mp->hsize, 0);		/* seek to end of header */
+			break;
+		}
+	}
+	if(mp->magic == 0)
+		werrstr("unknown header type");
+	return ret;
+}
+/*
+ * Convert header to canonical form
+ */
+static void
+hswal(long *lp, int n, long (*swap) (long))
+{
+	while (n--) {
+		*lp = (*swap) (*lp);
+		lp++;
+	}
+}
+/*
+ *	Crack a normal a.out-type header
+ */
+static int
+adotout(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	long pgsize;
+
+	USED(fd);
+	pgsize = mach->pgsize;
+	settext(fp, hp->e.exec.entry, pgsize+sizeof(Exec),
+			hp->e.exec.text, sizeof(Exec));
+	setdata(fp, _round(pgsize+fp->txtsz+sizeof(Exec), pgsize),
+		hp->e.exec.data, fp->txtsz+sizeof(Exec), hp->e.exec.bss);
+	setsym(fp, hp->e.exec.syms, hp->e.exec.spsz, hp->e.exec.pcsz, fp->datoff+fp->datsz);
+	return 1;
+}
+
+/*
+ *	68020 2.out and 68020 bootable images
+ *	386I 8.out and 386I bootable images
+ *
+ */
+static int
+common(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	long kbase;
+
+	adotout(fd, fp, hp);
+	kbase = mach->kbase;
+	if ((fp->entry & kbase) == kbase) {		/* Boot image */
+		switch(fp->type) {
+		case F68020:
+			fp->type = F68020B;
+			fp->name = "68020 plan 9 boot image";
+			fp->hdrsz = 0;		/* header stripped */
+			break;
+		case FI386:
+			fp->type = FI386B;
+			fp->txtaddr = sizeof(Exec);
+			fp->name = "386 plan 9 boot image";
+			fp->hdrsz = 0;		/* header stripped */
+			fp->dataddr = fp->txtaddr+fp->txtsz;
+			break;
+		case FARM:
+			fp->txtaddr = kbase+0x8000+sizeof(Exec);
+			fp->name = "ARM plan 9 boot image";
+			fp->hdrsz = 0;		/* header stripped */
+			fp->dataddr = fp->txtaddr+fp->txtsz;
+			return 1;
+		default:
+			break;
+		}
+		fp->txtaddr |= kbase;
+		fp->entry |= kbase;
+		fp->dataddr |= kbase;
+	}
+	else if (fp->type == FARM && (fp->entry == 0x8020 || fp->entry == 0x8080)) {
+		fp->txtaddr = fp->entry;
+		fp->name = "ARM Inferno boot image";
+		fp->hdrsz = 0;		/* header stripped */
+		fp->dataddr = fp->txtaddr+fp->txtsz;
+	}
+	else if (fp->type == FPOWER && fp->entry == 0x3020) {
+		fp->txtaddr = fp->entry;
+		fp->name = "Power Inferno boot image";
+		fp->hdrsz = 0;		/* header stripped */
+		fp->dataddr = fp->txtaddr+fp->txtsz;
+	}
+	return 1;
+}
+
+/*
+ *	mips bootable image.
+ */
+static int
+mipsboot(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	USED(fd);
+	switch(hp->e.mipsexec.amagic) {
+	default:
+	case 0407:	/* some kind of mips */
+		fp->type = FMIPSB;
+		settext(fp, hp->e.mipsexec.mentry, hp->e.mipsexec.text_start, hp->e.mipsexec.tsize,
+					sizeof(struct mipsexec)+4);
+		setdata(fp, hp->e.mipsexec.data_start, hp->e.mipsexec.dsize,
+				fp->txtoff+hp->e.mipsexec.tsize, hp->e.mipsexec.bsize);
+		break;
+	case 0413:	/* some kind of mips */
+		fp->type = FMIPSB;
+		settext(fp, hp->e.mipsexec.mentry, hp->e.mipsexec.text_start, hp->e.mipsexec.tsize, 0);
+		setdata(fp, hp->e.mipsexec.data_start, hp->e.mipsexec.dsize, hp->e.mipsexec.tsize,
+					hp->e.mipsexec.bsize);
+		break;
+	}
+	setsym(fp, hp->e.mipsexec.nsyms, 0, hp->e.mipsexec.u0.mpcsize, hp->e.mipsexec.symptr);
+	fp->hdrsz = 0;		/* header stripped */
+	return 1;
+}
+
+/*
+ *	mips4k bootable image.
+ */
+static int
+mips4kboot(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	USED(fd);
+	switch(hp->e.mipsexec.amagic) {
+	default:
+	case 0407:	/* some kind of mips */
+		fp->type = FMIPSB;
+		settext(fp, hp->e.mipsexec.mentry, hp->e.mipsexec.text_start, hp->e.mipsexec.tsize,
+					sizeof(struct mips4kexec));
+		setdata(fp, hp->e.mipsexec.data_start, hp->e.mipsexec.dsize,
+				fp->txtoff+hp->e.mipsexec.tsize, hp->e.mipsexec.bsize);
+		break;
+	case 0413:	/* some kind of mips */
+		fp->type = FMIPSB;
+		settext(fp, hp->e.mipsexec.mentry, hp->e.mipsexec.text_start, hp->e.mipsexec.tsize, 0);
+		setdata(fp, hp->e.mipsexec.data_start, hp->e.mipsexec.dsize, hp->e.mipsexec.tsize,
+					hp->e.mipsexec.bsize);
+		break;
+	}
+	setsym(fp, hp->e.mipsexec.nsyms, 0, hp->e.mipsexec.u0.mpcsize, hp->e.mipsexec.symptr);
+	fp->hdrsz = 0;		/* header stripped */
+	return 1;
+}
+
+/*
+ *	sparc bootable image
+ */
+static int
+sparcboot(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	USED(fd);
+	fp->type = FSPARCB;
+	settext(fp, hp->e.sparcexec.sentry, hp->e.sparcexec.sentry, hp->e.sparcexec.stext,
+					sizeof(struct sparcexec));
+	setdata(fp, hp->e.sparcexec.sentry+hp->e.sparcexec.stext, hp->e.sparcexec.sdata,
+					fp->txtoff+hp->e.sparcexec.stext, hp->e.sparcexec.sbss);
+	setsym(fp, hp->e.sparcexec.ssyms, 0, hp->e.sparcexec.sdrsize, fp->datoff+hp->e.sparcexec.sdata);
+	fp->hdrsz = 0;		/* header stripped */
+	return 1;
+}
+
+/*
+ *	next bootable image
+ */
+static int
+nextboot(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	USED(fd);
+	fp->type = FNEXTB;
+	settext(fp, hp->e.nextexec.textc.vmaddr, hp->e.nextexec.textc.vmaddr,
+					hp->e.nextexec.texts.size, hp->e.nextexec.texts.offset);
+	setdata(fp, hp->e.nextexec.datac.vmaddr, hp->e.nextexec.datas.size,
+				hp->e.nextexec.datas.offset, hp->e.nextexec.bsss.size);
+	setsym(fp, hp->e.nextexec.symc.nsyms, hp->e.nextexec.symc.spoff, hp->e.nextexec.symc.pcoff,
+					hp->e.nextexec.symc.symoff);
+	fp->hdrsz = 0;		/* header stripped */
+	return 1;
+}
+
+static Shdr*
+elfsectbyname(int fd, Ehdr *hp, Shdr *sp, char *name)
+{
+	int i, offset, n;
+	char s[64];
+
+	offset = sp[hp->shstrndx].offset;
+	for(i = 1; i < hp->shnum; i++) {
+		seek(fd, offset+sp[i].name, 0);
+		n = read(fd, s, sizeof(s)-1);
+		if(n < 0)
+			continue;
+		s[n] = 0;
+		if(strcmp(s, name) == 0)
+			return &sp[i]; 
+	}
+	return 0;
+}
+/*
+ *	Decode an Irix 5.x ELF header
+ */
+static int
+elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
+{
+
+	Ehdr *ep;
+	Shdr *es, *txt, *init, *s;
+	long addr, size, offset, bsize;
+
+	ep = &hp->e.ehdr;
+	fp->magic = ELF_MAG;
+	fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
+
+	if(ep->shnum <= 0) {
+		werrstr("no ELF header sections");
+		return 0;
+	}
+	es = malloc(sizeof(Shdr)*ep->shnum);
+	if(es == 0)
+		return 0;
+
+	seek(fd, ep->shoff, 0);
+	if(read(fd, es, sizeof(Shdr)*ep->shnum) < 0){
+		free(es);
+		return 0;
+	}
+
+	txt = elfsectbyname(fd, ep, es, ".text");
+	init = elfsectbyname(fd, ep, es, ".init");
+	if(txt == 0 || init == 0 || init != txt+1)
+		goto bad;
+	if(txt->addr+txt->size != init->addr)
+		goto bad;
+	settext(fp, ep->elfentry, txt->addr, txt->size+init->size, txt->offset);
+
+	addr = 0;
+	offset = 0;
+	size = 0;
+	s = elfsectbyname(fd, ep, es, ".data");
+	if(s) {
+		addr = s->addr;
+		size = s->size;
+		offset = s->offset;
+	}
+
+	s = elfsectbyname(fd, ep, es, ".rodata");
+	if(s) {
+		if(addr){
+			if(addr+size != s->addr)
+				goto bad;
+		} else {
+			addr = s->addr;
+			offset = s->offset;
+		}
+		size += s->size;
+	}
+
+	s = elfsectbyname(fd, ep, es, ".got");
+	if(s) {
+		if(addr){
+			if(addr+size != s->addr)
+				goto bad;
+		} else {
+			addr = s->addr;
+			offset = s->offset;
+		}
+		size += s->size;
+	}
+
+	bsize = 0;
+	s = elfsectbyname(fd, ep, es, ".bss");
+	if(s) {
+		if(addr){
+			if(addr+size != s->addr)
+				goto bad;
+		} else {
+			addr = s->addr;
+			offset = s->offset;
+		}
+		bsize = s->size;
+	}
+
+	if(addr == 0)
+		goto bad;
+
+	setdata(fp, addr, size, offset, bsize);
+	fp->name = "IRIX Elf a.out executable";
+	free(es);
+	return 1;
+bad:
+	free(es);
+	werrstr("ELF sections scrambled");
+	return 0;
+}
+
+/*
+ * (Free|Net)BSD ARM header.
+ */
+static int
+armdotout(int fd, Fhdr *fp, ExecHdr *hp)
+{
+	long kbase;
+
+	USED(fd);
+	settext(fp, hp->e.exec.entry, sizeof(Exec), hp->e.exec.text, sizeof(Exec));
+	setdata(fp, fp->txtsz, hp->e.exec.data, fp->txtsz, hp->e.exec.bss);
+	setsym(fp, hp->e.exec.syms, hp->e.exec.spsz, hp->e.exec.pcsz, fp->datoff+fp->datsz);
+
+	kbase = 0xF0000000;
+	if ((fp->entry & kbase) == kbase) {		/* Boot image */
+		fp->txtaddr = kbase+sizeof(Exec);
+		fp->name = "ARM *BSD boot image";
+		fp->hdrsz = 0;		/* header stripped */
+		fp->dataddr = kbase+fp->txtsz;
+	}
+	return 1;
+}
+
+static void
+settext(Fhdr *fp, long e, long a, long s, long off)
+{
+	fp->txtaddr = a;
+	fp->entry = e;
+	fp->txtsz = s;
+	fp->txtoff = off;
+}
+static void
+setdata(Fhdr *fp, long a, long s, long off, long bss)
+{
+	fp->dataddr = a;
+	fp->datsz = s;
+	fp->datoff = off;
+	fp->bsssz = bss;
+}
+static void
+setsym(Fhdr *fp, long sy, long sppc, long lnpc, long symoff)
+{
+	fp->symsz = sy;
+	fp->symoff = symoff;
+	fp->sppcsz = sppc;
+	fp->sppcoff = fp->symoff+fp->symsz;
+	fp->lnpcsz = lnpc;
+	fp->lnpcoff = fp->sppcoff+fp->sppcsz;
+}
+
+
+static long
+_round(long a, long b)
+{
+	long w;
+
+	w = (a/b)*b;
+	if (a!=w)
+		w += b;
+	return(w);
+}
diff --git a/utils/libmach/k.c b/utils/libmach/k.c
new file mode 100644
index 00000000..30ae15a0
--- /dev/null
+++ b/utils/libmach/k.c
@@ -0,0 +1,117 @@
+/*
+ * sparc definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "uregk.h"
+#include "mach.h"
+
+#define	REGOFF(x)	(ulong)(&((struct Ureg *) 0)->x)
+
+#define R1		REGOFF(u0.r1)
+#define R7		REGOFF(r7)
+#define PC		REGOFF(pc)
+#define	R15		REGOFF(r15)
+
+#define	REGSIZE		sizeof(struct Ureg)
+#define	FP_REG(x)	(REGSIZE+4*(x))
+#define	FPREGSIZE	(33*4)
+
+Reglist sparcreglist[] = {
+	{"Y",		REGOFF(y),	RINT|RRDONLY, 'X'},
+	{"TBR",		REGOFF(tbr),	RINT|RRDONLY, 'X'},
+	{"PSR",		REGOFF(psr),	RINT|RRDONLY, 'X'},
+	{"PC",		REGOFF(pc),	RINT, 'X'},
+	{"R1",		REGOFF(u0.r1),	RINT, 'X'},
+	{"R2",		REGOFF(r2),	RINT, 'X'},
+	{"R3",		REGOFF(r3),	RINT, 'X'},
+	{"R4",		REGOFF(r4),	RINT, 'X'},
+	{"R5",		REGOFF(r5),	RINT, 'X'},
+	{"R6",		REGOFF(r6),	RINT, 'X'},
+	{"R7",		REGOFF(r7),	RINT, 'X'},
+	{"R8",		REGOFF(r8),	RINT, 'X'},
+	{"R9",		REGOFF(r9),	RINT, 'X'},
+	{"R10",		REGOFF(r10),	RINT, 'X'},
+	{"R11",		REGOFF(r11),	RINT, 'X'},
+	{"R12",		REGOFF(r12),	RINT, 'X'},
+	{"R13",		REGOFF(r13),	RINT, 'X'},
+	{"R14",		REGOFF(r14),	RINT, 'X'},
+	{"R15",		REGOFF(r15),	RINT, 'X'},
+	{"R16",		REGOFF(r16),	RINT, 'X'},
+	{"R17",		REGOFF(r17),	RINT, 'X'},
+	{"R18",		REGOFF(r18),	RINT, 'X'},
+	{"R19",		REGOFF(r19),	RINT, 'X'},
+	{"R20",		REGOFF(r20),	RINT, 'X'},
+	{"R21",		REGOFF(r21),	RINT, 'X'},
+	{"R22",		REGOFF(r22),	RINT, 'X'},
+	{"R23",		REGOFF(r23),	RINT, 'X'},
+	{"R24",		REGOFF(r24),	RINT, 'X'},
+	{"R25",		REGOFF(r25),	RINT, 'X'},
+	{"R26",		REGOFF(r26),	RINT, 'X'},
+	{"R27",		REGOFF(r27),	RINT, 'X'},
+	{"R28",		REGOFF(r28),	RINT, 'X'},
+	{"R29",		REGOFF(r29),	RINT, 'X'},
+	{"R30",		REGOFF(r30),	RINT, 'X'},
+	{"R31",		REGOFF(r31),	RINT, 'X'},
+	{"NPC",		REGOFF(npc),	RINT, 'X'},
+
+	{"FSR",		FP_REG(0),	RINT, 'X'},
+	{"F0",		FP_REG(1),	RFLT, 'F'},
+	{"F1",		FP_REG(2),	RFLT, 'f'},
+	{"F2",		FP_REG(3),	RFLT, 'F'},
+	{"F3",		FP_REG(4),	RFLT, 'f'},
+	{"F4",		FP_REG(5),	RFLT, 'F'},
+	{"F5",		FP_REG(6),	RFLT, 'f'},
+	{"F6",		FP_REG(7),	RFLT, 'F'},
+	{"F7",		FP_REG(8),	RFLT, 'f'},
+	{"F8",		FP_REG(9),	RFLT, 'F'},
+	{"F9",		FP_REG(10),	RFLT, 'f'},
+	{"F10",		FP_REG(11),	RFLT, 'F'},
+	{"F11",		FP_REG(12),	RFLT, 'f'},
+	{"F12",		FP_REG(13),	RFLT, 'F'},
+	{"F13",		FP_REG(14),	RFLT, 'f'},
+	{"F14",		FP_REG(15),	RFLT, 'F'},
+	{"F15",		FP_REG(16),	RFLT, 'f'},
+	{"F16",		FP_REG(17),	RFLT, 'F'},
+	{"F17",		FP_REG(18),	RFLT, 'f'},
+	{"F18",		FP_REG(19),	RFLT, 'F'},
+	{"F19",		FP_REG(20),	RFLT, 'f'},
+	{"F20",		FP_REG(21),	RFLT, 'F'},
+	{"F21",		FP_REG(22),	RFLT, 'f'},
+	{"F22",		FP_REG(23),	RFLT, 'F'},
+	{"F23",		FP_REG(24),	RFLT, 'f'},
+	{"F24",		FP_REG(25),	RFLT, 'F'},
+	{"F25",		FP_REG(26),	RFLT, 'f'},
+	{"F26",		FP_REG(27),	RFLT, 'F'},
+	{"F27",		FP_REG(28),	RFLT, 'f'},
+	{"F28",		FP_REG(29),	RFLT, 'F'},
+	{"F29",		FP_REG(30),	RFLT, 'f'},
+	{"F30",		FP_REG(31),	RFLT, 'F'},
+	{"F31",		FP_REG(32),	RFLT, 'f'},
+	{  0 }
+};
+
+/*
+ * sparc has same stack format as mips
+ */
+Mach msparc =
+{
+	"sparc",
+	MSPARC,		/* machine type */
+	sparcreglist,	/* register list */
+	REGSIZE,	/* register set size in bytes */
+	FPREGSIZE,	/* floating point register size in bytes */
+	"PC",		/* name of PC */
+	"R1",		/* name of SP */
+	"R15",		/* name of link register */
+	"setSB",	/* static base register name */
+	0,		/* value */
+	0x1000,		/* page size */
+	0xE0000000,	/* kernel base */
+	0,		/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/kdb.c b/utils/libmach/kdb.c
new file mode 100644
index 00000000..bffd5e77
--- /dev/null
+++ b/utils/libmach/kdb.c
@@ -0,0 +1,1055 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+/*
+ * Sparc-specific debugger interface
+ */
+
+static	char	*sparcexcep(Map*, Rgetter);
+static	int	sparcfoll(Map*, ulong, Rgetter, ulong*);
+static	int	sparcinst(Map*, ulong, char, char*, int);
+static	int	sparcdas(Map*, ulong, char*, int);
+static	int	sparcinstlen(Map*, ulong);
+
+Machdata sparcmach =
+{
+	{0x91, 0xd0, 0x20, 0x01},	/* breakpoint: TA $1 */
+	4,			/* break point size */
+
+	beswab,			/* convert short to local byte order */
+	beswal,			/* convert long to local byte order */
+	beswav,			/* convert vlong to local byte order */
+	risctrace,		/* C traceback */
+	riscframe,		/* frame finder */
+	sparcexcep,		/* print exception */
+	0,			/* breakpoint fixup */
+	beieeesftos,		/* single precision float printer */
+	beieeedftos,		/* double precision float printer */
+	sparcfoll,		/* following addresses */
+	sparcinst,		/* print instruction */
+	sparcdas,		/* dissembler */
+	sparcinstlen,		/* instruction size */
+};
+
+static char *trapname[] =
+{
+	"reset",
+	"instruction access exception",
+	"illegal instruction",
+	"privileged instruction",
+	"fp disabled",
+	"window overflow",
+	"window underflow",
+	"unaligned address",
+	"fp exception",
+	"data access exception",
+	"tag overflow",
+};
+
+static char*
+excname(ulong tbr)
+{
+	static char buf[32];
+
+	if(tbr < sizeof trapname/sizeof(char*))
+		return trapname[tbr];
+	if(tbr >= 130)
+		sprint(buf, "trap instruction %ld", tbr-128);
+	else if(17<=tbr && tbr<=31)
+		sprint(buf, "interrupt level %ld", tbr-16);
+	else switch(tbr){
+	case 36:
+		return "cp disabled";
+	case 40:
+		return "cp exception";
+	case 128:
+		return "syscall";
+	case 129:
+		return "breakpoint";
+	default:
+		sprint(buf, "unknown trap %ld", tbr);
+	}
+	return buf;
+}
+
+static char*
+sparcexcep(Map *map, Rgetter rget)
+{
+	long tbr;
+
+	tbr = (*rget)(map, "TBR");
+	tbr = (tbr&0xFFF)>>4;
+	return excname(tbr);
+}
+
+	/* Sparc disassembler and related functions */
+
+typedef struct instr Instr;
+
+struct opcode {
+	char	*mnemonic;
+	void	(*f)(Instr*, char*);
+	int	flag;
+};
+
+static	char FRAMENAME[] = ".frame";
+
+struct instr {
+	uchar	op;		/* bits 31-30 */
+	uchar	rd;		/* bits 29-25 */
+	uchar	op2;		/* bits 24-22 */
+	uchar	a;		/* bit  29    */
+	uchar	cond;		/* bits 28-25 */
+	uchar	op3;		/* bits 24-19 */
+	uchar	rs1;		/* bits 18-14 */
+	uchar	i;		/* bit  13    */
+	uchar	asi;		/* bits 12-05 */
+	uchar	rs2;		/* bits 04-00 */
+	short	simm13;		/* bits 12-00, signed */
+	ushort	opf;		/* bits 13-05 */
+	ulong	immdisp22;	/* bits 21-00 */
+	ulong	simmdisp22;	/* bits 21-00, signed */
+	ulong	disp30;		/* bits 30-00 */
+	ulong	imm32;		/* SETHI+ADD constant */
+	int	target;		/* SETHI+ADD dest reg */
+	long	w0;
+	long	w1;
+	ulong	addr;		/* pc of instruction */
+	char	*curr;		/* current fill level in output buffer */
+	char	*end;		/* end of buffer */
+	int 	size;		/* number of longs in instr */
+	char	*err;		/* errmsg */
+};
+
+static	Map	*mymap;		/* disassembler context */
+static	int	dascase;
+
+static int	mkinstr(ulong, Instr*);
+static void	bra1(Instr*, char*, char*[]);
+static void	bra(Instr*, char*);
+static void	fbra(Instr*, char*);
+static void	cbra(Instr*, char*);
+static void	unimp(Instr*, char*);
+static void	fpop(Instr*, char*);
+static void	shift(Instr*, char*);
+static void	sethi(Instr*, char*);
+static void	load(Instr*, char*);
+static void	loada(Instr*, char*);
+static void	store(Instr*, char*);
+static void	storea(Instr*, char*);
+static void	add(Instr*, char*);
+static void	cmp(Instr*, char*);
+static void	wr(Instr*, char*);
+static void	jmpl(Instr*, char*);
+static void	rd(Instr*, char*);
+static void	loadf(Instr*, char*);
+static void	storef(Instr*, char*);
+static void	loadc(Instr*, char*);
+static void	loadcsr(Instr*, char*);
+static void	trap(Instr*, char*);
+
+static struct opcode sparcop0[8] = {
+	"UNIMP",	unimp,	0,	/* page 137 */	/* 0 */
+		"",		0,	0,		/* 1 */
+	"B",		bra,	0,	/* page 119 */	/* 2 */
+		"",		0,	0,		/* 3 */
+	"SETHI",	sethi,	0,	/* page 104 */	/* 4 */
+		"",		0,	0,		/* 5 */
+	"FB",		fbra,	0,	/* page 121 */	/* 6 */
+	"CB",		cbra,	0,	/* page 123 */	/* 7 */
+};
+
+static struct opcode sparcop2[64] = {
+		"ADD",		add,	0,	/* page 108 */	/* 0x00 */
+		"AND",		add,	0,	/* page 106 */	/* 0x01 */
+		"OR",		add,	0,			/* 0x02 */
+		"XOR",		add,	0,			/* 0x03 */
+		"SUB",		add,	0,	/* page 110 */	/* 0x04 */
+		"ANDN",		add,	0,			/* 0x05 */
+		"ORN",		add,	0,			/* 0x06 */
+		"XORN",		add,	0,			/* 0x07 */
+		"ADDX",		add,	0,			/* 0x08 */
+		"",		0,	0,			/* 0x09 */
+		"UMUL",		add,	0,	/* page 113 */	/* 0x0a */
+		"SMUL",		add,	0,			/* 0x0b */
+		"SUBX",		add,	0,			/* 0x0c */
+		"",		0,	0,			/* 0x0d */
+		"UDIV",		add,	0,	/* page 115 */	/* 0x0e */
+		"SDIV",		add,	0,			/* 0x0f */
+		"ADDCC",	add,	0,			/* 0x10 */
+		"ANDCC",	add,	0,			/* 0x11 */
+		"ORCC",		add,	0,			/* 0x12 */
+		"XORCC",	add,	0,			/* 0x13 */
+		"SUBCC",	cmp,	0,			/* 0x14 */
+		"ANDNCC",	add,	0,			/* 0x15 */
+		"ORNCC",	add,	0,			/* 0x16 */
+		"XORNCC",	add,	0,			/* 0x17 */
+		"ADDXCC",	add,	0,			/* 0x18 */
+		"",		0,	0,			/* 0x19 */
+		"UMULCC",	add,	0,			/* 0x1a */
+		"SMULCC",	add,	0,			/* 0x1b */
+		"SUBXCC",	add,	0,			/* 0x1c */
+		"",		0,	0,			/* 0x1d */
+		"UDIVCC",	add,	0,			/* 0x1e */
+		"SDIVCC",	add,	0,			/* 0x1f */
+		"TADD",		add,	0,	/* page 109 */	/* 0x20 */
+		"TSUB",		add,	0,	/* page 111 */	/* 0x21 */
+		"TADDCCTV",	add,	0,			/* 0x22 */
+		"TSUBCCTV",	add,	0,			/* 0x23 */
+		"MULSCC",	add,	0,	/* page 112 */	/* 0x24 */
+		"SLL",		shift,	0,	/* page 107 */	/* 0x25 */
+		"SRL",		shift,	0,			/* 0x26 */
+		"SRA",		shift,	0,			/* 0x27 */
+		"rdy",		rd,	0,	/* page 131 */	/* 0x28 */
+		"rdpsr",	rd,	0,			/* 0x29 */
+		"rdwim",	rd,	0,			/* 0x2a */
+		"rdtbr",	rd,	0,			/* 0x2b */
+		"",		0,	0,			/* 0x2c */
+		"",		0,	0,			/* 0x2d */
+		"",		0,	0,			/* 0x2e */
+		"",		0,	0,			/* 0x2f */
+		"wry",		wr,	0,	/* page 133 */	/* 0x30 */
+		"wrpsr",	wr,	0,			/* 0x31 */
+		"wrwim",	wr,	0,			/* 0x32 */
+		"wrtbr",	wr,	0,			/* 0x33 */
+		"FPOP",		fpop,	0,	/* page 140 */	/* 0x34 */
+		"FPOP",		fpop,	0,			/* 0x35 */
+		"",		0,	0,			/* 0x36 */
+		"",		0,	0,			/* 0x37 */
+		"JMPL",		jmpl,	0,	/* page 126 */	/* 0x38 */
+		"RETT",		add,	0,	/* page 127 */	/* 0x39 */
+		"T",		trap,	0,	/* page 129 */	/* 0x3a */
+		"flush",	add,	0,	/* page 138 */	/* 0x3b */
+		"SAVE",		add,	0,	/* page 117 */	/* 0x3c */
+		"RESTORE",	add,	0,			/* 0x3d */
+};
+
+static struct opcode sparcop3[64]={
+		"ld",		load,	0,			/* 0x00 */
+		"ldub",		load,	0,			/* 0x01 */
+		"lduh",		load,	0,			/* 0x02 */
+		"ldd",		load,	0,			/* 0x03 */
+		"st",		store,	0,			/* 0x04 */
+		"stb",		store,	0,	/* page 95 */	/* 0x05 */
+		"sth",		store,	0,			/* 0x06 */
+		"std",		store,	0,			/* 0x07 */
+		"",		0,	0,			/* 0x08 */
+		"ldsb",		load,	0,	/* page 90 */	/* 0x09 */
+		"ldsh",		load,	0,			/* 0x0a */
+		"",		0,	0,			/* 0x0b */
+		"",		0,	0,			/* 0x0c */
+		"ldstub",	store,	0,	/* page 101 */	/* 0x0d */
+		"",		0,	0,			/* 0x0e */
+		"swap",		load,	0,	/* page 102 */	/* 0x0f */
+		"lda",		loada,	0,			/* 0x10 */
+		"lduba",	loada,	0,			/* 0x11 */
+		"lduha",	loada,	0,			/* 0x12 */
+		"ldda",		loada,	0,			/* 0x13 */
+		"sta",		storea,	0,			/* 0x14 */
+		"stba",		storea,	0,			/* 0x15 */
+		"stha",		storea,	0,			/* 0x16 */
+		"stda",		storea,	0,			/* 0x17 */
+		"",		0,	0,			/* 0x18 */
+		"ldsba",	loada,	0,			/* 0x19 */
+		"ldsha",	loada,	0,			/* 0x1a */
+		"",		0,	0,			/* 0x1b */
+		"",		0,	0,			/* 0x1c */
+		"ldstuba",	storea,	0,			/* 0x1d */
+		"",		0,	0,			/* 0x1e */
+		"swapa",	loada,	0,			/* 0x1f */
+		"ldf",		loadf,	0,	/* page 92 */	/* 0x20 */
+		"ldfsr",	loadf,0,			/* 0x21 */
+		"",		0,	0,			/* 0x22 */
+		"lddf",		loadf,	0,			/* 0x23 */
+		"stf",		storef,	0,	/* page 97 */	/* 0x24 */
+		"stfsr",	storef,0,			/* 0x25 */
+		"stdfq",	storef,0,			/* 0x26 */
+		"stdf",		storef,	0,			/* 0x27 */
+		"",		0,	0,			/* 0x28 */
+		"",		0,	0,			/* 0x29 */
+		"",		0,	0,			/* 0x2a */
+		"",		0,	0,			/* 0x2b */
+		"",		0,	0,			/* 0x2c */
+		"",		0,	0,			/* 0x2d */
+		"",		0,	0,			/* 0x2e */
+		"",		0,	0,			/* 0x2f */
+		"ldc",		loadc,	0,	/* page 94 */	/* 0x30 */
+		"ldcsr",	loadcsr,0,			/* 0x31 */
+		"",		0,	0,			/* 0x32 */
+		"lddc",		loadc,	0,			/* 0x33 */
+		"stc",		loadc,	0,	/* page 99 */	/* 0x34 */
+		"stcsr",	loadcsr,0,			/* 0x35 */
+		"stdcq",	loadcsr,0,			/* 0x36 */
+		"stdc",		loadc,	0,			/* 0x37 */
+};
+
+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);
+}
+
+static int
+decode(ulong pc, Instr *i)
+{
+	long w;
+
+	if (get4(mymap, pc, &w) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	i->op = (w >> 30) & 0x03;
+	i->rd = (w >> 25) & 0x1F;
+	i->op2 = (w >> 22) & 0x07;
+	i->a = (w >> 29) & 0x01;
+	i->cond = (w >> 25) & 0x0F;
+	i->op3 = (w >> 19) & 0x3F;
+	i->rs1 = (w >> 14) & 0x1F;
+	i->i = (w >> 13) & 0x01;
+	i->asi = (w >> 5) & 0xFF;
+	i->rs2 = (w >> 0) & 0x1F;
+	i->simm13 = (w >> 0) & 0x1FFF;
+	if(i->simm13 & (1<<12))
+		i->simm13 |= ~((1<<13)-1);
+	i->opf = (w >> 5) & 0x1FF;
+	i->immdisp22 = (w >> 0) & 0x3FFFFF;
+	i->simmdisp22 = i->immdisp22;
+	if(i->simmdisp22 & (1<<21))
+		i->simmdisp22 |= ~((1<<22)-1);
+	i->disp30 = (w >> 0) & 0x3FFFFFFF;
+	i->w0 = w;
+	i->target = -1;
+	i->addr = pc;
+	i->size = 1;
+	return 1;
+}
+
+static int
+mkinstr(ulong pc, Instr *i)
+{
+	Instr xi;
+
+	if (decode(pc, i) < 0)
+		return -1;
+	if(i->op==0 && i->op2==4 && !dascase){	/* SETHI */
+		if (decode(pc+4, &xi) < 0)
+			return -1;
+		if(xi.op==2 && xi.op3==0)		/* ADD */
+		if(xi.i == 1 && xi.rs1 == i->rd){	/* immediate to same reg */
+			i->imm32 = xi.simm13 + (i->immdisp22<<10);
+			i->target = xi.rd;
+			i->w1 = xi.w0;
+			i->size++;
+			return 1;
+		}
+	}
+	if(i->op==2 && i->opf==1 && !dascase){	/* FMOVS */
+		if (decode(pc+4, &xi) < 0)
+			return -1;
+		if(i->op==2 && i->opf==1)		/* FMOVS */
+		if(xi.rd==i->rd+1 && xi.rs2==i->rs2+1){	/* next pair */
+			i->w1 = xi.w0;
+			i->size++;
+		}
+	}
+	return 1;
+}
+
+static int
+printins(Map *map, ulong pc, char *buf, int n)
+{
+	Instr instr;
+	void (*f)(Instr*, char*);
+
+	mymap = map;
+	memset(&instr, 0, sizeof(instr));
+	instr.curr = buf;
+	instr.end = buf+n-1;
+	if (mkinstr(pc, &instr) < 0)
+		return -1;
+	switch(instr.op){
+	case 0:
+		f = sparcop0[instr.op2].f;
+		if(f)
+			(*f)(&instr, sparcop0[instr.op2].mnemonic);
+		else
+			bprint(&instr, "unknown %lux", instr.w0);
+		break;
+
+	case 1:
+		bprint(&instr, "%X", "CALL\t");
+		instr.curr += symoff(instr.curr, instr.end-instr.curr,
+					pc+instr.disp30*4, CTEXT);
+		if (!dascase)
+			bprint(&instr, "(SB)");
+		break;
+
+	case 2:
+		f = sparcop2[instr.op3].f;
+		if(f)
+			(*f)(&instr, sparcop2[instr.op3].mnemonic);
+		else
+			bprint(&instr, "unknown %lux", instr.w0);
+		break;
+
+	case 3:
+		f = sparcop3[instr.op3].f;
+		if(f)
+			(*f)(&instr, sparcop3[instr.op3].mnemonic);
+		else
+			bprint(&instr, "unknown %lux", instr.w0);
+		break;
+	}
+	if (instr.err) {
+		if (instr.curr != buf)
+			bprint(&instr, "\t\t;");
+		bprint(&instr, instr.err);
+	}
+	return instr.size*4;
+}
+
+/* convert to lower case from upper, according to dascase */
+static int
+Xconv(Fmt *f)
+{
+	char buf[128];
+	char *s, *t, *oa;
+
+	oa = va_arg(f->args, char*);
+	if(dascase){
+		for(s=oa,t=buf; *t = *s; s++,t++)
+			if('A'<=*t && *t<='Z')
+				*t += 'a'-'A';
+		return fmtstrcpy(f, buf);
+	}
+	return fmtstrcpy(f, oa);
+}
+
+static int
+sparcinst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	static int fmtinstalled = 0;
+
+		/* a modifier of 'I' toggles the dissassembler type */
+	if (!fmtinstalled) {
+		fmtinstalled = 1;
+		fmtinstall('X', Xconv);
+	}
+	if ((asstype == ASUNSPARC && modifier == 'i')
+		|| (asstype == ASPARC && modifier == 'I'))
+		dascase = 'a'-'A';
+	else
+		dascase = 0;
+	return printins(map, pc, buf, n);
+}
+
+static int
+sparcdas(Map *map, ulong pc, char *buf, int n)
+{
+	Instr instr;
+
+	mymap = map;
+	memset(&instr, 0, sizeof(instr));
+	instr.curr = buf;
+	instr.end = buf+n-1;
+	if (mkinstr(pc, &instr) < 0)
+		return -1;
+	if (instr.end-instr.curr > 8)
+		instr.curr = _hexify(instr.curr, instr.w0, 7);
+	if (instr.end-instr.curr > 9 && instr.size == 2) {
+		*instr.curr++ = ' ';
+		instr.curr = _hexify(instr.curr, instr.w1, 7);
+	}
+	*instr.curr = 0;
+	return instr.size*4;
+}
+
+static int
+sparcinstlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	return i.size*4;
+}
+
+static int
+plocal(Instr *i)
+{
+	int offset;
+	Symbol s;
+
+	if (!findsym(i->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s))
+		return -1;
+	if (s.value > i->simm13) {
+		if(getauto(&s, s.value-i->simm13, CAUTO, &s)) {
+			bprint(i, "%s+%d(SP)", s.name, s.value);
+			return 1;
+		}
+	} else {
+		offset = i->simm13-s.value;
+		if (getauto(&s, offset-4, CPARAM, &s)) {
+			bprint(i, "%s+%d(FP)", s.name, offset);
+			return 1;
+		}
+	}
+	return -1;
+}
+
+static void
+address(Instr *i)
+{
+	Symbol s, s2;
+	long off, off1;
+
+	if (i->rs1 == 1 && plocal(i) >= 0)
+		return;
+	off = mach->sb+i->simm13;
+	if(i->rs1 == 2	&& findsym(off, CANY, &s)
+			&& s.value-off < 4096
+			&& (s.class == CDATA || s.class == CTEXT)) {
+		if(off==s.value && s.name[0]=='$'){
+			off1 = 0;
+			get4(mymap, s.value, &off1);
+			if(off1 && findsym(off1, CANY, &s2) && s2.value == off1){
+				bprint(i, "$%s(SB)", s2.name);
+				return;
+			}
+		}
+		bprint(i, "%s", s.name);
+		if (s.value != off)
+			bprint(i, "+%lux", s.value-off);
+		bprint(i, "(SB)");
+		return;
+	}
+	bprint(i, "%lux(R%d)", i->simm13, i->rs1);
+}
+
+static void
+unimp(Instr *i, char *m)
+{
+	bprint(i, "%X", m);
+}
+
+static char	*bratab[16] = {	/* page 91 */
+		"N",		/* 0x0 */
+		"E",		/* 0x1 */
+		"LE",		/* 0x2 */
+		"L",		/* 0x3 */
+		"LEU",		/* 0x4 */
+		"CS",		/* 0x5 */
+		"NEG",		/* 0x6 */
+		"VS",		/* 0x7 */
+		"A",		/* 0x8 */
+		"NE",		/* 0x9 */
+		"G",		/* 0xa */
+		"GE",		/* 0xb */
+		"GU",		/* 0xc */
+		"CC",		/* 0xd */
+		"POS",		/* 0xe */
+		"VC",		/* 0xf */
+};
+
+static char	*fbratab[16] = {	/* page 91 */
+		"N",		/* 0x0 */
+		"NE",		/* 0x1 */
+		"LG",		/* 0x2 */
+		"UL",		/* 0x3 */
+		"L",		/* 0x4 */
+		"UG",		/* 0x5 */
+		"G",		/* 0x6 */
+		"U",		/* 0x7 */
+		"A",		/* 0x8 */
+		"E",		/* 0x9 */
+		"UE",		/* 0xa */
+		"GE",		/* 0xb */
+		"UGE",		/* 0xc */
+		"LE",		/* 0xd */
+		"ULE",		/* 0xe */
+		"O",		/* 0xf */
+};
+
+static char	*cbratab[16] = {	/* page 91 */
+		"N",		/* 0x0 */
+		"123",		/* 0x1 */
+		"12",		/* 0x2 */
+		"13",		/* 0x3 */
+		"1",		/* 0x4 */
+		"23",		/* 0x5 */
+		"2",		/* 0x6 */
+		"3",		/* 0x7 */
+		"A",		/* 0x8 */
+		"0",		/* 0x9 */
+		"03",		/* 0xa */
+		"02",		/* 0xb */
+		"023",		/* 0xc */
+		"01",		/* 0xd */
+		"013",		/* 0xe */
+		"012",		/* 0xf */
+};
+
+static void
+bra1(Instr *i, char *m, char *tab[])
+{
+	long imm;
+
+	imm = i->simmdisp22;
+	if(i->a)
+		bprint(i, "%X%X.%c\t", m, tab[i->cond], 'A'+dascase);
+	else
+		bprint(i, "%X%X\t", m, tab[i->cond]);
+	i->curr += symoff(i->curr, i->end-i->curr, i->addr+4*imm, CTEXT);
+	if (!dascase)
+		bprint(i, "(SB)");
+}
+
+static void
+bra(Instr *i, char *m)			/* page 91 */
+{
+	bra1(i, m, bratab);
+}
+
+static void
+fbra(Instr *i, char *m)			/* page 93 */
+{
+	bra1(i, m, fbratab);
+}
+
+static void
+cbra(Instr *i, char *m)			/* page 95 */
+{
+	bra1(i, m, cbratab);
+}
+
+static void
+trap(Instr *i, char *m)			/* page 101 */
+{
+	if(i->i == 0)
+		bprint(i, "%X%X\tR%d+R%d", m, bratab[i->cond], i->rs2, i->rs1);
+	else
+		bprint(i, "%X%X\t$%lux+R%d", m, bratab[i->cond], i->simm13, i->rs1);
+}
+
+static void
+sethi(Instr *i, char *m)		/* page 89 */
+{
+	ulong imm;
+
+	imm = i->immdisp22<<10;
+	if(dascase){
+		bprint(i, "%X\t%lux, R%d", m, imm, i->rd);
+		return;
+	}
+	if(imm==0 && i->rd==0){
+		bprint(i, "NOP");
+		return;
+	}
+	if(i->target < 0){
+		bprint(i, "MOVW\t$%lux, R%d", imm, i->rd);
+		return;
+	}
+	bprint(i, "MOVW\t$%lux, R%d", i->imm32, i->target);
+}
+
+static char ldtab[] = {
+	'W',
+	'B',
+	'H',
+	'D',
+};
+
+static char*
+moveinstr(int op3, char *m)
+{
+	char *s;
+	int c;
+	static char buf[8];
+
+	if(!dascase){
+		/* batshit cases */
+		if(op3 == 0xF || op3 == 0x1F)
+			return "SWAP";
+		if(op3 == 0xD || op3 == 0x1D)
+			return "TAS";	/* really LDSTUB */
+		c = ldtab[op3&3];
+		s = "";
+		if((op3&11)==1 || (op3&11)==2)
+			s="U";
+		sprint(buf, "MOV%c%s", c, s);
+		return buf;
+	}
+	return m;
+}
+
+static void
+load(Instr *i, char *m)			/* page 68 */
+{
+	m = moveinstr(i->op3, m);
+	if(i->i == 0)
+		bprint(i, "%s\t(R%d+R%d), R%d", m, i->rs1, i->rs2, i->rd);
+	else{
+		bprint(i, "%s\t", m);
+		address(i);
+		bprint(i, ", R%d", i->rd);
+	}
+}
+
+static void
+loada(Instr *i, char *m)		/* page 68 */
+{
+	m = moveinstr(i->op3, m);
+	if(i->i == 0)
+		bprint(i, "%s\t(R%d+R%d, %d), R%d", m, i->rs1, i->rs2, i->asi, i->rd);
+	else
+		bprint(i, "unknown ld asi %lux", i->w0);
+}
+
+static void
+store(Instr *i, char *m)		/* page 74 */
+{
+	m = moveinstr(i->op3, m);
+	if(i->i == 0)
+		bprint(i, "%s\tR%d, (R%d+R%d)",
+				m, i->rd, i->rs1, i->rs2);
+	else{
+		bprint(i, "%s\tR%d, ", m, i->rd);
+		address(i);
+	}
+}
+
+static void
+storea(Instr *i, char *m)		/* page 74 */
+{
+	m = moveinstr(i->op3, m);
+	if(i->i == 0)
+		bprint(i, "%s\tR%d, (R%d+R%d, %d)", m, i->rd, i->rs1, i->rs2, i->asi);
+	else
+		bprint(i, "%s\tR%d, %d(R%d, %d), ???", m, i->rd, i->simm13, i->rs1, i->asi);
+}
+
+static void
+shift(Instr *i, char *m)	/* page 88 */
+{
+	if(i->i == 0){
+		if(i->rs1 == i->rd)
+			if(dascase)
+				bprint(i, "%X\tR%d, R%d", m, i->rs1, i->rs2);
+			else
+				bprint(i, "%X\tR%d, R%d", m, i->rs2, i->rs1);
+		else
+			if(dascase)
+				bprint(i, "%X\tR%d, R%d, R%d", m, i->rs1, i->rs2, i->rd);
+			else
+				bprint(i, "%X\tR%d, R%d, R%d", m, i->rs2, i->rs1, i->rd);
+	}else{
+		if(i->rs1 == i->rd)
+			if(dascase)
+				bprint(i, "%X\t$%d,R%d", m, i->simm13&0x1F, i->rs1);
+			else
+				bprint(i, "%X\tR%d, $%d", m,  i->rs1, i->simm13&0x1F);
+		else
+			if(dascase)
+				bprint(i, "%X\tR%d, $%d, R%d",m,i->rs1,i->simm13&0x1F,i->rd);
+			else
+				bprint(i, "%X\t$%d, R%d, R%d",m,i->simm13&0x1F,i->rs1,i->rd);
+	}
+}
+
+static void
+add(Instr *i, char *m)	/* page 82 */
+{
+	if(i->i == 0){
+		if(dascase)
+			bprint(i, "%X\tR%d, R%d", m, i->rs1, i->rs2);
+		else
+			if(i->op3==2 && i->rs1==0 && i->rd)  /* OR R2, R0, R1 */
+				bprint(i, "MOVW\tR%d", i->rs2);
+			else
+				bprint(i, "%X\tR%d, R%d", m, i->rs2, i->rs1);
+	}else{
+		if(dascase)
+			bprint(i, "%X\tR%d, $%lux", m, i->rs1, i->simm13);
+		else
+			if(i->op3==0 && i->rd && i->rs1==0)	/* ADD $x, R0, R1 */
+				bprint(i, "MOVW\t$%lux", i->simm13);
+			else if(i->op3==0 && i->rd && i->rs1==2){
+				/* ADD $x, R2, R1 -> MOVW $x(SB), R1 */
+				bprint(i, "MOVW\t$");
+				address(i);
+			} else
+				bprint(i, "%X\t$%lux, R%d", m, i->simm13, i->rs1);
+	}
+	if(i->rs1 != i->rd)
+		bprint(i, ", R%d", i->rd);
+}
+
+static void
+cmp(Instr *i, char *m)
+{
+	if(dascase || i->rd){
+		add(i, m);
+		return;
+	}
+	if(i->i == 0)
+		bprint(i, "CMP\tR%d, R%d", i->rs1, i->rs2);
+	else
+		bprint(i, "CMP\tR%d, $%lux", i->rs1, i->simm13);
+}
+
+static char *regtab[4] = {
+	"Y",
+	"PSR",
+	"WIM",
+	"TBR",
+};
+
+static void
+wr(Instr *i, char *m)		/* page 82 */
+{
+	if(dascase){
+		if(i->i == 0)
+			bprint(i, "%s\tR%d, R%d", m, i->rs1, i->rs2);
+		else
+			bprint(i, "%s\tR%d, $%lux", m, i->rs1, i->simm13);
+	}else{
+		if(i->i && i->simm13==0)
+			bprint(i, "MOVW\tR%d", i->rs1);
+		else if(i->i == 0)
+			bprint(i, "wr\tR%d, R%d", i->rs2, i->rs1);
+		else
+			bprint(i, "wr\t$%lux, R%d", i->simm13, i->rs1);
+	}
+	bprint(i, ", %s", regtab[i->op3&3]);
+}
+
+static void
+rd(Instr *i, char *m)		/* page 103 */
+{
+	if(i->rs1==15 && i->rd==0){
+		m = "stbar";
+		if(!dascase)
+			m = "STBAR";
+		bprint(i, "%s", m);
+	}else{
+		if(!dascase)
+			m = "MOVW";
+		bprint(i, "%s\t%s, R%d", m, regtab[i->op3&3], i->rd);
+	}
+}
+
+static void
+jmpl(Instr *i, char *m)		/* page 82 */
+{
+	if(i->i == 0){
+		if(i->rd == 15)
+			bprint(i, "%X\t(R%d+R%d)", "CALL", i->rs2, i->rs1);
+		else
+			bprint(i, "%X\t(R%d+R%d), R%d", m, i->rs2, i->rs1, i->rd);
+	}else{
+		if(!dascase && i->simm13==8 && i->rs1==15 && i->rd==0)
+			bprint(i, "RETURN");
+		else{
+			bprint(i, "%X\t", m);
+			address(i);
+			bprint(i, ", R%d", i->rd);
+		}
+	}
+}
+
+static void
+loadf(Instr *i, char *m)		/* page 70 */
+{
+	if(!dascase){
+		m = "FMOVD";
+		if(i->op3 == 0x20)
+			m = "FMOVF";
+		else if(i->op3 == 0x21)
+			m = "MOVW";
+	}
+	if(i->i == 0)
+		bprint(i, "%s\t(R%d+R%d)", m, i->rs1, i->rs2);
+	else{
+		bprint(i, "%s\t", m);
+		address(i);
+	}
+	if(i->op3 == 0x21)
+		bprint(i, ", FSR");
+	else
+		bprint(i, ", R%d", i->rd);
+}
+
+static
+void storef(Instr *i, char *m)		/* page 70 */
+{
+	if(!dascase){
+		m = "FMOVD";
+		if(i->op3 == 0x25 || i->op3 == 0x26)
+			m = "MOVW";
+		else if(i->op3 == 0x20)
+			m = "FMOVF";
+	}
+	bprint(i, "%s\t", m);
+	if(i->op3 == 0x25)
+		bprint(i, "FSR, ");
+	else if(i->op3 == 0x26)
+		bprint(i, "FQ, ");
+	else
+		bprint(i, "R%d, ", i->rd);
+	if(i->i == 0)
+		bprint(i, "(R%d+R%d)", i->rs1, i->rs2);
+	else
+		address(i);
+}
+
+static
+void loadc(Instr *i, char *m)			/* page 72 */
+{
+	if(i->i == 0)
+		bprint(i, "%s\t(R%d+R%d), C%d", m, i->rs1, i->rs2, i->rd);
+	else{
+		bprint(i, "%s\t", m);
+		address(i);
+		bprint(i, ", C%d", i->rd);
+	}
+}
+
+static
+void loadcsr(Instr *i, char *m)			/* page 72 */
+{
+	if(i->i == 0)
+		bprint(i, "%s\t(R%d+R%d), CSR", m, i->rs1, i->rs2);
+	else{
+		bprint(i, "%s\t", m);
+		address(i);
+		bprint(i, ", CSR");
+	}
+}
+
+static struct{
+	int	opf;
+	char	*name;
+} fptab1[] = {			/* ignores rs1 */
+	0xC4,	"FITOS",	/* page 109 */
+	0xC8,	"FITOD",
+	0xCC,	"FITOX",
+
+	0xD1,	"FSTOI",	/* page 110 */
+	0xD2,	"FDTOI",
+	0xD3,	"FXTOI",
+
+	0xC9,	"FSTOD",	/* page 111 */
+	0xCD,	"FSTOX",
+	0xC6,	"FDTOS",
+	0xCE,	"FDTOX",
+	0xC7,	"FXTOS",
+	0xCB,	"FXTOD",
+
+	0x01,	"FMOVS",	/* page 112 */
+	0x05,	"FNEGS",
+	0x09,	"FABSS",
+
+	0x29,	"FSQRTS", 	/* page 113 */
+	0x2A,	"FSQRTD",
+	0x2B,	"FSQRTX",
+
+	0,	0,
+};
+
+static struct{
+	int	opf;
+	char	*name;
+} fptab2[] = {			/* uses rs1 */
+
+	0x41,	"FADDS",	/* page 114 */
+	0x42,	"FADDD",
+	0x43,	"FADDX",
+	0x45,	"FSUBS",
+	0x46,	"FSUBD",
+	0x47,	"FSUBX",
+
+	0x49,	"FMULS",	/* page 115 */
+	0x4A,	"FMULD",
+	0x4B,	"FMULX",
+	0x4D,	"FDIVS",
+	0x4E,	"FDIVD",
+	0x4F,	"FDIVX",
+
+	0x51,	"FCMPS",	/* page 116 */
+	0x52,	"FCMPD",
+	0x53,	"FCMPX",
+	0x55,	"FCMPES",
+	0x56,	"FCMPED",
+	0x57,	"FCMPEX",
+
+	0, 0
+};
+
+static void
+fpop(Instr *i, char *m)	/* page 108-116 */
+{
+	int j;
+
+	if(dascase==0 && i->size==2){
+		bprint(i, "FMOVD\tF%d, F%d", i->rs2, i->rd);
+		return;
+	}
+	for(j=0; fptab1[j].name; j++)
+		if(fptab1[j].opf == i->opf){
+			bprint(i, "%X\tF%d, F%d", fptab1[j].name, i->rs2, i->rd);
+			return;
+		}
+	for(j=0; fptab2[j].name; j++)
+		if(fptab2[j].opf == i->opf){
+			bprint(i, "%X\tF%d, F%d, F%d", fptab2[j].name, i->rs1, i->rs2, i->rd);
+			return;
+		}
+	bprint(i, "%X%ux\tF%d, F%d, F%d", m, i->opf, i->rs1, i->rs2, i->rd);
+}
+
+static int
+sparcfoll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	ulong w, r1, r2;
+	char buf[8];
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	w = i.w0;
+	switch(w & 0xC1C00000){
+	case 0x00800000:		/* branch on int cond */
+	case 0x01800000:		/* branch on fp cond */
+	case 0x01C00000:		/* branch on copr cond */
+		foll[0] = pc+8;
+		foll[1] = pc + (i.simmdisp22<<2);
+		return 2;
+	}
+
+	if((w&0xC0000000) == 0x40000000){	/* CALL */
+		foll[0] = pc + (i.disp30<<2);
+		return 1;
+	}
+
+	if((w&0xC1F80000) == 0x81C00000){	/* JMPL */
+		sprint(buf, "R%ld", (w>>14)&0xF);
+		r1 = (*rget)(map, buf);
+		if(w & 0x2000)			/* JMPL R1+simm13 */
+			r2 = i.simm13;
+		else{				/* JMPL R1+R2 */
+			sprint(buf, "R%ld", w&0xF);
+			r2 = (*rget)(map, buf);
+		}
+		foll[0] = r1 + r2;
+		return 1;
+	}
+	foll[0] = pc+i.size*4;
+	return 1;
+}
diff --git a/utils/libmach/kobj.c b/utils/libmach/kobj.c
new file mode 100644
index 00000000..f8d7e613
--- /dev/null
+++ b/utils/libmach/kobj.c
@@ -0,0 +1,132 @@
+/*
+ * kobj.c - identify and parse a sparc object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "kc/k.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	type;
+	char	sym;
+	char	name;
+};
+static Addr addr(Biobuf*);
+static char type2char(int);
+static	void	skip(Biobuf*, int);
+
+
+int
+_isk(char *s)
+{
+	return  s[0] == ANAME				/* ANAME */
+		&& s[1] == D_FILE			/* type */
+		&& s[2] == 1				/* sym */
+		&& s[3] == '<';				/* name of file */
+}
+
+
+int
+_readk(Biobuf *bp, Prog *p)
+{
+	int as, n;
+	Addr a;
+
+	as = Bgetc(bp);			/* as */
+	if(as < 0)
+		return 0;
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 5);		/* reg (1 byte); lineno (4 bytes) */
+	a = addr(bp);
+	addr(bp);
+	if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	long off;
+
+	a.type = Bgetc(bp);	/* a.type */
+	skip(bp, 1);		/* reg */
+	a.sym = Bgetc(bp);	/* sym index */
+	a.name = Bgetc(bp);	/* sym type */
+	switch(a.type) {
+	default:
+	case D_NONE: case D_REG: case D_FREG: case D_CREG: case D_PREG:
+		break;
+	case D_BRANCH:
+	case D_OREG:
+	case D_ASI:
+	case D_CONST:
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+		if(a.sym!=0 && (a.name==D_PARAM || a.name==D_AUTO))
+			_offset(a.sym, off);
+		break;
+	case D_SCONST:
+		skip(bp, NSNAME);
+		break;
+	case D_FCONST:
+		skip(bp, 8);
+		break;
+	}
+	return a;
+}
+
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/mach.h b/utils/libmach/mach.h
new file mode 100644
index 00000000..6a5d2569
--- /dev/null
+++ b/utils/libmach/mach.h
@@ -0,0 +1,294 @@
+/*
+ *	Architecture-dependent application data
+ */
+#include "a.out.h"
+/*
+ *	Supported architectures:
+ *		mips,
+ *		68020,
+ *		i386,
+ *		amd64,
+ *		sparc,
+ *		mips2 (R4000)
+ *		arm
+ */
+enum
+{
+	MMIPS,			/* machine types */
+	MSPARC,
+	M68020,
+	MI386,
+	MI960,			/* retired */
+	M3210,			/* retired */
+	MMIPS2,
+	NMIPS2,
+	M29000,			/* retired */
+	MARM,
+	MPOWER,
+
+				/* types of executables */
+	FNONE = 0,		/* unidentified */
+	FMIPS,			/* v.out */
+	FMIPSB,			/* mips bootable */
+	FSPARC,			/* k.out */
+	FSPARCB,		/* Sparc bootable */
+	F68020,			/* 2.out */
+	F68020B,		/* 68020 bootable */
+	FNEXTB,			/* Next bootable */
+	FI386,			/* 8.out */
+	FI386B,			/* I386 bootable */
+	FI960,			/* retired */
+	FI960B,			/* retired */
+	F3210,			/* retired */
+	FMIPS2BE,			/* 4.out */
+	F29000,			/* retired */
+	FARM,			/* 5.out */
+	FARMB,			/* ARM bootable */
+	FPOWER,			/* q.out */
+	FPOWERB,		/* power pc bootable */
+	FMIPS2LE,		/* 4k little endian */
+
+	ANONE = 0,		/* dissembler types */
+	AMIPS,
+	AMIPSCO,		/* native mips */
+	ASPARC,
+	ASUNSPARC,		/* native sun */
+	A68020,
+	AI386,
+	AI8086,			/* oh god */
+	AI960,			/* retired */
+	A29000,
+	AARM,
+	APOWER,
+				/* object file types */
+	Obj68020 = 0,		/* .2 */
+	ObjSparc,		/* .k */
+	ObjMips,		/* .v */
+	Obj386,			/* .8 */
+	Obj960,			/* retired */
+	Obj3210,		/* .x */
+	ObjMips2,		/* .4 */
+	Obj29000,		/* retired */
+	ObjArm,			/* .5 */
+	ObjPower,		/* .q */
+	ObjMips2le,		/* .0 */
+	Maxobjtype,
+
+	CNONE  = 0,		/* symbol table classes */
+	CAUTO,
+	CPARAM,
+	CSTAB,
+	CTEXT,
+	CDATA,
+	CANY			/* to look for any class */
+};
+
+typedef	struct	Map	Map;
+typedef struct	Symbol	Symbol;
+typedef	struct	Reglist	Reglist;
+typedef	struct	Mach	Mach;
+typedef	struct	Machdata Machdata;
+typedef struct	segment	segment;
+
+typedef	int	(*Rsegio)(segment*, ulong, long, char*, int);
+
+/*
+ * 	Structure to map a segment to a position in a file
+ */
+struct Map {
+	int	nsegs;			/* number of segments */
+	struct segment {		/* per-segment map */
+		char	*name;		/* the segment name */
+		int	fd;		/* file descriptor */
+		int	inuse;		/* in use - not in use */
+		ulong	b;		/* base */
+		ulong	e;		/* end */
+		ulong	f;		/* offset within file */
+		Rsegio	mget;	/* special get if not 0 */
+		Rsegio	mput;	/* special put if not 0 */
+	} seg[1];			/* actually n of these */
+};
+
+
+
+/*
+ *	Internal structure describing a symbol table entry
+ */
+struct Symbol {
+	void 	*handle;		/* used internally - owning func */
+	/*struct {*/
+		char	*name;
+		long	value;		/* address or stack offset */
+		char	type;		/* as in a.out.h */
+		char	class;		/* as above */
+	/*};*/
+};
+
+/*
+ *	machine register description
+ */
+struct Reglist {
+	char	*rname;			/* register name */
+	short	roffs;			/* offset in u-block */
+	char	rflags;			/* INTEGER/FLOAT, WRITABLE */
+	char	rformat;		/* print format: 'x', 'X', 'f', '8', '3', 'Y', 'W' */
+};
+
+enum {				/* bits in rflags field */
+	RINT	= (0<<0),
+	RFLT	= (1<<0),
+	RRDONLY	= (1<<1)
+};
+/*
+ *	Machine-dependent data is stored in two structures:
+ *		Mach  - miscellaneous general parameters
+ *		Machdata - jump vector of service functions used by debuggers
+ *
+ *	Mach is defined in 2.c, 4.c, v.c, k.c, 8.c, 6.c and set in executable.c
+ *
+ *	Machdata is defined in 2db.c, 4db.c, vdb.c, kdb.c, 8db.c, and 6db.c
+ *		and set in the debugger startup.
+ */
+
+
+struct Mach{
+	char	*name;
+	int	mtype;			/* machine type code */
+	Reglist *reglist;		/* register set */
+	ulong	regsize;		/* sizeof registers in bytes*/
+	ulong	fpregsize;		/* sizeof fp registers in bytes*/
+	char	*pc;			/* pc name */
+	char	*sp;			/* sp name */
+	char	*link;			/* link register name */
+	char	*sbreg;			/* static base register name */
+	ulong	sb;			/* static base register value */
+	int	pgsize;			/* page size */
+	ulong	kbase;			/* kernel base address */
+	ulong	ktmask;			/* ktzero = kbase & ~ktmask */
+	int	pcquant;		/* quantization of pc */
+	int	szaddr;			/* sizeof(void*) */
+	int	szreg;			/* sizeof(register) */
+	int	szfloat;		/* sizeof(float) */
+	int	szdouble;		/* sizeof(double) */
+};
+
+extern	Mach	*mach;			/* Current machine */
+
+typedef vlong	(*Rgetter)(Map*, char*);
+typedef	void	(*Tracer)(Map*, ulong, ulong, Symbol*);
+
+struct	Machdata {		/* Machine-dependent debugger support */
+	uchar	bpinst[4];			/* break point instr. */
+	short	bpsize;				/* size of break point instr. */
+
+	ushort	(*swab)(ushort);		/* short to local byte order */
+	long	(*swal)(long);			/* long to local byte order */
+	vlong	(*swav)(vlong);			/* vlong to local byte order */
+	int	(*ctrace)(Map*, ulong, ulong, ulong, Tracer); /* C traceback */
+	ulong	(*findframe)(Map*, ulong, ulong, ulong, ulong);/* frame finder */
+	char*	(*excep)(Map*, Rgetter);	/* last exception */
+	ulong	(*bpfix)(ulong);		/* breakpoint fixup */
+	int	(*sftos)(char*, int, void*);	/* single precision float */
+	int	(*dftos)(char*, int, void*);	/* double precision float */
+	int	(*foll)(Map*, ulong, Rgetter, ulong*);	/* follow set */
+	int	(*das)(Map*, ulong, char, char*, int);	/* symbolic disassembly */
+	int	(*hexinst)(Map*, ulong, char*, int); 	/* hex disassembly */
+	int	(*instsize)(Map*, ulong);	/* instruction size */
+};
+
+/*
+ *	Common a.out header describing all architectures
+ */
+typedef struct Fhdr
+{
+	char	*name;		/* identifier of executable */
+	short	type;		/* file type - see codes above*/
+	short	hdrsz;		/* size of this header */
+	long	magic;		/* magic number */
+	long	txtaddr;	/* text address */
+	long	entry;		/* entry point */
+	long	txtsz;		/* text size */
+	long	txtoff;		/* start of text in file */
+	long	dataddr;	/* start of data segment */
+	long	datsz;		/* size of data seg */
+	long	datoff;		/* offset to data seg in file */
+	long	bsssz;		/* size of bss */
+	long	symsz;		/* size of symbol table */
+	long	symoff;		/* offset of symbol table in file */
+	long	sppcsz;		/* size of sp-pc table */
+	long	sppcoff;	/* offset of sp-pc table in file */
+	long	lnpcsz;		/* size of line number-pc table */
+	long	lnpcoff;	/* size of line number-pc table */
+} Fhdr;
+
+extern	int	asstype;		/* dissembler type - machdata.c */
+extern	Machdata *machdata;		/* jump vector - machdata.c */
+
+Map*		attachproc(int, int, int, Fhdr*);
+Map*		attachremt(int, Fhdr*);
+int		beieee80ftos(char*, int, void*);
+int		beieeesftos(char*, int, void*);
+int		beieeedftos(char*, int, void*);
+ushort		beswab(ushort);
+long		beswal(long);
+vlong		beswav(vlong);
+int		cisctrace(Map*, ulong, ulong, ulong, Tracer);
+ulong		ciscframe(Map*, ulong, ulong, ulong, ulong);
+int		crackhdr(int fd, Fhdr*);
+long		file2pc(char*, ulong);
+int		fileelem(Sym**, uchar *, char*, int);
+int		fileline(char*, int, ulong);
+int		filesym(int, char*, int);
+int		findlocal(Symbol*, char*, Symbol*);
+int		findseg(Map*, char*);
+int		findsym(long, int, Symbol *);
+int		fnbound(long, ulong*);
+int		fpformat(Map*, Reglist*, char*, int, int);
+int		get1(Map*, ulong, uchar*, int);
+int		get2(Map*, ulong, ushort*);
+int		get4(Map*, ulong, long*);
+int		get8(Map*, ulong, vlong*);
+int		getauto(Symbol*, int, int, Symbol*);
+Sym*		getsym(int);
+int		globalsym(Symbol *, int);
+char*		_hexify(char*, ulong, int);
+int		ieeesftos(char*, int, ulong);
+int		ieeedftos(char*, int, ulong, ulong);
+int		isar(Biobuf*);
+int		leieee80ftos(char*, int, void*);
+int		leieeesftos(char*, int, void*);
+int		leieeedftos(char*, int, void*);
+ushort		leswab(ushort);
+long		leswal(long);
+vlong		leswav(vlong);
+long		line2addr(ulong, ulong, ulong);
+Map*		loadmap(Map*, int, Fhdr*);
+int		localaddr(Map*, char*, char*, long*, Rgetter);
+int		localsym(Symbol*, int);
+int		lookup(char*, char*, Symbol*);
+void		machbytype(int);
+int		machbyname(char*);
+int		nextar(Biobuf*, int, char*);
+Map*		newmap(Map*, int);
+void		objtraverse(void(*)(Sym*, void*), void*);
+int		objtype(Biobuf*, char**);
+long		pc2sp(ulong);
+long		pc2line(ulong);
+int		put1(Map*, ulong, uchar*, int);
+int		put2(Map*, ulong, ushort);
+int		put4(Map*, ulong, long);
+int		put8(Map*, ulong, vlong);
+int		readar(Biobuf*, int, int, int);
+int		readobj(Biobuf*, int);
+struct segment*	reloc(Map*, ulong, long*);
+ulong		riscframe(Map*, ulong, ulong, ulong, ulong);
+int		risctrace(Map*, ulong, ulong, ulong, Tracer);
+int		setmap(Map*, int, ulong, ulong, ulong, char*);
+void		setmapio(Map*, int, Rsegio, Rsegio);
+Sym*		symbase(long*);
+int		syminit(int, Fhdr*);
+int		symoff(char*, int, long, int);
+void		textseg(ulong, Fhdr*);
+int		textsym(Symbol*, int);
+void		unusemap(Map*, int);
+
diff --git a/utils/libmach/machdata.c b/utils/libmach/machdata.c
new file mode 100644
index 00000000..a82e14e8
--- /dev/null
+++ b/utils/libmach/machdata.c
@@ -0,0 +1,450 @@
+/*
+ * Debugger utilities shared by at least two architectures
+ */
+
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+#define STARTSYM	"_main"
+#define PROFSYM		"_mainp"
+#define	FRAMENAME	".frame"
+
+extern	Machdata	mipsmach;
+
+int	asstype = AMIPS;		/* disassembler type */
+Machdata *machdata;		/* machine-dependent functions */
+
+int
+localaddr(Map *map, char *fn, char *var, long *r, Rgetter rget)
+{
+	Symbol s;
+	ulong fp;
+	ulong pc, sp, link;
+
+	if (!lookup(fn, 0, &s)) {
+		werrstr("function not found");
+		return -1;
+	}
+	pc = rget(map, mach->pc);
+	sp = rget(map, mach->sp);
+	if(mach->link)
+		link = rget(map, mach->link);
+	else
+		link = 0;
+	fp = machdata->findframe(map, s.value, pc, sp, link);
+	if (fp == 0) {
+		werrstr("stack frame not found");
+		return -1;
+	}
+
+	if (!var || !var[0]) {
+		*r = fp;
+		return 1;
+	}
+
+	if (findlocal(&s, var, &s) == 0) {
+		werrstr("local variable not found");
+		return -1;
+	}
+
+	switch (s.class) {
+	case CAUTO:
+		*r = fp - s.value;
+		break;
+	case CPARAM:		/* assume address size is stack width */
+		*r = fp + s.value + mach->szaddr;
+		break;
+	default:
+		werrstr("local variable not found: %d", s.class);
+		return -1;
+	}
+	return 1;
+}
+
+/*
+ * Print value v as name[+offset] and then the string s.
+ */
+int
+symoff(char *buf, int n, long v, int space)
+{
+	Symbol s;
+	int r;
+	long delta;
+
+	r = delta = 0;		/* to shut compiler up */
+	if (v) {
+		r = findsym(v, space, &s);
+		if (r)
+			delta = v-s.value;
+		if (delta < 0)
+			delta = -delta;
+	}
+	if (v == 0 || r == 0)
+		return snprint(buf, n, "%lux", v);
+	if (s.type != 't' && s.type != 'T' && delta >= 4096)
+		return snprint(buf, n, "%lux", v);
+	if (strcmp(s.name, ".string") == 0)
+		return snprint(buf, n, "%lux", v);
+	if (delta)
+		return snprint(buf, n, "%s+%lux", s.name, v-s.value);
+	else
+		return snprint(buf, n, "%s", s.name);
+}
+/*
+ *	Format floating point registers
+ *
+ *	Register codes in format field:
+ *	'X' - print as 32-bit hexadecimal value
+ *	'F' - 64-bit double register when modif == 'F'; else 32-bit single reg
+ *	'f' - 32-bit ieee float
+ *	'8' - big endian 80-bit ieee extended float
+ *	'3' - little endian 80-bit ieee extended float with hole in bytes 8&9
+ */
+int
+fpformat(Map *map, Reglist *rp, char *buf, int n, int modif)
+{
+	char reg[12];
+	long r;
+
+	switch(rp->rformat)
+	{
+	case 'X':
+		if (get4(map, rp->roffs, &r) < 0)
+			return -1;
+		snprint(buf, n, "%lux", r);
+		break;
+	case 'F':	/* first reg of double reg pair */
+		if (modif == 'F')
+		if (((rp+1)->rflags&RFLT) && (rp+1)->rformat == 'f') {
+			if (get1(map, rp->roffs, (uchar *)reg, 8) < 0)
+				return -1;
+			machdata->dftos(buf, n, reg);
+			return 2;
+		}	
+			/* treat it like 'f' */
+		if (get1(map, rp->roffs, (uchar *)reg, 4) < 0)
+			return -1;
+		machdata->sftos(buf, n, reg);
+		break;
+	case 'f':	/* 32 bit float */
+		if (get1(map, rp->roffs, (uchar *)reg, 4) < 0)
+			return -1;
+		machdata->sftos(buf, n, reg);
+		break;
+	case '3':	/* little endian ieee 80 with hole in bytes 8&9 */
+		if (get1(map, rp->roffs, (uchar *)reg, 10) < 0)
+			return -1;
+		memmove(reg+10, reg+8, 2);	/* open hole */
+		memset(reg+8, 0, 2);		/* fill it */
+		leieee80ftos(buf, n, reg);
+		break;
+	case '8':	/* big-endian ieee 80 */
+		if (get1(map, rp->roffs, (uchar *)reg, 10) < 0)
+			return -1;
+		beieee80ftos(buf, n, reg);
+		break;
+	default:	/* unknown */
+		break;
+	}
+	return 1;
+}
+
+char *
+_hexify(char *buf, ulong p, int zeros)
+{
+	ulong d;
+
+	d = p/16;
+	if(d)
+		buf = _hexify(buf, d, zeros-1);
+	else
+		while(zeros--)
+			*buf++ = '0';
+	*buf++ = "0123456789abcdef"[p&0x0f];
+	return buf;
+}
+
+/*
+ * These routines assume that if the number is representable
+ * in IEEE floating point, it will be representable in the native
+ * double format.  Naive but workable, probably.
+ */
+int
+ieeedftos(char *buf, int n, ulong h, ulong l)
+{
+	double fr;
+	int exp;
+
+	if (n <= 0)
+		return 0;
+
+
+	if(h & (1L<<31)){
+		*buf++ = '-';
+		h &= ~(1L<<31);
+	}else
+		*buf++ = ' ';
+	n--;
+	if(l == 0 && h == 0)
+		return snprint(buf, n, "0.");
+	exp = (h>>20) & ((1L<<11)-1L);
+	if(exp == 0)
+		return snprint(buf, n, "DeN(%.8lux%.8lux)", h, l);
+	if(exp == ((1L<<11)-1L)){
+		if(l==0 && (h&((1L<<20)-1L)) == 0)
+			return snprint(buf, n, "Inf");
+		else
+			return snprint(buf, n, "NaN(%.8lux%.8lux)", h&((1L<<20)-1L), l);
+	}
+	exp -= (1L<<10) - 2L;
+	fr = l & ((1L<<16)-1L);
+	fr /= 1L<<16;
+	fr += (l>>16) & ((1L<<16)-1L);
+	fr /= 1L<<16;
+	fr += (h & (1L<<20)-1L) | (1L<<20);
+	fr /= 1L<<21;
+	fr = ldexp(fr, exp);
+	return snprint(buf, n, "%.18g", fr);
+}
+
+int
+ieeesftos(char *buf, int n, ulong h)
+{
+	double fr;
+	int exp;
+
+	if (n <= 0)
+		return 0;
+
+	if(h & (1L<<31)){
+		*buf++ = '-';
+		h &= ~(1L<<31);
+	}else
+		*buf++ = ' ';
+	n--;
+	if(h == 0)
+		return snprint(buf, n, "0.");
+	exp = (h>>23) & ((1L<<8)-1L);
+	if(exp == 0)
+		return snprint(buf, n, "DeN(%.8lux)", h);
+	if(exp == ((1L<<8)-1L)){
+		if((h&((1L<<23)-1L)) == 0)
+			return snprint(buf, n, "Inf");
+		else
+			return snprint(buf, n, "NaN(%.8lux)", h&((1L<<23)-1L));
+	}
+	exp -= (1L<<7) - 2L;
+	fr = (h & ((1L<<23)-1L)) | (1L<<23);
+	fr /= 1L<<24;
+	fr = ldexp(fr, exp);
+	return snprint(buf, n, "%.9g", fr);
+}
+
+int
+beieeesftos(char *buf, int n, void *s)
+{
+	return ieeesftos(buf, n, beswal(*(ulong*)s));
+}
+
+int
+beieeedftos(char *buf, int n, void *s)
+{
+	return ieeedftos(buf, n, beswal(*(ulong*)s), beswal(((ulong*)(s))[1]));
+}
+
+int
+leieeesftos(char *buf, int n, void *s)
+{
+	return ieeesftos(buf, n, leswal(*(ulong*)s));
+}
+
+int
+leieeedftos(char *buf, int n, void *s)
+{
+	return ieeedftos(buf, n, leswal(((ulong*)(s))[1]), leswal(*(ulong*)s));
+}
+
+/* packed in 12 bytes, with s[2]==s[3]==0; mantissa starts at s[4]*/
+int
+beieee80ftos(char *buf, int n, void *s)
+{
+	uchar *reg = (uchar*)s;
+	int i;
+	ulong x;
+	uchar ieee[8+8];	/* room for slop */
+	uchar *p, *q;
+
+	memset(ieee, 0, sizeof(ieee));
+	/* sign */
+	if(reg[0] & 0x80)
+		ieee[0] |= 0x80;
+
+	/* exponent */
+	x = ((reg[0]&0x7F)<<8) | reg[1];
+	if(x == 0)		/* number is ±0 */
+		goto done;
+	if(x == 0x7FFF){
+		if(memcmp(reg+4, ieee+1, 8) == 0){ /* infinity */
+			x = 2047;
+		}else{				/* NaN */
+			x = 2047;
+			ieee[7] = 0x1;		/* make sure */
+		}
+		ieee[0] |= x>>4;
+		ieee[1] |= (x&0xF)<<4;
+		goto done;
+	}
+	x -= 0x3FFF;		/* exponent bias */
+	x += 1023;
+	if(x >= (1<<11) || ((reg[4]&0x80)==0 && x!=0))
+		return snprint(buf, n, "not in range");
+	ieee[0] |= x>>4;
+	ieee[1] |= (x&0xF)<<4;
+
+	/* mantissa */
+	p = reg+4;
+	q = ieee+1;
+	for(i=0; i<56; i+=8, p++, q++){	/* move one byte */
+		x = (p[0]&0x7F) << 1;
+		if(p[1] & 0x80)
+			x |= 1;
+		q[0] |= x>>4;
+		q[1] |= (x&0xF)<<4;
+	}
+    done:
+	return beieeedftos(buf, n, (void*)ieee);
+}
+
+
+int
+leieee80ftos(char *buf, int n, void *s)
+{
+	int i;
+	char *cp;
+	char b[12];
+
+	cp = (char*) s;
+	for(i=0; i<12; i++)
+		b[11-i] = *cp++;
+	return beieee80ftos(buf, n, b);
+}
+
+int
+cisctrace(Map *map, ulong pc, ulong sp, ulong link, Tracer trace)
+{
+	Symbol s;
+	int found;
+	ulong opc;
+	long moved, j;
+
+	USED(link);
+	j = 0;
+	opc = 0;
+	while(pc && opc != pc) {
+		moved = pc2sp(pc);
+		if (moved == -1)
+			break;
+		found = findsym(pc, CTEXT, &s);
+		if (!found)
+			break;
+		if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
+			break;
+
+		sp += moved;
+		opc = pc;
+		if (get4(map, sp, (long *)&pc) < 0)
+			break;
+		(*trace)(map, pc, sp, &s);
+		sp += mach->szaddr;	/*assumes address size = stack width*/
+		if(++j > 40)
+			break;
+	}
+	return j;
+}
+
+int
+risctrace(Map *map, ulong pc, ulong sp, ulong link, Tracer trace)
+{
+	int i;
+	Symbol s, f;
+	ulong oldpc;
+
+	i = 0;
+	while(findsym(pc, CTEXT, &s)) {
+		if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
+			break;
+
+		if(pc == s.value)	/* at first instruction */
+			f.value = 0;
+		else if(findlocal(&s, FRAMENAME, &f) == 0)
+			break;
+
+		oldpc = pc;
+		if(s.type == 'L' || s.type == 'l' || pc <= s.value+mach->pcquant)
+			pc = link;
+		else
+			if (get4(map, sp, (long *) &pc) < 0)
+				break;
+
+		if(pc == 0 || (pc == oldpc && f.value == 0))
+			break;
+
+		sp += f.value;
+		(*trace)(map, pc-8, sp, &s);
+
+		if(++i > 40)
+			break;
+	}
+	return i;
+}
+
+ulong
+ciscframe(Map *map, ulong addr, ulong pc, ulong sp, ulong link)
+{
+	Symbol s;
+	int moved;
+
+	USED(link);
+	for(;;) {
+		moved = pc2sp(pc);
+		if (moved  == -1)
+			break;
+		sp += moved;
+		findsym(pc, CTEXT, &s);
+		if (addr == s.value)
+			return sp;
+		if (get4(map, sp, (long *) &pc) < 0)
+			break;
+		sp += mach->szaddr;	/*assumes sizeof(addr) = stack width*/
+	}
+	return 0;
+}
+
+ulong
+riscframe(Map *map, ulong addr, ulong pc, ulong sp, ulong link)
+{
+	Symbol s, f;
+
+	while (findsym(pc, CTEXT, &s)) {
+		if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
+			break;
+
+		if(pc == s.value)	/* at first instruction */
+			f.value = 0;
+		else
+		if(findlocal(&s, FRAMENAME, &f) == 0)
+			break;
+
+		sp += f.value;
+		if (s.value == addr)
+			return sp;
+
+		if (s.type == 'L' || s.type == 'l' || pc-s.value <= mach->szaddr*2)
+			pc = link;
+		else
+		if (get4(map, sp-f.value, (long *)&pc) < 0)
+			break;
+	}
+	return 0;
+}
diff --git a/utils/libmach/map.c b/utils/libmach/map.c
new file mode 100644
index 00000000..afb19b11
--- /dev/null
+++ b/utils/libmach/map.c
@@ -0,0 +1,203 @@
+/*
+ * file map routines
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+Map *
+newmap(Map *map, int n)
+{
+	int size;
+
+	size = sizeof(Map)+(n-1)*sizeof(struct segment);
+	if (map == 0)
+		map = malloc(size);
+	else
+		map = realloc(map, size);
+	if (map == 0) {
+		werrstr("out of memory: %r");
+		return 0;
+	}
+	memset(map, 0, size);
+	map->nsegs = n;
+	return map;
+}
+
+int
+setmap(Map *map, int fd, ulong b, ulong e, ulong f, char *name)
+{
+	int i;
+
+	if (map == 0)
+		return 0;
+	for (i = 0; i < map->nsegs; i++)
+		if (!map->seg[i].inuse)
+			break;
+	if (i >= map->nsegs)
+		return 0;
+	map->seg[i].b = b;
+	map->seg[i].e = e;
+	map->seg[i].f = f;
+	map->seg[i].inuse = 1;
+	map->seg[i].name = name;
+	map->seg[i].fd = fd;
+	return 1;
+}
+
+static ulong
+stacktop(int pid)
+{
+	char buf[64];
+	int fd;
+	int n;
+	char *cp;
+
+	sprint(buf, "/proc/%d/segment", pid);
+	fd = open(buf, 0);
+	if (fd < 0)
+		return 0;
+	n = read(fd, buf, sizeof(buf)-1);
+	close(fd);
+	buf[n] = 0;
+	if (strncmp(buf, "Stack", 5))
+		return 0;
+	for (cp = buf+5; *cp && *cp == ' '; cp++)
+		;
+	if (!*cp)
+		return 0;
+	cp = strchr(cp, ' ');
+	if (!cp)
+		return 0;
+	while (*cp && *cp == ' ')
+		cp++;
+	if (!*cp)
+		return 0;
+	return strtoul(cp, 0, 16);
+}
+
+Map*
+attachproc(int pid, int kflag, int corefd, Fhdr *fp)
+{
+	char buf[64], *regs;
+	int fd;
+	Map *map;
+	ulong n;
+	int mode;
+
+	map = newmap(0, 4);
+	if (!map)
+		return 0;
+	if(kflag) {
+		regs = "kregs";
+		mode = OREAD;
+	} else {
+		regs = "regs";
+		mode = ORDWR;
+	}
+	if (mach->regsize) {
+		sprint(buf, "/proc/%d/%s", pid, regs);
+		fd = open(buf, mode);
+		if(fd < 0) {
+			free(map);
+			return 0;
+		}
+		setmap(map, fd, 0, mach->regsize, 0, "regs");
+	}
+	if (mach->fpregsize) {
+		sprint(buf, "/proc/%d/fpregs", pid);
+		fd = open(buf, mode);
+		if(fd < 0) {
+			close(map->seg[0].fd);
+			free(map);
+			return 0;
+		}
+		setmap(map, fd, mach->regsize, mach->regsize+mach->fpregsize, 0, "fpregs");
+	}
+	setmap(map, corefd, fp->txtaddr, fp->txtaddr+fp->txtsz, fp->txtaddr, "text");
+	if(kflag || (ulong) fp->dataddr >= 0x7fffffff) {
+		setmap(map, corefd, fp->dataddr, 0xffffffff, fp->dataddr, "data");
+		return map;
+	}
+	n = stacktop(pid);
+	if (n == 0) {
+		setmap(map, corefd, fp->dataddr, 0x7fffffff, fp->dataddr, "data");
+		return map;
+	}
+	setmap(map, corefd, fp->dataddr, n, fp->dataddr, "data");
+	return map;
+}
+	
+int
+findseg(Map *map, char *name)
+{
+	int i;
+
+	if (!map)
+		return -1;
+	for (i = 0; i < map->nsegs; i++)
+		if (map->seg[i].inuse && !strcmp(map->seg[i].name, name))
+			return i;
+	return -1;
+}
+
+void
+unusemap(Map *map, int i)
+{
+	if (map != 0 && 0 <= i && i < map->nsegs)
+		map->seg[i].inuse = 0;
+}
+
+Map*
+attachremt(int fd, Fhdr *f)
+{
+	Map *m;
+	ulong txt;
+
+	m = newmap(0, 3);
+	if (m == 0)
+		return 0;
+
+	/* Space for mach structures */
+	txt = f->txtaddr;
+	if(txt > 8*4096)
+		txt -= 8*4096;
+
+	setmap(m, fd, txt, f->txtaddr+f->txtsz, txt, "*text");
+	/*setmap(m, fd, f->dataddr, 0xffffffff, f->dataddr, "*data");*/ /* pc heap is < KTZERO */
+	setmap(m, fd, 4096, 0xffffffff, 4096, "*data");
+	setmap(m, fd, 0x0, mach->regsize, 0, "kreg");
+
+	return m;
+}
+
+Map*
+loadmap(Map *map, int fd, Fhdr *fp)
+{
+	map = newmap(map, 2);
+	if (map == 0)
+		return 0;
+
+	map->seg[0].b = fp->txtaddr;
+	map->seg[0].e = fp->txtaddr+fp->txtsz;
+	map->seg[0].f = fp->txtoff;
+	map->seg[0].fd = fd;
+	map->seg[0].inuse = 1;
+	map->seg[0].name = "text";
+	map->seg[1].b = fp->dataddr;
+	map->seg[1].e = fp->dataddr+fp->datsz;
+	map->seg[1].f = fp->datoff;
+	map->seg[1].fd = fd;
+	map->seg[1].inuse = 1;
+	map->seg[1].name = "data";
+	return map;
+}
+
+void
+setmapio(Map *map, int i, Rsegio get, Rsegio put)
+{
+	if (map != 0 && 0 <= i && i < map->nsegs) {
+		map->seg[i].mget = get;
+		map->seg[i].mput = put;
+	}
+}
diff --git a/utils/libmach/mkfile b/utils/libmach/mkfile
new file mode 100644
index 00000000..e2747136
--- /dev/null
+++ b/utils/libmach/mkfile
@@ -0,0 +1,46 @@
+<../../mkconfig
+
+LIB=libmach.a
+OFILES=\
+	2.$O\
+	4.$O\
+	5.$O\
+	6.$O\
+	8.$O\
+	k.$O\
+	q.$O\
+	t.$O\
+	v.$O\
+	2db.$O\
+	4db.$O\
+	5db.$O\
+	8db.$O\
+	kdb.$O\
+	qdb.$O\
+	tdb.$O\
+	vdb.$O\
+	2obj.$O\
+	5obj.$O\
+	6obj.$O\
+	8obj.$O\
+	kobj.$O\
+	qobj.$O\
+	tobj.$O\
+	vobj.$O\
+	obj.$O\
+	map.$O\
+	swap.$O\
+	sym.$O\
+	access.$O\
+	machdata.$O\
+	setmach.$O\
+	executable.$O\
+	vcodas.$O\
+
+HFILES=mach.h a.out.h bootexec.h elf.h ureg2.h ureg4.h ureg6.h ureg8.h uregk.h uregv.h ureg5.h
+
+<$ROOT/mkfiles/mksyslib-$SHELLTYPE
+CFLAGS= $CFLAGS -I..
+
+package:QV:
+	$TRUE
diff --git a/utils/libmach/obj.c b/utils/libmach/obj.c
new file mode 100644
index 00000000..39f2fad4
--- /dev/null
+++ b/utils/libmach/obj.c
@@ -0,0 +1,326 @@
+/*
+ * obj.c
+ * routines universal to all object files
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "ar.h"
+#include "mach.h"
+#include "obj.h"
+
+#define islocal(t)	((t)=='a' || (t)=='p')
+
+enum
+{
+	NNAMES	= 50,
+	MAXIS	= 8,		/* max length to determine if a file is a .? file */
+	MAXOFF	= 0x7fffffff,	/* larger than any possible local offset */
+	NHASH	= 1024,		/* must be power of two */
+	HASHMUL	= 79L,
+};
+
+int	_is2(char*),		/* in [$OS].c */
+	_is5(char*),
+	_is6(char*),
+	_is8(char*),
+	_is9(char*),
+	_isk(char*),
+	_isq(char*),
+	_ist(char*),
+	_isv(char*),
+	_isx(char*),
+	_read2(Biobuf*, Prog*),
+	_read5(Biobuf*, Prog*),
+	_read6(Biobuf*, Prog*),
+	_read8(Biobuf*, Prog*),
+	_read9(Biobuf*, Prog*),
+	_readk(Biobuf*, Prog*),
+	_readq(Biobuf*, Prog*),
+	_readt(Biobuf*, Prog*),
+	_readv(Biobuf*, Prog*),
+	_readx(Biobuf*, Prog*);
+
+typedef struct Obj	Obj;
+typedef struct Symtab	Symtab;
+
+struct	Obj		/* functions to handle each intermediate (.$O) file */
+{
+	char	*name;				/* name of each $O file */
+	int	(*is)(char*);			/* test for each type of $O file */
+	int	(*read)(Biobuf*, Prog*);	/* read for each type of $O file*/
+};
+
+static Obj	obj[] =
+{			/* functions to identify and parse each type of obj */
+	/*[Obj68020]*/	"68020 .2",	_is2, _read2,
+	/*[ObjSparc]*/	"sparc .k",	_isk, _readk,
+	/*[ObjMips]*/	"mips .v",	_isv, _readv,
+	/*[Obj386]*/	"386 .8",	_is8, _read8,
+	/*[Obj960]*/	"960 .6",	0, 0, 
+	/*[Obj3210]*/	"3210 .x",	0, 0,
+	/*[ObjMips2]*/	"mips2 .4",	0, 0,
+	/*[Obj29000]*/	"29000 .9",	0, 0,
+	/*[ObjArm]*/	"arm .5",	_is5, _read5,
+	/*[ObjPower]*/	"power .q",	_isq, _readq,
+	/*[ObjMips2le]*/	"mips2 .0",	0, 0,
+	/*[Maxobjtype]*/	0, 0
+};
+
+struct	Symtab
+{
+	struct	Sym 	s;
+	struct	Symtab	*next;
+};
+
+static	Symtab *hash[NHASH];
+static	Sym	*names[NNAMES];	/* working set of active names */
+
+static	int	processprog(Prog*,int);	/* decode each symbol reference */
+static	void	objreset(void);
+static	void	objlookup(int, char *, int );
+static	void 	objupdate(int, int);
+
+int
+objtype(Biobuf *bp, char **name)
+{
+	int i;
+	char buf[MAXIS];
+
+	if(Bread(bp, buf, MAXIS) < MAXIS)
+		return -1;
+	Bseek(bp, -MAXIS, 1);
+	for (i = 0; i < Maxobjtype; i++) {
+		if (obj[i].is && (*obj[i].is)(buf)) {
+			if (name)
+				*name = obj[i].name;
+			return i;
+		}
+	}
+	return -1;
+}
+
+int
+isar(Biobuf *bp)
+{
+	int n;
+	char magbuf[SARMAG];
+
+	n = Bread(bp, magbuf, SARMAG);
+	if(n == SARMAG && strncmp(magbuf, ARMAG, SARMAG) == 0)
+		return 1;
+	return 0;
+}
+
+/*
+ * determine what kind of object file this is and process it.
+ * return whether or not this was a recognized intermediate file.
+ */
+int
+readobj(Biobuf *bp, int objtype)
+{
+	Prog p;
+
+	if (objtype < 0 || objtype >= Maxobjtype || obj[objtype].is == 0)
+		return 1;
+	objreset();
+	while ((*obj[objtype].read)(bp, &p))
+		if (!processprog(&p, 1))
+			return 0;
+	return 1;
+}
+
+int
+readar(Biobuf *bp, int objtype, int end, int doautos)
+{
+	Prog p;
+
+	if (objtype < 0 || objtype >= Maxobjtype || obj[objtype].is == 0)
+		return 1;
+	objreset();
+	while ((*obj[objtype].read)(bp, &p) && BOFFSET(bp) < end)
+		if (!processprog(&p, doautos))
+			return 0;
+	return 1;
+}
+
+/*
+ *	decode a symbol reference or definition
+ */
+static	int
+processprog(Prog *p, int doautos)
+{
+	if(p->kind == aNone)
+		return 1;
+	if(p->sym < 0 || p->sym >= NNAMES)
+		return 0;
+	switch(p->kind)
+	{
+	case aName:
+		if (!doautos)
+		if(p->type != 'U' && p->type != 'b')
+			break;
+		objlookup(p->sym, p->id, p->type);
+		break;
+	case aText:
+		objupdate(p->sym, 'T');
+		break;
+	case aData:
+		objupdate(p->sym, 'D');
+		break;
+	default:
+		break;
+	}
+	return 1;
+}
+
+/*
+ * find the entry for s in the symbol array.
+ * make a new entry if it is not already there.
+ */
+static void
+objlookup(int id, char *name, int type)
+{
+	long h;
+	char *cp;
+	Sym *s;
+	Symtab *sp;
+
+	s = names[id];
+	if(s && strcmp(s->name, name) == 0) {
+		s->type = type;
+		return;
+	}
+
+	h = *name;
+	for(cp = name+1; *cp; h += *cp++)
+		h *= HASHMUL;
+	if(h < 0)
+		h = ~h;
+	h &= (NHASH-1);
+	if (type == 'U' || type == 'b' || islocal(type)) {
+		for(sp = hash[h]; sp; sp = sp->next)
+			if(strcmp(sp->s.name, name) == 0) {
+				switch(sp->s.type) {
+				case 'T':
+				case 'D':
+				case 'U':
+					if (type == 'U') {
+						names[id] = &sp->s;
+						return;
+					}
+					break;
+				case 't':
+				case 'd':
+				case 'b':
+					if (type == 'b') {
+						names[id] = &sp->s;
+						return;
+					}
+					break;
+				case 'a':
+				case 'p':
+					if (islocal(type)) {
+						names[id] = &sp->s;
+						return;
+					}
+					break;
+				default:
+					break;
+				}
+			}
+	}
+	sp = malloc(sizeof(Symtab));
+	sp->s.name = name;
+	sp->s.type = type;
+	sp->s.value = islocal(type) ? MAXOFF : 0;
+	names[id] = &sp->s;
+	sp->next = hash[h];
+	hash[h] = sp;
+	return;
+}
+/*
+ *	traverse the symbol lists
+ */
+void
+objtraverse(void (*fn)(Sym*, void*), void *pointer)
+{
+	int i;
+	Symtab *s;
+
+	for(i = 0; i < NHASH; i++)
+		for(s = hash[i]; s; s = s->next)
+			(*fn)(&s->s, pointer);
+}
+
+/*
+ * update the offset information for a 'a' or 'p' symbol in an intermediate file
+ */
+void
+_offset(int id, long off)
+{
+	Sym *s;
+
+	s = names[id];
+	if (s && s->name[0] && islocal(s->type) && s->value > off)
+		s->value = off;
+}
+
+/*
+ * update the type of a global text or data symbol
+ */
+static void 
+objupdate(int id, int type)
+{
+	Sym *s;
+
+	s = names[id];
+	if (s && s->name[0])
+		if (s->type == 'U')
+			s->type = type;
+		else if (s->type == 'b')
+			s->type = tolower(type);
+}
+
+/*
+ * look for the next file in an archive
+ */
+int
+nextar(Biobuf *bp, int offset, char *buf)
+{
+	struct ar_hdr a;
+	int i, r;
+	long arsize;
+
+	if (offset&01)
+		offset++;
+	Bseek(bp, offset, 0);
+	r = Bread(bp, &a, SAR_HDR);
+	if(r != SAR_HDR)
+		return 0;
+	if(strncmp(a.fmag, ARFMAG, sizeof(a.fmag)))
+		return -1;
+	for(i=0; i<sizeof(a.name) && i<SARNAME && a.name[i] != ' '; i++)
+		buf[i] = a.name[i];
+	buf[i] = 0;
+	arsize = atol(a.size);
+	if (arsize&1)
+		arsize++;
+	return arsize + SAR_HDR;
+}
+
+static void
+objreset(void)
+{
+	int i;
+	Symtab *s, *n;
+
+	for(i = 0; i < NHASH; i++) {
+		for(s = hash[i]; s; s = n) {
+			n = s->next;
+			free(s->s.name);
+			free(s);
+		}
+		hash[i] = 0;
+	}
+	memset(names, 0, sizeof names);
+}
diff --git a/utils/libmach/obj.h b/utils/libmach/obj.h
new file mode 100644
index 00000000..2d2dfea6
--- /dev/null
+++ b/utils/libmach/obj.h
@@ -0,0 +1,24 @@
+/*
+ * obj.h -- defs for dealing with object files
+ */
+
+typedef enum Kind		/* variable defs and references in obj */
+{
+	aNone,			/* we don't care about this prog */
+	aName,			/* introduces a name */
+	aText,			/* starts a function */
+	aData,			/* references to a global object */
+} Kind;
+
+typedef struct	Prog	Prog;
+
+struct Prog		/* info from .$O files */
+{
+	Kind	kind;		/* what kind of symbol */
+	char	type;		/* type of the symbol: ie, 'T', 'a', etc. */
+	char	sym;		/* index of symbol's name */
+	char	*id;		/* name for the symbol, if it introduces one */
+};
+
+#define UNKNOWN	'?'
+void		_offset(int, long);
diff --git a/utils/libmach/q.c b/utils/libmach/q.c
new file mode 100644
index 00000000..858882bf
--- /dev/null
+++ b/utils/libmach/q.c
@@ -0,0 +1,122 @@
+/*
+ * PowerPC definition
+ *	forsyth@terzarima.net
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "uregq.h"
+#include "mach.h"
+
+
+#define	REGOFF(x)	(ulong) (&((struct Ureg *) 0)->x)
+
+#define SP		REGOFF(sp)
+#define PC		REGOFF(pc)
+#define	R3		REGOFF(r3)	/* return reg */
+#define	LR		REGOFF(lr)
+#define R31		REGOFF(r31)
+#define FP_REG(x)	(R31+4+8*(x))
+
+#define	REGSIZE	sizeof(struct Ureg)
+#define	FPREGSIZE	(8*33)
+
+Reglist powerreglist[] = {
+	{"CAUSE",	REGOFF(cause), RINT|RRDONLY, 'X'},
+	{"SRR1",	REGOFF(status), RINT|RRDONLY, 'X'},
+	{"PC",		REGOFF(pc), RINT, 'X'},
+	{"LR",		REGOFF(lr), RINT, 'X'},
+	{"CR",		REGOFF(cr), RINT, 'X'},
+	{"XER",		REGOFF(xer), RINT, 'X'},
+	{"CTR",		REGOFF(ctr), RINT, 'X'},
+	{"PC",		PC, RINT, 'X'},
+	{"SP",		SP, RINT, 'X'},
+	{"R0",		REGOFF(r0), RINT, 'X'},
+	/* R1 is SP */
+	{"R2",		REGOFF(r2), RINT, 'X'},
+	{"R3",		REGOFF(r3), RINT, 'X'},
+	{"R4",		REGOFF(r4), RINT, 'X'},
+	{"R5",		REGOFF(r5), RINT, 'X'},
+	{"R6",		REGOFF(r6), RINT, 'X'},
+	{"R7",		REGOFF(r7), RINT, 'X'},
+	{"R8",		REGOFF(r8), RINT, 'X'},
+	{"R9",		REGOFF(r9), RINT, 'X'},
+	{"R10",		REGOFF(r10), RINT, 'X'},
+	{"R11",		REGOFF(r11), RINT, 'X'},
+	{"R12",		REGOFF(r12), RINT, 'X'},
+	{"R13",		REGOFF(r13), RINT, 'X'},
+	{"R14",		REGOFF(r14), RINT, 'X'},
+	{"R15",		REGOFF(r15), RINT, 'X'},
+	{"R16",		REGOFF(r16), RINT, 'X'},
+	{"R17",		REGOFF(r17), RINT, 'X'},
+	{"R18",		REGOFF(r18), RINT, 'X'},
+	{"R19",		REGOFF(r19), RINT, 'X'},
+	{"R20",		REGOFF(r20), RINT, 'X'},
+	{"R21",		REGOFF(r21), RINT, 'X'},
+	{"R22",		REGOFF(r22), RINT, 'X'},
+	{"R23",		REGOFF(r23), RINT, 'X'},
+	{"R24",		REGOFF(r24), RINT, 'X'},
+	{"R25",		REGOFF(r25), RINT, 'X'},
+	{"R26",		REGOFF(r26), RINT, 'X'},
+	{"R27",		REGOFF(r27), RINT, 'X'},
+	{"R28",		REGOFF(r28), RINT, 'X'},
+	{"R29",		REGOFF(r29), RINT, 'X'},
+	{"R30",		REGOFF(r30), RINT, 'X'},
+	{"R31",		REGOFF(r31), RINT, 'X'},
+	{"F0",		FP_REG(0), RFLT, 'D'},
+	{"F1",		FP_REG(1), RFLT, 'D'},
+	{"F2",		FP_REG(2), RFLT, 'D'},
+	{"F3",		FP_REG(3), RFLT, 'D'},
+	{"F4",		FP_REG(4), RFLT, 'D'},
+	{"F5",		FP_REG(5), RFLT, 'D'},
+	{"F6",		FP_REG(6), RFLT, 'D'},
+	{"F7",		FP_REG(7), RFLT, 'D'},
+	{"F8",		FP_REG(8), RFLT, 'D'},
+	{"F9",		FP_REG(9), RFLT, 'D'},
+	{"F10",		FP_REG(10), RFLT, 'D'},
+	{"F11",		FP_REG(11), RFLT, 'D'},
+	{"F12",		FP_REG(12), RFLT, 'D'},
+	{"F13",		FP_REG(13), RFLT, 'D'},
+	{"F14",		FP_REG(14), RFLT, 'D'},
+	{"F15",		FP_REG(15), RFLT, 'D'},
+	{"F16",		FP_REG(16), RFLT, 'D'},
+	{"F17",		FP_REG(17), RFLT, 'D'},
+	{"F18",		FP_REG(18), RFLT, 'D'},
+	{"F19",		FP_REG(19), RFLT, 'D'},
+	{"F20",		FP_REG(20), RFLT, 'D'},
+	{"F21",		FP_REG(21), RFLT, 'D'},
+	{"F22",		FP_REG(22), RFLT, 'D'},
+	{"F23",		FP_REG(23), RFLT, 'D'},
+	{"F24",		FP_REG(24), RFLT, 'D'},
+	{"F25",		FP_REG(25), RFLT, 'D'},
+	{"F26",		FP_REG(26), RFLT, 'D'},
+	{"F27",		FP_REG(27), RFLT, 'D'},
+	{"F28",		FP_REG(28), RFLT, 'D'},
+	{"F29",		FP_REG(29), RFLT, 'D'},
+	{"F30",		FP_REG(30), RFLT, 'D'},
+	{"F31",		FP_REG(31), RFLT, 'D'},
+	{"FPSCR",	FP_REG(32)+4, RFLT, 'X'},
+	{  0 }
+};
+
+	/* the machine description */
+Mach mpower =
+{
+	"power",
+	MPOWER,		/* machine type */
+	powerreglist,	/* register set */
+	REGSIZE,	/* register set size in bytes */
+	FPREGSIZE,	/* floating point register size in bytes */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"LR",		/* name of link register */
+	"setSB",	/* static base register name */
+	0,		/* value */
+	0x1000,		/* page size */
+	0x20000000,	/* kernel base */
+	0,		/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/qdb.c b/utils/libmach/qdb.c
new file mode 100644
index 00000000..f2aa682a
--- /dev/null
+++ b/utils/libmach/qdb.c
@@ -0,0 +1,1270 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+/*
+ * PowerPC-specific debugger interface
+ *	forsyth@terzarima.net
+ */
+
+static	char	*powerexcep(Map*, Rgetter);
+static	int	powerfoll(Map*, ulong, Rgetter, ulong*);
+static	int	powerinst(Map*, ulong, char, char*, int);
+static	int	powerinstlen(Map*, ulong);
+static	int	powerdas(Map*, ulong, char*, int);
+
+/*
+ *	Machine description
+ */
+Machdata powermach =
+{
+	{0x07f, 0xe0, 0x00, 0x08},		/* breakpoint (tw 31,r0,r0) */
+	4,			/* break point size */
+
+	beswab,			/* convert short to local byte order */
+	beswal,			/* convert long to local byte order */
+	beswav,			/* vlong to local byte order */
+	risctrace,		/* print C traceback */
+	riscframe,		/* frame finder */
+	powerexcep,		/* print exception */
+	0,			/* breakpoint fixup */
+	beieeesftos,		/* single precision float printer */
+	beieeedftos,		/* double precisioin float printer */
+	powerfoll,		/* following addresses */
+	powerinst,		/* print instruction */
+	powerdas,		/* dissembler */
+	powerinstlen,		/* instruction size */
+};
+
+static char *excname[] =
+{
+	"reserved 0",
+	"system reset",
+	"machine check",
+	"data access",
+	"instruction access",
+	"external interrupt",
+	"alignment",
+	"program exception",
+	"floating-point unavailable",
+	"decrementer",
+	"i/o controller interface error",
+	"reserved B",
+	"system call",
+	"trace trap",
+	"floating point assist",
+	"reserved",
+	"ITLB miss",
+	"DTLB load miss",
+	"DTLB store miss",
+	"instruction address breakpoint"
+	"SMI interrupt"
+	"reserved 15",
+	"reserved 16",
+	"reserved 17",
+	"reserved 18",
+	"reserved 19",
+	"reserved 1A",
+	/* the following are made up on a program exception */
+	"floating point exception",		/* 1B: FPEXC */
+	"illegal instruction",	/* 1C */
+	"privileged instruction",	/* 1D */
+	"trap",	/* 1E */
+	"illegal operation",	/* 1F */
+	"breakpoint",	/* 20 */
+};
+
+static char*
+powerexcep(Map *map, Rgetter rget)
+{
+	long c;
+	static char buf[32];
+
+	c = (*rget)(map, "CAUSE") >> 8;
+	if(c < nelem(excname))
+		return excname[c];
+	sprint(buf, "unknown trap #%lx", c);
+	return buf;
+}
+
+/*
+ * disassemble PowerPC opcodes
+ */
+
+#define	REGSP	1	/* should come from q.out.h, but there's a clash */
+#define	REGSB	2
+
+static	char FRAMENAME[] = ".frame";
+
+static Map *mymap;
+
+/*
+ * ibm conventions for these: bit 0 is top bit
+ *	from table 10-1
+ */
+typedef struct {
+	uchar	aa;		/* bit 30 */
+	uchar	crba;		/* bits 11-15 */
+	uchar	crbb;		/* bits 16-20 */
+	long	bd;		/* bits 16-29 */
+	uchar	crfd;		/* bits 6-8 */
+	uchar	crfs;		/* bits 11-13 */
+	uchar	bi;		/* bits 11-15 */
+	uchar	bo;		/* bits 6-10 */
+	uchar	crbd;		/* bits 6-10 */
+	/*union {*/
+		short	d;	/* bits 16-31 */
+		short	simm;
+		ushort	uimm;
+	/*};*/
+	uchar	fm;		/* bits 7-14 */
+	uchar	fra;		/* bits 11-15 */
+	uchar	frb;		/* bits 16-20 */
+	uchar	frc;		/* bits 21-25 */
+	uchar	frs;		/* bits 6-10 */
+	uchar	frd;		/* bits 6-10 */
+	uchar	crm;		/* bits 12-19 */
+	long	li;		/* bits 6-29 || b'00' */
+	uchar	lk;		/* bit 31 */
+	uchar	mb;		/* bits 21-25 */
+	uchar	me;		/* bits 26-30 */
+	uchar	nb;		/* bits 16-20 */
+	uchar	op;		/* bits 0-5 */
+	uchar	oe;		/* bit 21 */
+	uchar	ra;		/* bits 11-15 */
+	uchar	rb;		/* bits 16-20 */
+	uchar	rc;		/* bit 31 */
+	/* union {*/
+		uchar	rs;	/* bits 6-10 */
+		uchar	rd;
+	/*};*/
+	uchar	sh;		/* bits 16-20 */
+	ushort	spr;		/* bits 11-20 */
+	uchar	to;		/* bits 6-10 */
+	uchar	imm;		/* bits 16-19 */
+	ushort	xo;		/* bits 21-30, 22-30, 26-30, or 30 (beware) */
+	long	immediate;
+	long w0;
+	long w1;
+	ulong	addr;		/* pc of instruction */
+	short	target;
+	char	*curr;		/* current fill level in output buffer */
+	char	*end;		/* end of buffer */
+	int 	size;		/* number of longs in instr */
+	char	*err;		/* errmsg */
+} Instr;
+
+#define	IBF(v,a,b) (((ulong)(v)>>(32-(b)-1)) & ~(~0L<<(((b)-(a)+1))))
+#define	IB(v,b) IBF((v),(b),(b))
+
+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);
+}
+
+static int
+decode(ulong pc, Instr *i)
+{
+	long w;
+
+	if (get4(mymap, pc, &w) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	i->aa = IB(w, 30);
+	i->crba = IBF(w, 11, 15);
+	i->crbb = IBF(w, 16, 20);
+	i->bd = IBF(w, 16, 29)<<2;
+	if(i->bd & 0x8000)
+		i->bd |= ~0L<<16;
+	i->crfd = IBF(w, 6, 8);
+	i->crfs = IBF(w, 11, 13);
+	i->bi = IBF(w, 11, 15);
+	i->bo = IBF(w, 6, 10);
+	i->crbd = IBF(w, 6, 10);
+	i->uimm = IBF(w, 16, 31);	/* also d, simm */
+	i->simm = i->uimm;
+	i->d = i->uimm;
+	i->fm = IBF(w, 7, 14);
+	i->fra = IBF(w, 11, 15);
+	i->frb = IBF(w, 16, 20);
+	i->frc = IBF(w, 21, 25);
+	i->frs = IBF(w, 6, 10);
+	i->frd = IBF(w, 6, 10);
+	i->crm = IBF(w, 12, 19);
+	i->li = IBF(w, 6, 29)<<2;
+	if(IB(w, 6))
+		i->li |= ~0<<25;
+	i->lk = IB(w, 31);
+	i->mb = IBF(w, 21, 25);
+	i->me = IBF(w, 26, 30);
+	i->nb = IBF(w, 16, 20);
+	i->op = IBF(w, 0, 5);
+	i->oe = IB(w, 21);
+	i->ra = IBF(w, 11, 15);
+	i->rb = IBF(w, 16, 20);
+	i->rc = IB(w, 31);
+	i->rs = IBF(w, 6, 10);	/* also rd */
+	i->rd = i->rs;
+	i->sh = IBF(w, 16, 20);
+	i->spr = IBF(w, 11, 20);
+	i->to = IBF(w, 6, 10);
+	i->imm = IBF(w, 16, 19);
+	i->xo = IBF(w, 21, 30);		/* bits 21-30, 22-30, 26-30, or 30 (beware) */
+	i->immediate = i->simm;
+	if(i->op == 15)
+		i->immediate <<= 16;
+	i->w0 = w;
+	i->target = -1;
+	i->addr = pc;
+	i->size = 1;
+	return 1;
+}
+
+static int
+mkinstr(ulong pc, Instr *i)
+{
+	Instr x;
+
+	if(decode(pc, i) < 0)
+		return -1;
+	/*
+	 * combine ADDIS/ORI (CAU/ORIL) into MOVW
+	 */
+	if (i->op == 15 && i->ra==0) {
+		if(decode(pc+4, &x) < 0)
+			return -1;
+		if (x.op == 24 && x.rs == x.ra && x.ra == i->rd) {
+			i->immediate |= (x.immediate & 0xFFFF);
+			i->w1 = x.w0;
+			i->target = x.rd;
+			i->size++;
+			return 1;
+		}
+	}
+	if (i->op == 15 && i->ra==REGSB && mach->sb) {
+		if(decode(pc+4, &x) < 0)
+			return -1;
+		if (x.op >= 32 && x.op < 54 && i->rd == x.ra) {
+			i->op = x.op;
+			i->ra = REGSB;
+			i->rs = i->rd = x.rd;
+			i->immediate += x.simm;
+			i->w1 = x.w0;
+			i->target = x.rd;
+			i->size++;
+			return 1;
+		}
+	}
+	return 1;
+}
+
+static int
+plocal(Instr *i)
+{
+	int offset;
+	Symbol s;
+
+	if (!findsym(i->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s))
+		return -1;
+	offset = s.value - i->immediate;
+	if (offset > 0) {
+		if(getauto(&s, offset, CAUTO, &s)) {
+			bprint(i, "%s+%d(SP)", s.name, s.value);
+			return 1;
+		}
+	} else {
+		if (getauto(&s, -offset-4, CPARAM, &s)) {
+			bprint(i, "%s+%d(FP)", s.name, -offset);
+			return 1;
+		}
+	}
+	return -1;
+}
+
+static int
+pglobal(Instr *i, long off, int anyoff, char *reg)
+{
+	Symbol s, s2;
+	long off1;
+
+	if(findsym(off, CANY, &s) &&
+	   strcmp(s.name, ".string") != 0 &&
+	   (ulong)(off-s.value) < 4096 &&
+	   (s.class == CDATA || s.class == CTEXT)) {
+		if(off==s.value && s.name[0]=='$'){
+			off1 = 0;
+			get4(mymap, s.value, &off1);
+			if(off1 && findsym(off1, CANY, &s2) && s2.value == off1){
+				bprint(i, "$%s%s", s2.name, reg);
+				return 1;
+			}
+		}
+		bprint(i, "%s", s.name);
+		if (s.value != off)
+			bprint(i, "+%lux", off-s.value);
+		bprint(i, reg);
+		return 1;
+	}
+	if(!anyoff)
+		return 0;
+	bprint(i, "%lux%s", off, reg);
+	return 1;
+}
+
+static void
+address(Instr *i)
+{
+	if (i->ra == REGSP && plocal(i) >= 0)
+		return;
+	if (i->ra == REGSB && mach->sb && pglobal(i, mach->sb+i->immediate, 0, "(SB)") > 0)
+		return;
+	if(i->immediate < 0)
+		bprint(i, "-%lx", -i->immediate);
+	else
+		bprint(i, "%lux", i->immediate);
+	if (i->ra == REGSB && mach->sb)
+		bprint(i, "(SB)");
+	else
+		bprint(i, "(R%d)", i->ra);
+}
+
+static	char	*tcrbits[] = {"LT", "GT", "EQ", "VS"};
+static	char	*fcrbits[] = {"GE", "LE", "NE", "VC"};
+
+typedef struct Opcode Opcode;
+
+struct Opcode {
+	uchar	op;
+	ushort	xo;
+	ushort	xomask;
+	char	*mnemonic;
+	void	(*f)(Opcode *, Instr *);
+	char	*ken;
+	int	flags;
+};
+
+static void format(char *, Instr *, char *);
+
+static void
+branch(Opcode *o, Instr *i)
+{
+	char buf[8];
+	int bo, bi;
+
+	bo = i->bo & ~1;	/* ignore prediction bit */
+	if(bo==4 || bo==12 || bo==20) {	/* simple forms */
+		if(bo != 20) {
+			bi = i->bi&3;
+			sprint(buf, "B%s%%L", bo==12? tcrbits[bi]: fcrbits[bi]);
+			format(buf, i, 0);
+			bprint(i, "\t");
+			if(i->bi > 4)
+				bprint(i, "CR(%d),", i->bi/4);
+		} else
+			format("BR%L\t", i, 0);
+		if(i->op == 16)
+			format(0, i, "%J");
+		else if(i->op == 19 && i->xo == 528)
+			format(0, i, "(CTR)");
+		else if(i->op == 19 && i->xo == 16)
+			format(0, i, "(LR)");
+	} else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+addi(Opcode *o, Instr *i)
+{
+	if (i->op==14 && i->ra == 0)
+		format("MOVW", i, "%i,R%d");
+	else if (i->ra == REGSP || i->ra == REGSB) {
+		bprint(i, "MOVW\t$");
+		address(i);
+		bprint(i, ",R%d", i->rd);
+	} else if(i->op==14 && i->simm < 0) {
+		bprint(i, "SUB\t$%d,R%d", -i->simm, i->ra);
+		if(i->rd != i->ra)
+			bprint(i, ",R%d", i->rd);
+	} else if(i->ra == i->rd) {
+		format(o->mnemonic, i, "%i");
+		bprint(i, ",R%d", i->rd);
+	} else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+addis(Opcode *o, Instr *i)
+{
+	long v;
+
+	v = i->immediate;
+	if (i->op==15 && i->ra == 0) {
+		bprint(i, "MOVW\t$");
+		pglobal(i, i->immediate, 1, "");
+		bprint(i, ",R%d", i->rd);
+	}
+	else if (i->op==15 && i->ra == REGSB && mach->sb) {
+		bprint(i, "MOVW\t$");
+		address(i);
+		bprint(i, ",R%d", i->rd);
+/* how about auto/param addresses? */
+	} else if(i->op==15 && v < 0) {
+		bprint(i, "SUB\t$%d,R%d", -v, i->ra);
+		if(i->rd != i->ra)
+			bprint(i, ",R%d", i->rd);
+	} else {
+		format(o->mnemonic, i, 0);
+		bprint(i, "\t$%ld,R%d", v, i->ra);
+		if(i->rd != i->ra)
+			bprint(i, ",R%d", i->rd);
+	}
+}
+
+static void
+andi(Opcode *o, Instr *i)
+{
+	if (i->ra == i->rs)
+		format(o->mnemonic, i, "%I,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+gencc(Opcode *o, Instr *i)
+{
+	format(o->mnemonic, i, o->ken);
+}
+
+static void
+gen(Opcode *o, Instr *i)
+{
+	format(o->mnemonic, i, o->ken);
+	if (i->rc)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+ldx(Opcode *o, Instr *i)
+{
+	if(i->ra == 0)
+		format(o->mnemonic, i, "(R%b),R%d");
+	else
+		format(o->mnemonic, i, "(R%b+R%a),R%d");
+	if(i->rc)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+stx(Opcode *o, Instr *i)
+{
+	if(i->ra == 0)
+		format(o->mnemonic, i, "R%d,(R%b)");
+	else
+		format(o->mnemonic, i, "R%d,(R%b+R%a)");
+	if(i->rc && i->xo != 150)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+fldx(Opcode *o, Instr *i)
+{
+	if(i->ra == 0)
+		format(o->mnemonic, i, "(R%b),F%d");
+	else
+		format(o->mnemonic, i, "(R%b+R%a),F%d");
+	if(i->rc)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+fstx(Opcode *o, Instr *i)
+{
+	if(i->ra == 0)
+		format(o->mnemonic, i, "F%d,(R%b)");
+	else
+		format(o->mnemonic, i, "F%d,(R%b+R%a)");
+	if(i->rc)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+dcb(Opcode *o, Instr *i)
+{
+	if(i->ra == 0)
+		format(o->mnemonic, i, "(R%b)");
+	else
+		format(o->mnemonic, i, "(R%b+R%a)");
+	if(i->rd)
+		bprint(i, " [illegal Rd]");
+	if(i->rc)
+		bprint(i, " [illegal Rc]");
+}
+
+static void
+lw(Opcode *o, Instr *i, char r)
+{
+	bprint(i, "%s\t", o->mnemonic);
+	address(i);
+	bprint(i, ",%c%d", r, i->rd);
+}
+
+static void
+load(Opcode *o, Instr *i)
+{
+	lw(o, i, 'R');
+}
+
+static void
+fload(Opcode *o, Instr *i)
+{
+	lw(o, i, 'F');
+}
+
+static void
+sw(Opcode *o, Instr *i, char r)
+{
+	int offset;
+	char *m;
+	Symbol s;
+
+	m = o->mnemonic;
+	if (i->ra == REGSP) {
+		if (findsym(i->addr, CTEXT, &s) && findlocal(&s, FRAMENAME, &s)) {
+			offset = s.value-i->immediate;
+			if (offset > 0 && getauto(&s, offset, CAUTO, &s)) {
+				bprint(i, "%s\t%c%d,%s-%d(SP)", m, r, i->rs,
+					s.name, offset);
+				return;
+			}
+		}
+	}
+	if (i->ra == REGSP || i->ra == REGSB && mach->sb) {
+		bprint(i, "%s\t%c%d,", m, r, i->rs);
+		address(i);
+		return;
+	}
+	if (r == 'F')
+		format(m, i, "F%d,%l");
+	else
+		format(m, i, o->ken);
+}
+
+static void
+store(Opcode *o, Instr *i)
+{
+	sw(o, i, 'R');
+}
+
+static void
+fstore(Opcode *o, Instr *i)
+{
+	sw(o, i, 'F');
+}
+
+static void
+shifti(Opcode *o, Instr *i)
+{
+	if (i->ra == i->rs)
+		format(o->mnemonic, i, "$%k,R%a");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+shift(Opcode *o, Instr *i)
+{
+	if (i->ra == i->rs)
+		format(o->mnemonic, i, "R%b,R%a");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+add(Opcode *o, Instr *i)
+{
+	if (i->rd == i->ra)
+		format(o->mnemonic, i, "R%b,R%d");
+	else if (i->rd == i->rb)
+		format(o->mnemonic, i, "R%a,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+sub(Opcode *o, Instr *i)
+{
+	format(o->mnemonic, i, 0);
+	if(i->op == 31) {
+		bprint(i, "\tR%d,R%d", i->ra, i->rb);	/* subtract Ra from Rb */
+		if(i->rd != i->rb)
+			bprint(i, ",R%d", i->rd);
+	} else
+		bprint(i, "\tR%d,$%d,R%d", i->ra, i->simm, i->rd);
+}
+
+static void
+qdiv(Opcode *o, Instr *i)
+{
+	format(o->mnemonic, i, 0);
+	if(i->op == 31)
+		bprint(i, "\tR%d,R%d", i->rb, i->ra);
+	else
+		bprint(i, "\t$%d,R%d", i->simm, i->ra);
+	if(i->ra != i->rd)
+		bprint(i, ",R%d", i->rd);
+}
+
+static void
+and(Opcode *o, Instr *i)
+{
+	if (i->op == 31) {
+		/* Rb,Rs,Ra */
+		if (i->ra == i->rs)
+			format(o->mnemonic, i, "R%b,R%a");
+		else if (i->ra == i->rb)
+			format(o->mnemonic, i, "R%s,R%a");
+		else
+			format(o->mnemonic, i, o->ken);
+	} else {
+		/* imm,Rs,Ra */
+		if (i->ra == i->rs)
+			format(o->mnemonic, i, "%I,R%a");
+		else
+			format(o->mnemonic, i, o->ken);
+	}
+}
+
+static void
+or(Opcode *o, Instr *i)
+{
+	if (i->op == 31) {
+		/* Rb,Rs,Ra */
+		if (i->rs == 0 && i->ra == 0 && i->rb == 0)
+			format("NOP", i, 0);
+		else if (i->rs == i->rb)
+			format("MOVW", i, "R%b,R%a");
+		else
+			and(o, i);
+	} else
+		and(o, i);
+}
+
+static void
+shifted(Opcode *o, Instr *i)
+{
+	format(o->mnemonic, i, 0);
+	bprint(i, "\t$%lux,", (ulong)i->uimm<<16);
+	if (i->rs == i->ra)
+		bprint(i, "R%d", i->ra);
+	else
+		bprint(i, "R%d,R%d", i->rs, i->ra);
+}
+
+static void
+neg(Opcode *o, Instr *i)
+{
+	if (i->rd == i->ra)
+		format(o->mnemonic, i, "R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static	char	ir2[] = "R%a,R%d";		/* reverse of IBM order */
+static	char	ir3[] = "R%b,R%a,R%d";
+static	char	ir3r[] = "R%a,R%b,R%d";
+static	char	il3[] = "R%b,R%s,R%a";
+static	char	il2u[] = "%I,R%s,R%a";
+static	char	il3s[] = "$%k,R%s,R%a";
+static	char	il2[] = "R%s,R%a";
+static	char	icmp3[] = "R%a,R%b,%D";
+static	char	cr3op[] = "%b,%a,%d";
+static	char	ir2i[] = "%i,R%a,R%d";
+static	char	fp2[] = "F%b,F%d";
+static	char	fp3[] = "F%b,F%a,F%d";
+static	char	fp3c[] = "F%c,F%a,F%d";
+static	char	fp4[] = "F%a,F%c,F%b,F%d";
+static	char	fpcmp[] = "F%a,F%b,%D";
+static	char	ldop[] = "%l,R%d";
+static	char	stop[] = "R%d,%l";
+static	char	fldop[] = "%l,F%d";
+static	char	fstop[] = "F%d,%l";
+static	char	rlim[] = "R%b,R%s,$%z,R%a";
+static	char	rlimi[] = "$%k,R%s,$%z,R%a";
+
+#define	OEM	IBF(~0,22,30)
+#define	FP4	IBF(~0,26,30)
+#define	ALL	((ushort)~0)
+/*
+notes:
+	10-26: crfD = rD>>2; rD&3 mbz
+		also, L bit (bit 10) mbz or selects 64-bit operands
+*/
+
+static Opcode opcodes[] = {
+	{31,	360,	OEM,	"ABS%V%C",	0,	ir2},	/* POWER */
+
+	{31,	266,	OEM,	"ADD%V%C",	add,	ir3},
+	{31,	 10,	OEM,	"ADDC%V%C",	add,	ir3},
+	{31,	138,	OEM,	"ADDE%V%C",	add,	ir3},
+	{14,	0,	0,	"ADD",		addi,	ir2i},
+	{12,	0,	0,	"ADDC",		addi,	ir2i},
+	{13,	0,	0,	"ADDCCC",	addi,	ir2i},
+	{15,	0,	0,	"ADD",		addis,	0},
+	{31,	234,	OEM,	"ADDME%V%C",	gencc,	ir2},
+	{31,	202,	OEM,	"ADDZE%V%C",	gencc,	ir2},
+
+	{31,	28,	ALL,	"AND%C",	and,	il3},
+	{31,	60,	ALL,	"ANDN%C",	and,	il3},
+	{28,	0,	0,	"ANDCC",		andi,	il2u},
+	{29,	0,	0,	"ANDCC",		shifted, 0},
+
+	{18,	0,	0,	"B%L",		gencc,	"%j"},
+	{16,	0,	0,	"BC%L",		branch,	"%d,%a,%J"},
+	{19,	528,	ALL,	"BC%L",		branch,	"%d,%a,(CTR)"},
+	{19,	16,	ALL,	"BC%L",		branch,	"%d,%a,(LR)"},
+
+	{31,	531,	ALL,	"CLCS",		gen,	ir2},	/* POWER */
+
+	{31,	0,	ALL,	"CMP",		0,	icmp3},
+	{11,	0,	0,	"CMP",		0,	"R%a,%i,%D"},
+	{31,	32,	ALL,	"CMPU",		0,	icmp3},
+	{10,	0,	0,	"CMPU",		0,	"R%a,%I,%D"},
+
+	{31,	26,	ALL,	"CNTLZ%C",	gencc,	ir2},
+
+	{19,	257,	ALL,	"CRAND",	gen,	cr3op},
+	{19,	129,	ALL,	"CRANDN",	gen,	cr3op},
+	{19,	289,	ALL,	"CREQV",	gen,	cr3op},
+	{19,	225,	ALL,	"CRNAND",	gen,	cr3op},
+	{19,	33,	ALL,	"CRNOR",	gen,	cr3op},
+	{19,	449,	ALL,	"CROR",		gen,	cr3op},
+	{19,	417,	ALL,	"CRORN",	gen,	cr3op},
+	{19,	193,	ALL,	"CRXOR",	gen,	cr3op},
+
+	{31,	86,	ALL,	"DCBF",		dcb,	0},
+	{31,	470,	ALL,	"DCBI",		dcb,	0},
+	{31,	54,	ALL,	"DCBST",	dcb,	0},
+	{31,	278,	ALL,	"DCBT",		dcb,	0},
+	{31,	246,	ALL,	"DCBTST",	dcb,	0},
+	{31,	1014,	ALL,	"DCBZ",		dcb,	0},
+
+	{31,	331,	OEM,	"DIV%V%C",	qdiv,	ir3},	/* POWER */
+	{31,	363,	OEM,	"DIVS%V%C",	qdiv,	ir3},	/* POWER */
+	{31,	491,	OEM,	"DIVW%V%C",	qdiv,	ir3},
+	{31,	459,	OEM,	"DIVWU%V%C",	qdiv,	ir3},
+
+	{31,	264,	OEM,	"DOZ%V%C",	gencc,	ir3r},	/* POWER */
+	{9,	0,	0,	"DOZ",		gen,	ir2i},	/* POWER */
+
+	{31,	310,	ALL,	"ECIWX",	ldx,	0},
+	{31,	438,	ALL,	"ECOWX",	stx,	0},
+	{31,	854,	ALL,	"EIEIO",	gen,	0},
+
+	{31,	284,	ALL,	"EQV%C",	gencc,	il3},
+
+	{31,	954,	ALL,	"EXTSB%C",	gencc,	il2},
+	{31,	922,	ALL,	"EXTSH%C",	gencc,	il2},
+
+	{63,	264,	ALL,	"FABS%C",	gencc,	fp2},
+	{63,	21,	ALL,	"FADD%C",	gencc,	fp3},
+	{59,	21,	ALL,	"FADDS%C",	gencc,	fp3},
+	{63,	32,	ALL,	"FCMPO",	gen,	fpcmp},
+	{63,	0,	ALL,	"FCMPU",	gen,	fpcmp},
+	{63,	14,	ALL,	"FCTIW%C",	gencc,	fp2},
+	{63,	15,	ALL,	"FCTIWZ%C",	gencc,	fp2},
+	{63,	18,	ALL,	"FDIV%C",	gencc,	fp3},
+	{59,	18,	ALL,	"FDIVS%C",	gencc,	fp3},
+	{63,	29,	FP4,	"FMADD%C",	gencc,	fp4},
+	{59,	29,	FP4,	"FMADDS%C",	gencc,	fp4},
+	{63,	72,	ALL,	"FMOVD%C",	gencc,	fp2},
+	{63,	28,	FP4,	"FMSUB%C",	gencc,	fp4},
+	{59,	28,	FP4,	"FMSUBS%C",	gencc,	fp4},
+	{63,	25,	FP4,	"FMUL%C",	gencc,	fp3c},
+	{59,	25,	FP4,	"FMULS%C",	gencc,	fp3c},
+	{63,	136,	ALL,	"FNABS%C",	gencc,	fp2},
+	{63,	40,	ALL,	"FNEG%C",	gencc,	fp2},
+	{63,	31,	FP4,	"FNMADD%C",	gencc,	fp4},
+	{59,	31,	FP4,	"FNMADDS%C",	gencc,	fp4},
+	{63,	30,	FP4,	"FNMSUB%C",	gencc,	fp4},
+	{59,	30,	FP4,	"FNMSUBS%C",	gencc,	fp4},
+	{63,	12,	ALL,	"FRSP%C",	gencc,	fp2},
+	{63,	20,	FP4,	"FSUB%C",	gencc,	fp3},
+	{59,	20,	FP4,	"FSUBS%C",	gencc,	fp3},
+
+	{31,	982,	ALL,	"ICBI",		dcb,	0},
+	{19,	150,	ALL,	"ISYNC",	gen,	0},
+
+	{34,	0,	0,	"MOVBZ",	load,	ldop},
+	{35,	0,	0,	"MOVBZU",	load,	ldop},
+	{31,	119,	ALL,	"MOVBZU",	ldx,	0},
+	{31,	87,	ALL,	"MOVBZ",	ldx,	0},
+	{50,	0,	0,	"FMOVD",	fload,	fldop},
+	{51,	0,	0,	"FMOVDU",	fload,	fldop},
+	{31,	631,	ALL,	"FMOVDU",	fldx,	0},
+	{31,	599,	ALL,	"FMOVD",	fldx,	0},
+	{48,	0,	0,	"FMOVS",	load,	fldop},
+	{49,	0,	0,	"FMOVSU",	load,	fldop},
+	{31,	567,	ALL,	"FMOVSU",	fldx,	0},
+	{31,	535,	ALL,	"FMOVS",	fldx,	0},
+	{42,	0,	0,	"MOVH",		load,	ldop},
+	{43,	0,	0,	"MOVHU",	load,	ldop},
+	{31,	375,	ALL,	"MOVHU",	ldx,	0},
+	{31,	343,	ALL,	"MOVH",		ldx,	0},
+	{31,	790,	ALL,	"MOVHBR",	ldx,	0},
+	{40,	0,	0,	"MOVHZ",	load,	ldop},
+	{41,	0,	0,	"MOVHZU",	load,	ldop},
+	{31,	311,	ALL,	"MOVHZU",	ldx,	0},
+	{31,	279,	ALL,	"MOVHZ",	ldx,	0},
+	{46,	0,	0,	"MOVMW",	load,	ldop},
+	{31,	277,	ALL,	"LSCBX%C",	ldx,	0},	/* POWER */
+	{31,	597,	ALL,	"LSW",		gen,	"(R%a),$%n,R%d"},
+	{31,	533,	ALL,	"LSW",		ldx,	0},
+	{31,	20,	ALL,	"LWAR",		ldx,	0},
+	{31,	534,	ALL,	"MOVWBR",	ldx,	0},
+	{32,	0,	0,	"MOVW",		load,	ldop},
+	{33,	0,	0,	"MOVWU",	load,	ldop},
+	{31,	55,	ALL,	"MOVWU",	ldx,	0},
+	{31,	23,	ALL,	"MOVW",		ldx,	0},
+
+	{31,	29,	ALL,	"MASKG%C",	gencc,	"R%s:R%b,R%d"},	/* POWER */
+	{31,	541,	ALL,	"MASKIR%C",	gencc,	"R%s,R%b,R%a"},	/* POWER */
+
+	{19,	0,	ALL,	"MOVFL",	gen,	"%S,%D"},
+	{63,	64,	ALL,	"MOVCRFS",	gen,	"%S,%D"},
+	{31,	512,	ALL,	"MOVW",		gen,	"XER,%D"},
+	{31,	19,	ALL,	"MOVW",		gen,	"CR,R%d"},
+
+	{63,	583,	ALL,	"MOVW%C",	gen,	"FPSCR, F%d"},	/* mffs */
+	{31,	83,	ALL,	"MOVW",		gen,	"MSR,R%d"},
+	{31,	339,	ALL,	"MOVW",		gen,	"%P,R%d"},
+	{31,	595,	ALL,	"MOVW",		gen,	"SEG(%a),R%d"},
+	{31,	659,	ALL,	"MOVW",		gen,	"SEG(R%b),R%d"},
+	{31,	144,	ALL,	"MOVFL",	gen,	"R%s,%m,CR"},
+	{63,	70,	ALL,	"MTFSB0%C",	gencc,	"%D"},
+	{63,	38,	ALL,	"MTFSB1%C",	gencc,	"%D"},
+	{63,	711,	ALL,	"MOVFL%C",	gencc,	"F%b,%M,FPSCR"},	/* mtfsf */
+	{63,	134,	ALL,	"MOVFL%C",	gencc,	"%K,%D"},
+	{31,	146,	ALL,	"MOVW",		gen,	"R%s,MSR"},
+	{31,	467,	ALL,	"MOVW",		gen,	"R%s,%P"},
+	{31,	210,	ALL,	"MOVW",		gen,	"R%s,SEG(%a)"},
+	{31,	242,	ALL,	"MOVW",		gen,	"R%s,SEG(R%b)"},
+
+	{31,	107,	OEM,	"MUL%V%C",	gencc,	ir3},	/* POWER */
+	{31,	75,	ALL,	"MULHW%C",	gencc,	ir3},	/* POWER */
+	{31,	11,	ALL,	"MULHWU%C",	gencc,	ir3},	/* POWER */
+
+	{31,	235,	OEM,	"MULLW%V%C",	gencc,	ir3},
+	{7,	0,	0,	"MULLW",	qdiv,	"%i,R%a,R%d"},
+
+	{31,	488,	OEM,	"NABS%V%C",	neg,	ir2},	/* POWER */
+
+	{31,	476,	ALL,	"NAND%C",	gencc,	il3},
+	{31,	104,	OEM,	"NEG%V%C",	neg,	ir2},
+	{31,	124,	ALL,	"NOR%C",	gencc,	il3},
+	{31,	444,	ALL,	"OR%C",	or,	il3},
+	{31,	412,	ALL,	"ORN%C",	or,	il3},
+	{24,	0,	0,	"OR",		and,	"%I,R%d,R%a"},
+	{25,	0,	0,	"OR",		shifted, 0},
+
+	{19,	50,	ALL,	"RFI",		gen,	0},
+
+	{22,	0,	0,	"RLMI%C",	gencc,	rlim},	/* POWER */
+	{20,	0,	0,	"RLWMI%C",	gencc,	rlimi},
+	{21,	0,	0,	"RLWNM%C",	gencc,	rlimi},
+	{23,	0,	0,	"RLWNM%C",	gencc,	rlim},
+
+	{31,	537,	ALL,	"RRIB%C",	gencc,	il3},	/* POWER */
+
+	{17,	1,	ALL,	"SYSCALL",	gen,	0},
+
+	{31,	153,	ALL,	"SLE%C",	shift,	il3},	/* POWER */
+	{31,	217,	ALL,	"SLEQ%C",	shift,	il3},	/* POWER */
+	{31,	184,	ALL,	"SLQ%C",	shifti,	il3s},	/* POWER */
+	{31,	248,	ALL,	"SLLQ%C",	shifti,	il3s},	/* POWER */
+	{31,	216,	ALL,	"SLLQ%C",	shift,	il3},	/* POWER */
+	{31,	152,	ALL,	"SLQ%C",	shift,	il3},	/* POWER */
+
+	{31,	24,	ALL,	"SLW%C",	shift,	il3},
+
+	{31,	920,	ALL,	"SRAQ%C",	shift,	il3},	/* POWER */
+	{31,	952,	ALL,	"SRAQ%C",	shifti,	il3s},	/* POWER */
+
+	{31,	792,	ALL,	"SRAW%C",	shift,	il3},
+	{31,	824,	ALL,	"SRAW%C",	shifti,	il3s},
+
+	{31,	665,	ALL,	"SRE%C",	shift,	il3},	/* POWER */
+	{31,	921,	ALL,	"SREA%C",	shift,	il3},	/* POWER */
+	{31,	729,	ALL,	"SREQ%C",	shift,	il3},	/* POWER */
+	{31,	696,	ALL,	"SRQ%C",	shifti,	il3s},	/* POWER */
+	{31,	760,	ALL,	"SRLQ%C",	shifti,	il3s},	/* POWER */
+	{31,	728,	ALL,	"SRLQ%C",	shift,	il3},	/* POWER */
+	{31,	664,	ALL,	"SRQ%C",	shift,	il3},	/* POWER */
+
+	{31,	536,	ALL,	"SRW%C",	shift,	il3},
+
+	{38,	0,	0,	"MOVB",		store,	stop},
+	{39,	0,	0,	"MOVBU",	store,	stop},
+	{31,	247,	ALL,	"MOVBU",	stx,	0},
+	{31,	215,	ALL,	"MOVB",		stx,	0},
+	{54,	0,	0,	"FMOVD",	fstore,	fstop},
+	{55,	0,	0,	"FMOVDU",	fstore,	fstop},
+	{31,	759,	ALL,	"FMOVDU",	fstx,	0},
+	{31,	727,	ALL,	"FMOVD",	fstx,	0},
+	{52,	0,	0,	"FMOVS",	fstore,	fstop},
+	{53,	0,	0,	"FMOVSU",	fstore,	fstop},
+	{31,	695,	ALL,	"FMOVSU",	fstx,	0},
+	{31,	663,	ALL,	"FMOVS",	fstx,	0},
+	{44,	0,	0,	"MOVH",		store,	stop},
+	{31,	918,	ALL,	"MOVHBR",	stx,	0},
+	{45,	0,	0,	"MOVHU",	store,	stop},
+	{31,	439,	ALL,	"MOVHU",	stx,	0},
+	{31,	407,	ALL,	"MOVH",		stx,	0},
+	{47,	0,	0,	"MOVMW",	store,	stop},
+	{31,	725,	ALL,	"STSW",		gen,	"R%d,$%n,(R%a)"},
+	{31,	661,	ALL,	"STSW",		stx,	0},
+	{36,	0,	0,	"MOVW",		store,	stop},
+	{31,	662,	ALL,	"MOVWBR",	stx,	0},
+	{31,	150,	ALL,	"STWCCC",	stx,	0},
+	{37,	0,	0,	"MOVWU",	store,	stop},
+	{31,	183,	ALL,	"MOVWU",	stx,	0},
+	{31,	151,	ALL,	"MOVW",		stx,	0},
+
+	{31,	40,	OEM,	"SUB%V%C",	sub,	ir3},
+	{31,	8,	OEM,	"SUBC%V%C",	sub,	ir3},
+	{31,	136,	OEM,	"SUBE%V%C",	sub,	ir3},
+	{8,	0,	0,	"SUBC",		gen,	"R%a,%i,R%d"},
+	{31,	232,	OEM,	"SUBME%V%C",	sub,	ir2},
+	{31,	200,	OEM,	"SUBZE%V%C",	sub,	ir2},
+
+	{31,	598,	ALL,	"SYNC",		gen,	0},
+	{31,	306,	ALL,	"TLBIE",	gen,	"R%b"},
+	{31,	370,	ALL,	"TLBIA",	gen,	0},
+	{31,	1010,	ALL,	"TLBLI",	gen,	"R%b"},
+	{31,	978,	ALL,	"TLBLD",	gen,	"R%b"},
+	{31,	4,	ALL,	"TW",		gen,	"%d,R%a,R%b"},
+	{3,	0,	0,	"TW",		gen,	"%d,R%a,%i"},
+
+	{31,	316,	ALL,	"XOR",		and,	il3},
+	{26,	0,	0,	"XOR",		and,	il2u},
+	{27,	0,	0,	"XOR",		shifted, 0},
+
+	{0},
+};
+
+typedef struct Spr Spr;
+struct Spr {
+	int	n;
+	char	*name;
+};
+
+static	Spr	sprname[] = {
+	{0, "MQ"},
+	{1, "XER"},
+	{268, "TBL"},
+	{269, "TBU"},
+	{8, "LR"},
+	{9, "CTR"},
+	{528, "IBAT0U"},
+	{529, "IBAT0L"},
+	{530, "IBAT1U"},
+	{531, "IBAT1L"},
+	{532, "IBAT2U"},
+	{533, "IBAT2L"},
+	{534, "IBAT3U"},
+	{535, "IBAT3L"},
+	{536, "DBAT0U"},
+	{537, "DBAT0L"},
+	{538, "DBAT1U"},
+	{539, "DBAT1L"},
+	{540, "DBAT2U"},
+	{541, "DBAT2L"},
+	{542, "DBAT3U"},
+	{543, "DBAT3L"},
+	{25, "SDR1"},
+	{19, "DAR"},
+	{272, "SPRG0"},
+	{273, "SPRG1"},
+	{274, "SPRG2"},
+	{275, "SPRG3"},
+	{18, "DSISR"},
+	{26, "SRR0"},
+	{27, "SRR1"},
+	{284, "TBLW"},
+	{285, "TBUW"},	
+	{22, "DEC"},
+	{282, "EAR"},
+	{1008, "HID0"},
+	{1009, "HID1"},
+	{976, "DMISS"},
+	{977, "DCMP"},
+	{978, "HASH1"},
+	{979, "HASH2"},
+	{980, "IMISS"},
+	{981, "ICMP"},
+	{982, "RPA"},
+	{1010, "IABR"},
+	{1013, "DABR"},
+	{0,0},
+};
+
+static void
+format(char *mnemonic, Instr *i, char *f)
+{
+	int n, s;
+	ulong mask;
+
+	if (mnemonic)
+		format(0, i, mnemonic);
+	if (f == 0)
+		return;
+	if (mnemonic)
+		bprint(i, "\t");
+	for ( ; *f; f++) {
+		if (*f != '%') {
+			bprint(i, "%c", *f);
+			continue;
+		}
+		switch (*++f) {
+		case 'V':
+			if(i->oe)
+				bprint(i, "V");
+			break;
+
+		case 'C':
+			if(i->rc)
+				bprint(i, "CC");
+			break;
+
+		case 'a':
+			bprint(i, "%d", i->ra);
+			break;
+
+		case 'b':
+			bprint(i, "%d", i->rb);
+			break;
+
+		case 'c':
+			bprint(i, "%d", i->frc);
+			break;
+
+		case 'd':
+		case 's':
+			bprint(i, "%d", i->rd);
+			break;
+
+		case 'S':
+			if(i->ra & 3)
+				bprint(i, "CR(INVAL:%d)", i->ra);
+			else if(i->op == 63)
+				bprint(i, "FPSCR(%d)", i->crfs);
+			else
+				bprint(i, "CR(%d)", i->crfs);
+			break;
+
+		case 'D':
+			if(i->rd & 3)
+				bprint(i, "CR(INVAL:%d)", i->rd);
+			else if(i->op == 63)
+				bprint(i, "FPSCR(%d)", i->crfd);
+			else
+				bprint(i, "CR(%d)", i->crfd);
+			break;
+
+		case 'l':
+			address(i);
+			break;
+
+		case 'i':
+			bprint(i, "$%ld", i->simm);
+			break;
+
+		case 'I':
+			bprint(i, "$%lx", i->uimm);
+			break;
+
+		case 'w':
+			bprint(i, "[%lux]", i->w0);
+			break;
+
+		case 'P':
+			n = ((i->spr&0x1f)<<5)|((i->spr>>5)&0x1f);
+			for(s=0; sprname[s].name; s++)
+				if(sprname[s].n == n)
+					break;
+			if(sprname[s].name) {
+				if(n < 10)
+					bprint(i, sprname[s].name);
+				else
+					bprint(i, "SPR(%s)", sprname[s].name);
+			} else
+				bprint(i, "SPR(%d)", n);
+			break;
+
+		case 'n':
+			bprint(i, "%d", i->nb==0? 32: i->nb);	/* eg, pg 10-103 */
+			break;
+
+		case 'm':
+			bprint(i, "%lx", i->crm);
+			break;
+
+		case 'M':
+			bprint(i, "%lx", i->fm);
+			break;
+
+		case 'z':
+			if(i->mb <= i->me)
+				mask = ((ulong)~0L>>i->mb) & (~0L<<(31-i->me));
+			else
+				mask = ~(((ulong)~0L>>(i->me+1)) & (~0L<<(31-(i->mb-1))));
+			bprint(i, "%lux", mask);
+			break;
+
+		case 'k':
+			bprint(i, "%d", i->sh);
+			break;
+
+		case 'K':
+			bprint(i, "$%x", i->imm);
+			break;
+
+		case 'L':
+			if(i->lk)
+				bprint(i, "L");
+			break;
+
+		case 'j':
+			if(i->aa)
+				pglobal(i, i->li, 1, "(SB)");
+			else
+				pglobal(i, i->addr+i->li, 1, "");
+			break;
+
+		case 'J':
+			if(i->aa)
+				pglobal(i, i->bd, 1, "(SB)");
+			else
+				pglobal(i, i->addr+i->bd, 1, "");
+			break;
+
+		case '\0':
+			bprint(i, "%%");
+			return;
+
+		default:
+			bprint(i, "%%%c", *f);
+			break;
+		}
+	}
+}
+
+static int
+printins(Map *map, ulong pc, char *buf, int n)
+{
+	Instr i;
+	Opcode *o;
+
+	mymap = map;
+	memset(&i, 0, sizeof(i));
+	i.curr = buf;
+	i.end = buf+n-1;
+	if(mkinstr(pc, &i) < 0)
+		return -1;
+	for(o = opcodes; o->mnemonic != 0; o++)
+		if(i.op == o->op && (i.xo & o->xomask) == o->xo) {
+			if (o->f)
+				(*o->f)(o, &i);
+			else
+				format(o->mnemonic, &i, o->ken);
+			return i.size*4;
+		}
+	bprint(&i, "unknown %lux", i.w0);
+	return i.size*4;
+}
+
+static int
+powerinst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	USED(modifier);
+	return printins(map, pc, buf, n);
+}
+
+static int
+powerdas(Map *map, ulong pc, char *buf, int n)
+{
+	Instr instr;
+
+	mymap = map;
+	memset(&instr, 0, sizeof(instr));
+	instr.curr = buf;
+	instr.end = buf+n-1;
+	if (mkinstr(pc, &instr) < 0)
+		return -1;
+	if (instr.end-instr.curr > 8)
+		instr.curr = _hexify(instr.curr, instr.w0, 7);
+	if (instr.end-instr.curr > 9 && instr.size == 2) {
+		*instr.curr++ = ' ';
+		instr.curr = _hexify(instr.curr, instr.w1, 7);
+	}
+	*instr.curr = 0;
+	return instr.size*4;
+}
+
+static int
+powerinstlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	return i.size*4;
+}
+
+static int
+powerfoll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	char *reg;
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	foll[0] = pc+4;
+	foll[1] = pc+4;
+	switch(i.op) {
+	default:
+		return 1;
+
+	case 18:	/* branch */
+		foll[0] = i.li;
+		if(!i.aa)
+			foll[0] += pc;
+		break;
+			
+	case 16:	/* conditional branch */
+		foll[0] = i.bd;
+		if(!i.aa)
+			foll[0] += pc;
+		break;
+
+	case 19:	/* conditional branch to register */
+		if(i.xo == 528)
+			reg = "CTR";
+		else if(i.xo == 16)
+			reg = "LR";
+		else
+			return 1;	/* not a branch */
+		foll[0] = (*rget)(map, reg);
+		break;
+	}
+	if(i.lk)
+		return 2;
+	return 1;
+}
diff --git a/utils/libmach/qobj.c b/utils/libmach/qobj.c
new file mode 100644
index 00000000..5decad08
--- /dev/null
+++ b/utils/libmach/qobj.c
@@ -0,0 +1,134 @@
+/*
+ * qobj.c - identify and parse a PowerPC object file
+ *	forsyth@terzarima.net
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "qc/q.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	type;
+	char	sym;
+	char	name;
+};
+static Addr addr(Biobuf*);
+static char type2char(int);
+static void skip(Biobuf*, int);
+
+int
+_isq(char *s)
+{
+	return  (s[0]&0377) == ANAME				/* ANAME */
+		&& s[1] == D_FILE			/* type */
+		&& s[2] == 1				/* sym */
+		&& s[3] == '<';				/* name of file */
+}
+
+int
+_readq(Biobuf *bp, Prog *p)
+{
+	int as, n;
+	Addr a;
+
+	as = Bgetc(bp);			/* as */
+	if(as < 0)
+		return 0;
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	n = Bgetc(bp);	/* reg and flag */
+	skip(bp, 4);		/* lineno(4) */
+	a = addr(bp);
+	if(n & 0x40)
+		addr(bp);
+	addr(bp);
+	if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	long off;
+
+	a.type = Bgetc(bp);	/* a.type */
+	skip(bp,1);		/* reg */
+	a.sym = Bgetc(bp);	/* sym index */
+	a.name = Bgetc(bp);	/* sym type */
+	switch(a.type){
+	default:
+	case D_NONE: case D_REG: case D_FREG: case D_CREG:
+	case D_FPSCR: case D_MSR: case D_SREG:
+		break;
+	case D_SPR:
+	case D_OREG:
+	case D_CONST:
+	case D_BRANCH:
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+		if(a.sym && (a.name==D_PARAM || a.name==D_AUTO))
+			_offset(a.sym, off);
+		break;
+	case D_SCONST:
+		skip(bp, NSNAME);
+		break;
+	case D_FCONST:
+		skip(bp, 8);
+		break;
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/setmach.c b/utils/libmach/setmach.c
new file mode 100644
index 00000000..cdac45f6
--- /dev/null
+++ b/utils/libmach/setmach.c
@@ -0,0 +1,143 @@
+#include	<lib9.h>
+#include	<bio.h>
+#include	"mach.h"
+		/* table for selecting machine-dependent parameters */
+
+typedef	struct machtab Machtab;
+
+struct machtab
+{
+	char		*name;			/* machine name */
+	short		type;			/* executable type */
+	short		boottype;		/* bootable type */
+	int		asstype;		/* disassembler code */
+	Mach		*mach;			/* machine description */
+	Machdata	*machdata;		/* machine functions */
+};
+
+extern	Mach		mmips, msparc, m68020, mi386, marm, mmips2be, mmips2le, mpower;
+extern	Machdata	mipsmach, sparcmach, m68020mach, i386mach,
+			armmach, mipsmach2be, mipsmach2le, powermach;
+
+/*
+ *	machine selection table.  machines with native disassemblers should
+ *	follow the plan 9 variant in the table; native modes are selectable
+ *	only by name.
+ */
+Machtab	machines[] =
+{
+	{	"68020",			/*68020*/
+		F68020,
+		F68020B,
+		A68020,
+		&m68020,
+		&m68020mach,	},
+	{	"68020",			/*Next 68040 bootable*/
+		F68020,
+		FNEXTB,
+		A68020,
+		&m68020,
+		&m68020mach,	},
+	{	"mips2LE",			/*plan 9 mips2 little endian*/
+		FMIPS2LE,
+		0,
+		AMIPS,
+		&mmips2le,
+		&mipsmach2le, 	},
+	{	"mips",				/*plan 9 mips*/
+		FMIPS,
+		FMIPSB,
+		AMIPS,
+		&mmips,
+		&mipsmach, 	},
+	{	"mips2",			/*plan 9 mips2*/
+		FMIPS2BE,
+		FMIPSB,
+		AMIPS,
+		&mmips2be,
+		&mipsmach2be, 	},
+	{	"mipsco",			/*native mips - must follow plan 9*/
+		FMIPS,
+		FMIPSB,
+		AMIPSCO,
+		&mmips,
+		&mipsmach,	},
+	{	"sparc",			/*plan 9 sparc */
+		FSPARC,
+		FSPARCB,
+		ASPARC,
+		&msparc,
+		&sparcmach,	},
+	{	"sunsparc",			/*native sparc - must follow plan 9*/
+		FSPARC,
+		FSPARCB,
+		ASUNSPARC,
+		&msparc,
+		&sparcmach,	},
+	{	"386",				/*plan 9 386*/
+		FI386,
+		FI386B,
+		AI386,
+		&mi386,
+		&i386mach,	},
+	{	"86",				/*8086 - a peach of a machine*/
+		FI386,
+		FI386B,
+		AI8086,
+		&mi386,
+		&i386mach,	},
+	{	"arm",				/*ARM*/
+		FARM,
+		FNONE,
+		AARM,
+		&marm,
+		&armmach,	},
+	{	"power",			/*PowerPC*/
+		FPOWER,
+		FNONE,
+		APOWER,
+		&mpower,
+		&powermach,	},
+	{	0		},		/*the terminator*/
+};
+
+/*
+ *	select a machine by executable file type
+ */
+void
+machbytype(int type)
+{
+	Machtab *mp;
+
+	for (mp = machines; mp->name; mp++){
+		if (mp->type == type || mp->boottype == type) {
+			asstype = mp->asstype;
+			machdata = mp->machdata;
+			break;
+		}
+	}
+}
+/*
+ *	select a machine by name
+ */
+int
+machbyname(char *name)
+{
+	Machtab *mp;
+
+	if (!name) {
+		asstype = AMIPS;
+		machdata = &mipsmach;
+		mach = &mmips;
+		return 1;
+	}
+	for (mp = machines; mp->name; mp++){
+		if (strcmp(mp->name, name) == 0) {
+			asstype = mp->asstype;
+			machdata = mp->machdata;
+			mach = mp->mach;
+			return 1;
+		}
+	}
+	return 0;
+}
diff --git a/utils/libmach/swap.c b/utils/libmach/swap.c
new file mode 100644
index 00000000..3ca9cf27
--- /dev/null
+++ b/utils/libmach/swap.c
@@ -0,0 +1,79 @@
+#include <lib9.h>
+
+/*
+ * big-endian short
+ */
+ushort
+beswab(ushort s)
+{
+	uchar *p;
+
+	p = (uchar*)&s;
+	return (p[0]<<8) | p[1];
+}
+
+/*
+ * big-endian long
+ */
+long
+beswal(long l)
+{
+	uchar *p;
+
+	p = (uchar*)&l;
+	return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+
+/*
+ * big-endian vlong
+ */
+vlong
+beswav(vlong v)
+{
+	uchar *p;
+
+	p = (uchar*)&v;
+	return ((vlong)p[0]<<56) | ((vlong)p[1]<<48) | ((vlong)p[2]<<40)
+				 | ((vlong)p[3]<<32) | ((vlong)p[4]<<24)
+				 | ((vlong)p[5]<<16) | ((vlong)p[6]<<8)
+				 | (vlong)p[7];
+}
+
+/*
+ * little-endian short
+ */
+ushort
+leswab(ushort s)
+{
+	uchar *p;
+
+	p = (uchar*)&s;
+	return (p[1]<<8) | p[0];
+}
+
+/*
+ * little-endian long
+ */
+long
+leswal(long l)
+{
+	uchar *p;
+
+	p = (uchar*)&l;
+	return (p[3]<<24) | (p[2]<<16) | (p[1]<<8) | p[0];
+}
+
+/*
+ * little-endian vlong
+ */
+vlong
+leswav(vlong v)
+{
+	uchar *p;
+
+	p = (uchar*)&v;
+	return ((vlong)p[7]<<56) | ((vlong)p[6]<<48) | ((vlong)p[5]<<40)
+				 | ((vlong)p[4]<<32) | ((vlong)p[3]<<24)
+				 | ((vlong)p[2]<<16) | ((vlong)p[1]<<8)
+				 | (vlong)p[0];
+}
diff --git a/utils/libmach/sym.c b/utils/libmach/sym.c
new file mode 100644
index 00000000..6b62c555
--- /dev/null
+++ b/utils/libmach/sym.c
@@ -0,0 +1,1405 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+#define	HUGEINT	0x7fffffff
+#define	NNAME	20		/* a relic of the past */
+
+typedef	struct txtsym Txtsym;
+typedef	struct file File;
+typedef	struct hist Hist;
+typedef struct pcl Pcl;
+
+struct txtsym {				/* Text Symbol table */
+	int 	n;			/* number of local vars */
+	Sym	**locals;		/* array of ptrs to autos */
+	Sym	*sym;			/* function symbol entry */
+};
+
+struct hist {		/* Stack of include files & #line directives */
+	char	*name;			/* Assumes names Null terminated in file */
+	long	line;			/* line # where it was included */
+	long	offset;			/* line # of #line directive */
+};
+
+struct pcl {
+	uchar		*pcline;	/* start of pcline data for this file */
+	long		pc;		/* starting pc for pcline crunch */
+	long		line;		/* starting line for pcline crunch */
+};
+
+struct file {				/* Per input file header to history stack */
+	long		addr;		/* address of first text sym */
+	union {
+		Txtsym		*ftxt;	/* first text symbol */
+		Sym		*fsym;	/* only during initilization */
+	} u0;
+	int		n;		/* size of history stack */
+	Hist		*hist;		/* history stack */
+	Pcl		pcl;		/* pcline startup data */
+};
+
+static	int	debug = 0;
+
+static	Sym	**autos;		/* Base of auto variables */
+static	File	*files;			/* Base of file arena */
+static	int	fmax;			/* largest file path index */
+static	Sym	**fnames;		/* file names path component table */
+static	Sym	**globals;		/* globals by addr table */
+static	Hist	*hist;			/* base of history stack */
+static	int	isbuilt;		/* internal table init flag */
+static	long	nauto;			/* number of automatics */
+static	long	nfiles;			/* number of files */
+static	long	nglob;			/* number of globals */
+static	long	nhist;			/* number of history stack entries */
+static	long	nsym;			/* number of symbols */
+static	long	ntxt;			/* number of text symbols */
+static	uchar	*pcline;		/* start of pc-line state table */
+static	uchar 	*pclineend;		/* end of pc-line table */
+static	int	npcl;			/* number of files pcl-decoded so far */
+static	uchar	*spoff;			/* start of pc-sp state table */
+static	uchar	*spoffend;		/* end of pc-sp offset table */
+static	Sym	*symbols;		/* symbol table */
+static	Txtsym	*txt;			/* Base of text symbol table */
+static	long	txtstart;		/* start of text segment */
+static	long	txtend;			/* end of text segment */
+
+static void	cleansyms(void);
+static int	decodename(Biobuf*, Sym*);
+static short	*encfname(char*);
+static int 	fline(char*, int, long, Hist*, Hist**);
+static void	fillsym(Sym*, Symbol*);
+static int	findglobal(char*, Symbol*);
+static int	findlocvar(Symbol*, char *, Symbol*);
+static int	findtext(char*, Symbol*);
+static int	hcomp(Hist*, short*);
+static int	hline(File*, short*, ulong*);
+static void	printhist(char*, Hist*, int);
+static long	pcl2line(ulong, Pcl *, Pcl *);
+static long	pc2fline(ulong, File **);
+static int	pc2filex(ulong);
+static int	buildtbls(void);
+static int	symcomp(void*, void*);
+static int	symerrmsg(int, char*);
+static int	txtcomp(void*, void*);
+static int	filecomp(void*, void*);
+
+/*
+ *	initialize the symbol tables
+ */
+int
+syminit(int fd, Fhdr *fp)
+{
+	Sym *p;
+	int i, size;
+	Biobuf b;
+	extern void thumbpctab(Biobuf*, Fhdr*);
+
+	if(fp->symsz == 0)
+		return 0;
+	if(fp->type == FNONE)
+		return 0;
+
+	cleansyms();
+	textseg(fp->txtaddr, fp);
+		/* minimum symbol record size = 4+1+2 bytes */
+	symbols = malloc((fp->symsz/(4+1+2)+1)*sizeof(Sym));
+	if(symbols == 0) {
+		werrstr("can't malloc %ld bytes", fp->symsz);
+		return -1;
+	}
+
+	Binit(&b, fd, OREAD);
+	Bseek(&b, fp->symoff, 0);
+	nsym = 0;
+	size = 0;
+	for(p = symbols; size < fp->symsz; p++, nsym++) {
+		if(Bread(&b, &p->value, sizeof(p->value)) != sizeof(p->value))
+			return symerrmsg(sizeof(p->value), "symbol");
+		p->value = beswal(p->value);
+		if(Bread(&b, &p->type, sizeof(p->type)) != sizeof(p->type))
+			return symerrmsg(sizeof(p->value), "symbol");
+
+		i = decodename(&b, p);
+		if(i < 0)
+			return -1;
+		size += i+sizeof(p->value)+sizeof(p->type);
+
+		/* count global & auto vars, text symbols, and file names */
+		switch (p->type) {
+		case 'l':
+		case 'L':
+		case 't':
+		case 'T':
+			ntxt++;
+			break;
+		case 'd':
+		case 'D':
+		case 'b':
+		case 'B':
+			nglob++;
+			break;
+		case 'f':
+			if(strcmp(p->name, ".frame") == 0) {
+				p->type = 'm';
+				nauto++;
+			}
+			else if(p->value > fmax)
+				fmax = p->value;	/* highest path index */
+			break;
+		case 'a':
+		case 'p':
+		case 'm':
+			nauto++;
+			break;
+		case 'z':
+			if(p->value == 1) {		/* one extra per file */
+				nhist++;
+				nfiles++;
+			}
+			nhist++;
+			break;
+		default:
+			break;
+		}
+	}
+	if (debug)
+		fprint(2,"NG: %ld NT: %ld NF: %d\n", nglob, ntxt, fmax);
+	if (fp->sppcsz) {			/* pc-sp offset table */
+		spoff = (uchar *)malloc(fp->sppcsz);
+		if(spoff == 0) {
+			werrstr("can't malloc %ld bytes", fp->sppcsz);
+			return -1;
+		}
+		Bseek(&b, fp->sppcoff, 0);
+		i = Bread(&b, spoff, fp->sppcsz);
+		if(i != fp->sppcsz){
+			spoff = 0;
+			return symerrmsg(fp->sppcsz, "sp-pc");
+		}
+		spoffend = spoff+fp->sppcsz;
+	}
+	if (fp->lnpcsz) {			/* pc-line number table */
+		pcline = (uchar *)malloc(fp->lnpcsz);
+		if(pcline == 0) {
+			werrstr("can't malloc %ld bytes", fp->lnpcsz);
+			return -1;
+		}
+		Bseek(&b, fp->lnpcoff, 0);
+		i = Bread(&b, pcline, fp->lnpcsz);
+		if(i != fp->lnpcsz){
+			pcline = 0;
+			return symerrmsg(fp->lnpcsz, "pc-line");
+		}
+		pclineend = pcline+fp->lnpcsz;
+	}
+	if(fp->type == FARM)	/* thumb pc table */
+		thumbpctab(&b, fp);
+	return nsym;
+}
+
+static int
+symerrmsg(int n, char *table)
+{
+	werrstr("can't read %d bytes of %s table", n, table);
+	return -1;
+}
+
+static int
+decodename(Biobuf *bp, Sym *p)
+{
+	char *cp;
+	int c1, c2;
+	int n;
+
+	if((p->type & 0x80) == 0) {		/* old-style, fixed length names */
+		p->name = malloc(NNAME);
+		if(p->name == 0) {
+			werrstr("can't malloc %d bytes", NNAME);
+			return -1;
+		}
+		if(Bread(bp, p->name, NNAME) != NNAME)
+			return symerrmsg(NNAME, "symbol");
+		Bseek(bp, 3, 1);
+		return NNAME+3;
+	}
+
+	p->type &= ~0x80;
+	if(p->type == 'z' || p->type == 'Z') {
+		n = Bseek(bp, 0, 1);
+		if(Bgetc(bp) < 0) {
+			werrstr("can't read symbol name");
+			return -1;
+		}
+		for(;;) {
+			c1 = Bgetc(bp);
+			c2 = Bgetc(bp);
+			if(c1 < 0 || c2 < 0) {
+				werrstr("can't read symbol name");
+				return -1;
+			}
+			if(c1 == 0 && c2 == 0)
+				break;
+		}
+		n = Bseek(bp, 0, 1)-n;
+		p->name = malloc(n);
+		if(p->name == 0) {
+			werrstr("can't malloc %d bytes", n);
+			return -1;
+		}
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->name, n) != n) {
+			werrstr("can't read %d bytes of symbol name", n);
+			return -1;
+		}
+	} else {
+		cp = Brdline(bp, '\0');
+		if(cp == 0) {
+			werrstr("can't read symbol name");
+			return -1;
+		}
+		n = Blinelen(bp);
+		p->name = malloc(n);
+		if(p->name == 0) {
+			werrstr("can't malloc %d bytes", n);
+			return -1;
+		}
+		strcpy(p->name, cp);
+	}
+	return n;
+}
+/*
+ *	free any previously loaded symbol tables
+ */
+static void
+cleansyms(void)
+{
+	if(globals)
+		free(globals);
+	globals = 0;
+	nglob = 0;
+	if(txt)
+		free(txt);
+	txt = 0;
+	ntxt = 0;
+	if(fnames)
+		free(fnames);
+	fnames = 0;
+	fmax = 0;
+
+	if(files)
+		free(files);
+	files = 0;
+	nfiles = 0;
+	if(hist)
+		free(hist);
+	hist = 0;
+	nhist = 0;
+	if(autos)
+		free(autos);
+	autos = 0;
+	nauto = 0;
+	isbuilt = 0;
+	if(symbols)
+		free(symbols);
+	symbols = 0;
+	nsym = 0;
+	if(spoff)
+		free(spoff);
+	spoff = 0;
+	if(pcline)
+		free(pcline);
+	pcline = 0;
+	npcl = 0;
+}
+/*
+ *	delimit the text segment
+ */
+void
+textseg(ulong base, Fhdr *fp)
+{
+	txtstart = base;
+	txtend = base+fp->txtsz;
+	npcl = 0;	/* all pcls must be recomputed */
+}
+/*
+ *	symbase: return base and size of raw symbol table
+ *		(special hack for high access rate operations)
+ */
+Sym *
+symbase(long *n)
+{
+	*n = nsym;
+	return symbols;
+}
+/*
+ *	Get the ith symbol table entry
+ */
+Sym *
+getsym(int index)
+{
+	if(index < nsym)
+		return &symbols[index];
+	return 0;
+}
+
+/*
+ *	initialize internal symbol tables
+ */
+static int
+buildtbls(void)
+{
+	int i, j, nh, ng, nt;
+	File *f;
+	Txtsym *tp;
+	Hist *hp;
+	Sym *p, **ap;
+
+	if(isbuilt)
+		return 1;
+	isbuilt = 1;
+			/* allocate the tables */
+	if(nglob) {
+		globals = malloc(nglob*sizeof(*globals));
+		if(!globals) {
+			werrstr("can't malloc global symbol table");
+			return 0;
+		}
+	}
+	if(ntxt) {
+		txt = malloc(ntxt*sizeof(*txt));
+		if (!txt) {
+			werrstr("can't malloc text symbol table");
+			return 0;
+		}
+	}
+	fmax++;
+	fnames = malloc(fmax*sizeof(*fnames));
+	if (!fnames) {
+		werrstr("can't malloc file name table");
+		return 0;
+	}
+	memset(fnames, 0, fmax*sizeof(*fnames));
+	files = malloc(nfiles*sizeof(*files));
+	if(!files) {
+		werrstr("can't malloc file table");
+		return 0;
+	}
+	hist = malloc(nhist*sizeof(Hist));
+	if(hist == 0) {
+		werrstr("can't malloc history stack");
+		return 0;
+	}
+	autos = malloc(nauto*sizeof(Sym*));
+	if(autos == 0) {
+		werrstr("can't malloc auto symbol table");
+		return 0;
+	}
+		/* load the tables */
+	ng = nt = nh = 0;
+	f = 0;
+	tp = 0;
+	i = nsym;
+	hp = hist;
+	ap = autos;
+	for(p = symbols; i-- > 0; p++) {
+		switch(p->type) {
+		case 'D':
+		case 'd':
+		case 'B':
+		case 'b':
+			if(debug)
+				fprint(2,"Global: %s %lux\n", p->name, p->value);
+			globals[ng++] = p;
+			break;
+		case 'z':
+			if(p->value == 1) {		/* New file */
+				if(f) {
+					f->n = nh;
+					f->hist[nh].name = 0;	/* one extra */
+					hp += nh+1;
+					f++;
+				}
+				else f = files;
+				f->hist = hp;
+				f->u0.fsym = 0;
+				f->addr = 0;
+				nh = 0;
+			}
+				/* alloc one slot extra as terminator */
+			f->hist[nh].name = p->name;
+			f->hist[nh].line = p->value;
+			f->hist[nh].offset = 0;
+			if(debug)
+				printhist("-> ", &f->hist[nh], 1);
+			nh++;
+			break;
+		case 'Z':
+			if(f && nh > 0)
+				f->hist[nh-1].offset = p->value;
+			break;
+		case 'T':
+		case 't':	/* Text: terminate history if first in file */
+		case 'L':
+		case 'l':
+			tp = &txt[nt++];
+			tp->n = 0;
+			tp->sym = p;
+			tp->locals = ap;
+			if(debug)
+				fprint(2,"TEXT: %s at %lux\n", p->name, p->value);
+			if(f && !f->u0.fsym) {			/* first  */
+				f->u0.fsym = p;
+				f->addr = p->value;
+			}
+			break;
+		case 'a':
+		case 'p':
+		case 'm':		/* Local Vars */
+			if(!tp)
+				print("Warning: Free floating local var");
+			else {
+				if(debug)
+					fprint(2,"Local: %s %lux\n", p->name, p->value);
+				tp->locals[tp->n] = p;
+				tp->n++;
+				ap++;
+			}
+			break;
+		case 'f':		/* File names */
+			if(debug)
+				fprint(2,"Fname: %s\n", p->name);
+			fnames[p->value] = p;
+			break;
+		default:
+			break;
+		}
+	}
+		/* sort global and text tables into ascending address order */
+	qsort(globals, nglob, sizeof(Sym*), symcomp);
+	qsort(txt, ntxt, sizeof(Txtsym), txtcomp);
+	qsort(files, nfiles, sizeof(File), filecomp);
+	tp = txt;
+	for(i = 0, f = files; i < nfiles; i++, f++) {
+		for(j = 0; j < ntxt; j++) {
+			if(f->u0.fsym == tp->sym) {
+				if(debug) {
+					fprint(2,"LINK: %s to at %lux", f->u0.fsym->name, f->addr);
+					printhist("... ", f->hist, 1);
+				}
+				f->u0.ftxt = tp++;
+				break;
+			}
+			if(++tp >= txt+ntxt)	/* wrap around */
+				tp = txt;
+		}
+	}
+	return 1;
+}
+
+/*
+ * find symbol function.var by name.
+ *	fn != 0 && var != 0	=> look for fn in text, var in data
+ *	fn != 0 && var == 0	=> look for fn in text
+ *	fn == 0 && var != 0	=> look for var first in text then in data space.
+ */
+int
+lookup(char *fn, char *var, Symbol *s)
+{
+	int found;
+
+	if(buildtbls() == 0)
+		return 0;
+	if(fn) {
+		found = findtext(fn, s);
+		if(var == 0)		/* case 2: fn not in text */
+			return found;
+		else if(!found)		/* case 1: fn not found */
+			return 0;
+	} else if(var) {
+		found = findtext(var, s);
+		if(found)
+			return 1;	/* case 3: var found in text */
+	} else return 0;		/* case 4: fn & var == zero */
+
+	if(found)
+		return findlocal(s, var, s);	/* case 1: fn found */
+	return findglobal(var, s);		/* case 3: var not found */
+
+}
+/*
+ * find a function by name
+ */
+static int
+findtext(char *name, Symbol *s)
+{
+	int i;
+
+	for(i = 0; i < ntxt; i++) {
+		if(strcmp(txt[i].sym->name, name) == 0) {
+			fillsym(txt[i].sym, s);
+			s->handle = (void *) &txt[i];
+			return 1;
+		}
+	}
+	return 0;
+}
+/*
+ * find global variable by name
+ */
+static int
+findglobal(char *name, Symbol *s)
+{
+	int i;
+
+	for(i = 0; i < nglob; i++) {
+		if(strcmp(globals[i]->name, name) == 0) {
+			fillsym(globals[i], s);
+			return 1;
+		}
+	}
+	return 0;
+}
+/*
+ *	find the local variable by name within a given function
+ */
+int
+findlocal(Symbol *s1, char *name, Symbol *s2)
+{
+	if(s1 == 0)
+		return 0;
+	if(buildtbls() == 0)
+		return 0;
+	return findlocvar(s1, name, s2);
+}
+/*
+ *	find the local variable by name within a given function
+ *		(internal function - does no parameter validation)
+ */
+static int
+findlocvar(Symbol *s1, char *name, Symbol *s2)
+{
+	Txtsym *tp;
+	int i;
+
+	tp = (Txtsym *)s1->handle;
+	if(tp && tp->locals) {
+		for(i = 0; i < tp->n; i++)
+			if (strcmp(tp->locals[i]->name, name) == 0) {
+				fillsym(tp->locals[i], s2);
+				s2->handle = (void *)tp;
+				return 1;
+			}
+	}
+	return 0;
+}
+/*
+ *	Get ith text symbol
+ */
+int
+textsym(Symbol *s, int index)
+{
+
+	if(buildtbls() == 0)
+		return 0;
+	if(index >= ntxt)
+		return 0;
+	fillsym(txt[index].sym, s);
+	s->handle = (void *)&txt[index];
+	return 1;
+}
+/*	
+ *	Get ith file name
+ */
+int
+filesym(int index, char *buf, int n)
+{
+	Hist *hp;
+
+	if(buildtbls() == 0)
+		return 0;
+	if(index >= nfiles)
+		return 0;
+	hp = files[index].hist;
+	if(!hp || !hp->name)
+		return 0;
+	return fileelem(fnames, (uchar*)hp->name, buf, n);
+}
+/*
+ *	Lookup name of local variable located at an offset into the frame.
+ *	The type selects either a parameter or automatic.
+ */
+int
+getauto(Symbol *s1, int off, int type, Symbol *s2)
+{
+	Txtsym *tp;
+	Sym *p;
+	int i, t;
+
+	if(s1 == 0)
+		return 0;
+	if(type == CPARAM)
+		t = 'p';
+	else if(type == CAUTO)
+		t = 'a';
+	else
+		return 0;
+	if(buildtbls() == 0)
+		return 0;
+	tp = (Txtsym *)s1->handle;
+	if(tp == 0)
+		return 0;
+	for(i = 0; i < tp->n; i++) {
+		p = tp->locals[i];
+		if(p->type == t && p->value == off) {
+			fillsym(p, s2);
+			s2->handle = s1->handle;
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/*
+ * Find text symbol containing addr; binary search assumes text array is sorted by addr
+ */
+static int
+srchtext(long addr)
+{
+	ulong val;
+	int top, bot, mid;
+	Sym *sp;
+
+	val = addr;
+	bot = 0;
+	top = ntxt;
+	for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
+		sp = txt[mid].sym;
+		if(val < (ulong)sp->value)
+			top = mid;
+		else if(mid != ntxt-1 && val >= (ulong)txt[mid+1].sym->value)
+			bot = mid;
+		else
+			return mid;
+	}
+	return -1;
+}
+
+/*
+ * Find data symbol containing addr; binary search assumes data array is sorted by addr
+ */
+static
+int srchdata(long addr)
+{
+	ulong val;
+	int top, bot, mid;
+	Sym *sp;
+
+	bot = 0;
+	top = nglob;
+	val = addr;
+	for(mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
+		sp = globals[mid];
+		if(val < (ulong)sp->value)
+			top = mid;
+		else if(mid < nglob-1 && val >= (ulong)globals[mid+1]->value)
+			bot = mid;
+		else
+			return mid;
+	}
+	return -1;
+}
+/*
+ * Find symbol containing val in specified search space
+ * There is a special case when a value falls beyond the end
+ * of the text segment; if the search space is CTEXT, that value
+ * (usually etext) is returned.  If the search space is CANY, symbols in the
+ * data space are searched for a match.
+ */
+int
+findsym(long w, int type, Symbol *s)
+{
+	int i;
+
+	if(buildtbls() == 0)
+		return 0;
+
+	if(type == CTEXT || type == CANY) {
+		i = srchtext(w);
+		if(i >= 0) {
+			if(type == CTEXT || i != ntxt-1) {
+				fillsym(txt[i].sym, s);
+				s->handle = (void *) &txt[i];
+				return 1;
+			}
+		}
+	}
+	if(type == CDATA || type == CANY) {
+		i = srchdata(w);
+		if(i >= 0) {
+			fillsym(globals[i], s);
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/*
+ *	Find the start and end address of the function containing addr
+ */
+int
+fnbound(long addr, ulong *bounds)
+{
+	int i;
+
+	if(buildtbls() == 0)
+		return 0;
+
+	i = srchtext(addr);
+	if(0 <= i && i < ntxt-1) {
+		bounds[0] = txt[i].sym->value;
+		bounds[1] = txt[i+1].sym->value;
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * get the ith local symbol for a function
+ * the input symbol table is reverse ordered, so we reverse
+ * accesses here to maintain approx. parameter ordering in a stack trace.
+ */
+int
+localsym(Symbol *s, int index)
+{
+	Txtsym *tp;
+
+	if(s == 0)
+		return 0;
+	if(buildtbls() == 0)
+		return 0;
+
+	tp = (Txtsym *)s->handle;
+	if(tp && tp->locals && index < tp->n) {
+		fillsym(tp->locals[tp->n-index-1], s);	/* reverse */
+		s->handle = (void *)tp;
+		return 1;
+	}
+	return 0;
+}
+/*
+ * get the ith global symbol
+ */
+int
+globalsym(Symbol *s, int index)
+{
+	if(s == 0)
+		return 0;
+	if(buildtbls() == 0)
+		return 0;
+
+	if(index < nglob) {
+		fillsym(globals[index], s);
+		return 1;
+	}
+	return 0;
+}
+/*
+ *	find the pc given a file name and line offset into it.
+ */
+long
+file2pc(char *file, ulong line)
+{
+	File *fp;
+	int i;
+	long pc;
+	ulong start, end;
+	short *name;
+
+	if(buildtbls() == 0 || files == 0)
+		return -1;
+	name = encfname(file);
+	if(name == 0) {			/* encode the file name */
+		werrstr("file %s not found", file);
+		return -1;
+	} 
+		/* find this history stack */
+	for(i = 0, fp = files; i < nfiles; i++, fp++)
+		if (hline(fp, name, &line))
+			break;
+	free(name);
+	if(i >= nfiles) {
+		werrstr("line %ld in file %s not found", line, file);
+		return -1;
+	}
+	start = fp->addr;		/* first text addr this file */
+	if(i < nfiles-1)
+		end = (fp+1)->addr;	/* first text addr next file */
+	else
+		end = 0;		/* last file in load module */
+	/*
+	 * At this point, line contains the offset into the file.
+	 * run the state machine to locate the pc closest to that value.
+	 */
+	if(debug)
+		fprint(2,"find pc for %ld - between: %lux and %lux\n", line, start, end);
+	pc = line2addr(line, start, end);
+	if(pc == -1) {
+		werrstr("line %ld not in file %s", line, file);
+		return -1;
+	}
+	return pc;
+}
+/*
+ *	search for a path component index
+ */
+static int
+pathcomp(char *s, int n)
+{
+	int i;
+
+	for(i = 0; i <= fmax; i++)
+		if(fnames[i] && strncmp(s, fnames[i]->name, n) == 0 && fnames[i]->name[n] == 0)
+			return i;
+	return -1;
+}
+/*
+ *	Encode a char file name as a sequence of short indices
+ *	into the file name dictionary.
+ */
+static short*
+encfname(char *file)
+{
+	int i, j;
+	char *cp, *cp2;
+	short *dest;
+
+	if(*file == '/')	/* always check first '/' */
+		cp2 = file+1;
+	else {
+		cp2 = strchr(file, '/');
+		if(!cp2)
+			cp2 = strchr(file, 0);
+	}
+	cp = file;
+	dest = 0;
+	for(i = 0; *cp; i++) {
+		j = pathcomp(cp, cp2-cp);
+		if(j < 0)
+			return 0;	/* not found */
+		dest = realloc(dest, (i+1)*sizeof(short));
+		dest[i] = j;
+		cp = cp2;
+		while(*cp == '/')	/* skip embedded '/'s */
+			cp++;
+		cp2 = strchr(cp, '/');
+		if(!cp2)
+			cp2 = strchr(cp, 0);
+	}
+	dest = realloc(dest, (i+1)*sizeof(short));
+	dest[i] = 0;
+	return dest;
+}
+/*
+ *	Search a history stack for a matching file name accumulating
+ *	the size of intervening files in the stack.
+ */
+static int
+hline(File *fp, short *name, ulong *line)
+{
+	Hist *hp;
+	int offset, depth;
+	long ln;
+
+	for(hp = fp->hist; hp->name; hp++)		/* find name in stack */
+		if(hp->name[1] || hp->name[2]) {
+			if(hcomp(hp, name))
+				break;
+		}
+	if(!hp->name)		/* match not found */
+		return 0;
+	if(debug)
+		printhist("hline found ... ", hp, 1);
+	/*
+	 * unwind the stack until empty or we hit an entry beyond our line
+	 */
+	ln = *line;
+	offset = hp->line-1;
+	depth = 1;
+	for(hp++; depth && hp->name; hp++) {
+		if(debug)
+			printhist("hline inspect ... ", hp, 1);
+		if(hp->name[1] || hp->name[2]) {
+			if(hp->offset){			/* Z record */
+				offset = 0;
+				if(hcomp(hp, name)) {
+					if(*line <= hp->offset)
+						break;
+					ln = *line+hp->line-hp->offset;
+					depth = 1;	/* implicit pop */
+				} else
+					depth = 2;	/* implicit push */
+			} else if(depth == 1 && ln < hp->line-offset)
+					break;		/* Beyond our line */
+			else if(depth++ == 1)		/* push	*/
+				offset -= hp->line;
+		} else if(--depth == 1)		/* pop */
+			offset += hp->line;	
+	}
+	*line = ln+offset;
+	return 1;
+}
+/*
+ *	compare two encoded file names
+ */
+static int
+hcomp(Hist *hp, short *sp)
+{
+	uchar *cp;
+	int i, j;
+	short *s;
+
+	cp = (uchar *)hp->name;
+	s = sp;
+	if (*s == 0)
+		return 0;
+	for (i = 1; j = (cp[i]<<8)|cp[i+1]; i += 2) {
+		if(j == 0)
+			break;
+		if(*s == j)
+			s++;
+		else
+			s = sp;
+	}
+	return *s == 0;
+}
+/*
+ *	Convert a pc to a "file:line {file:line}" string.
+ */
+int
+fileline(char *str, int n, ulong dot)
+{
+	long line;
+	File *f;
+	int i;
+
+	*str = 0;
+	if(buildtbls() == 0)
+		return 0;
+
+	i = pc2filex(dot);
+	if (i >= 0)
+	{
+		f = &files[i];
+		line = pc2line(dot);
+		if(line >= 0 && fline(str, n, line, f->hist, 0) >= 0)
+			return 1;
+	}
+	return 0;
+}
+/*
+ *	Convert a pc to an index to the file table
+ */
+static int
+pc2filex(ulong dot)
+{
+	int top, bot, mid;
+	File *f;
+
+	if(buildtbls() == 0)
+		return -1;
+
+		/* binary search assumes file list is sorted by addr */
+	bot = 0;
+	top = nfiles;
+	for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
+		f = &files[mid];
+		if(dot < f->addr)
+			top = mid;
+		else if(mid < nfiles-1 && dot >= (f+1)->addr)
+			bot = mid;
+		else
+			return mid;
+	}
+	return -1;
+}
+
+/*
+ *	Convert a line number within a composite file to relative line
+ *	number in a source file.  A composite file is the source
+ *	file with included files inserted in line.
+ */
+static int
+fline(char *str, int n, long line, Hist *base, Hist **ret)
+{
+	Hist *start;			/* start of current level */
+	Hist *h;			/* current entry */
+	int delta;			/* sum of size of files this level */
+	int k;
+
+	start = base;
+	h = base;
+	delta = h->line;
+	while(h && h->name && line > h->line) {
+		if(h->name[1] || h->name[2]) {
+			if(h->offset != 0) {	/* #line Directive */
+				delta = h->line-h->offset+1;
+				start = h;
+				base = h++;
+			} else {		/* beginning of File */
+				if(start == base)
+					start = h++;
+				else {
+					k = fline(str, n, line, start, &h);
+					if(k <= 0)
+						return k;
+				}
+			}
+		} else {
+			if(start == base) {	/* end of recursion level */
+				if(ret)
+					*ret = h;
+				return 1;
+			} else {			/* end of included file */
+				delta += h->line-start->line;
+				h++;
+				start = base;
+			}
+		}
+	}
+	if(!h)
+		return -1;
+	if(start != base)
+		line = line-start->line+1;
+	else
+		line = line-delta+1;
+	if(!h->name)
+		strncpy(str, "<eof>", n);
+	else {
+		k = fileelem(fnames, (uchar*)start->name, str, n);
+		if(k+8 < n)
+			sprint(str+k, ":%ld", line);
+	}
+/**********Remove comments for complete back-trace of include sequence
+ *	if(start != base) {
+ *		k = strlen(str);
+ *		if(k+2 < n) {
+ *			str[k++] = ' ';
+ *			str[k++] = '{';
+ *		}
+ *		k += fileelem(fnames, (uchar*) base->name, str+k, n-k);
+ *		if(k+10 < n)
+ *			sprint(str+k, ":%ld}", start->line-delta);
+ *	}
+ ********************/
+	return 0;
+}
+/*
+ *	convert an encoded file name to a string.
+ */
+int
+fileelem(Sym **fp, uchar *cp, char *buf, int n)
+{
+	int i, j;
+	char *c, *bp, *end;
+
+	bp = buf;
+	end = buf+n-1;
+	for(i = 1; j = (cp[i]<<8)|cp[i+1]; i+=2){
+		c = fp[j]->name;
+		if(bp != buf && bp[-1] != '/' && bp < end)
+			*bp++ = '/';
+		while(bp < end && *c)
+			*bp++ = *c++;
+	}
+	*bp = 0;
+	return bp-buf;
+}
+/*
+ *	compare the values of two symbol table entries.
+ */
+static int
+symcomp(void *a, void *b)
+{
+	return (*(Sym**)a)->value - (*(Sym**)b)->value;
+}
+/*
+ *	compare the values of the symbols referenced by two text table entries
+ */
+static int
+txtcomp(void *a, void *b)
+{
+	return ((Txtsym*)a)->sym->value - ((Txtsym*)b)->sym->value;
+}
+/*
+ *	compare the values of the symbols referenced by two file table entries
+ */
+static int
+filecomp(void *a, void *b)
+{
+	return ((File*)a)->addr - ((File*)b)->addr;
+}
+/*
+ *	fill an interface Symbol structure from a symbol table entry
+ */
+static void
+fillsym(Sym *sp, Symbol *s)
+{
+	s->type = sp->type;
+	s->value = sp->value;
+	s->name = sp->name;
+	switch(sp->type) {
+	case 'b':
+	case 'B':
+	case 'D':
+	case 'd':
+		s->class = CDATA;
+		break;
+	case 't':
+	case 'T':
+	case 'l':
+	case 'L':
+		s->class = CTEXT;
+		break;
+	case 'a':
+		s->class = CAUTO;
+		break;
+	case 'p':
+		s->class = CPARAM;
+		break;
+	case 'm':
+		s->class = CSTAB;
+		break;
+	default:
+		s->class = CNONE;
+		break;
+	}
+	s->handle = 0;
+}
+/*
+ *	find the stack frame, given the pc
+ */
+long
+pc2sp(ulong pc)
+{
+	uchar *c;
+	uchar u;
+	ulong currpc;
+	long currsp;
+
+	if(spoff == 0)
+		return -1;
+	currsp = 0;
+	currpc = txtstart - mach->pcquant;
+
+	if(pc<currpc || pc>txtend)
+		return -1;
+	for(c = spoff; c < spoffend; c++) {
+		if (currpc >= pc)
+			return currsp;
+		u = *c;
+		if (u == 0) {
+			currsp += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
+			c += 4;
+		}
+		else if (u < 65)
+			currsp += 4*u;
+		else if (u < 129)
+			currsp -= 4*(u-64);
+		else 
+			currpc += mach->pcquant*(u-129);
+		currpc += mach->pcquant;
+	}
+	return -1;
+}
+/*
+ *	find the source file line number for a given value of the pc
+ */
+long
+pc2line(ulong pc)
+{
+	File *fp;
+	return pc2fline(pc, &fp);
+}
+/*
+ *	Convert a pc into a file table pointer & line offset
+ */
+static long
+pc2fline(ulong pc, File **fpp)
+{
+	File *f;
+	int i;
+
+	i = pc2filex(pc);
+	if (i < 0)
+		return i;
+	if (i >= npcl){
+		/* Precompute starting points by file, else too slow */
+		if (npcl == 0){
+			Pcl pcl;
+
+			/* decode start for pcline machine */
+			pcl.pcline = pcline;
+			pcl.pc = txtstart - mach->pcquant;
+			pcl.line = 0;
+			pcl2line(files->addr, &pcl, &files[0].pcl);
+			npcl = 1;
+		}
+		for (f = &files[npcl]; npcl <= i; npcl++, f++)
+			if (pcl2line(f->addr, &(f-1)->pcl, &f->pcl) < 0)
+				break;
+	}
+	f = &files[i];
+	*fpp = f;
+	return pcl2line(pc, &f->pcl, 0);
+}
+/*
+ *	Convert pc to line offset, given Pcl starting point,
+ *	 saving Pcl result.
+ */
+static long
+pcl2line(ulong pc, Pcl *bp, Pcl *rp)
+{
+	uchar *c;
+	uchar u;
+	ulong currpc;
+	long currline;
+
+	if(bp->pcline == 0)
+		return -1;
+	currpc = bp->pc;
+	currline = bp->line;
+	if(pc<currpc || pc>txtend)
+		return -1;
+	for(c = bp->pcline; c < pclineend; c++) {
+		if (currpc >= pc) {
+			if (rp){
+				rp->pc = currpc;
+				rp->line = currline;
+				rp->pcline = c;
+			}
+			return currline;
+		}
+		u = *c;
+		if(u == 0) {
+			currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
+			c += 4;
+		}
+		else if(u < 65)
+			currline += u;
+		else if(u < 129)
+			currline -= (u-64);
+		else 
+			currpc += mach->pcquant*(u-129);
+		currpc += mach->pcquant;
+	}
+	return -1;
+}
+/*
+ *	find the pc associated with a line number
+ *	basepc and endpc are text addresses bounding the search.
+ *	if endpc == 0, the end of the table is used (i.e., no upper bound).
+ *	usually, basepc and endpc contain the first text address in
+ *	a file and the first text address in the following file, respectively.
+ */
+long
+line2addr(ulong line, ulong basepc, ulong endpc)
+{
+	uchar *c;
+	uchar u;
+	ulong currpc;
+	long currline;
+	long delta, d;
+	long pc, found;
+
+	if(pcline == 0 || line == 0)
+		return -1;
+
+	currline = 0;
+	currpc = txtstart-mach->pcquant;
+	pc = -1;
+	found = 0;
+	delta = HUGEINT;
+
+	for(c = pcline; c < pclineend; c++) {
+		if(endpc && currpc >= endpc)	/* end of file of interest */
+			break;
+		if(currpc >= basepc) {		/* proper file */
+			if(currline >= line) {
+				d = currline-line;
+				found = 1;
+			} else
+				d = line-currline;
+			if(d < delta) {
+				delta = d;
+				pc = currpc;
+			}
+		}
+		u = *c;
+		if(u == 0) {
+			currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
+			c += 4;
+		}
+		else if(u < 65)
+			currline += u;
+		else if(u < 129)
+			currline -= (u-64);
+		else 
+			currpc += mach->pcquant*(u-129);
+		currpc += mach->pcquant;
+	}
+	if(found)
+		return pc;
+	return -1;
+}
+/*
+ *	Print a history stack (debug). if count is 0, prints the whole stack
+ */
+static void
+printhist(char *msg, Hist *hp, int count)
+{
+	int i;
+	uchar *cp;
+	char buf[128];
+
+	i = 0;
+	while(hp->name) {
+		if(count && ++i > count)
+			break;
+		fprint(2,"%s Line: %lx (%ld)  Offset: %lx (%ld)  Name: ", msg,
+			hp->line, hp->line, hp->offset, hp->offset);
+		for(cp = (uchar *)hp->name+1; (*cp<<8)|cp[1]; cp += 2) {
+			if (cp != (uchar *)hp->name+1)
+				fprint(2,"/");
+			fprint(2,"%x", (*cp<<8)|cp[1]);
+		}
+		fileelem(fnames, (uchar *) hp->name, buf, sizeof(buf));
+		fprint(2," (%s)\n", buf);
+		hp++;
+	}
+}
+
+#ifdef DEBUG
+/*
+ *	print the history stack for a file. (debug only)
+ *	if (name == 0) => print all history stacks.
+ */
+void
+dumphist(char *name)
+{
+	int i;
+	File *f;
+	short *fname;
+
+	if(buildtbls() == 0)
+		return;
+	if(name)
+		fname = encfname(name);
+	for(i = 0, f = files; i < nfiles; i++, f++)
+		if(fname == 0 || hcomp(f->hist, fname))
+			printhist("> ", f->hist, f->n);
+
+	if(fname)
+		free(fname);
+}
+#endif
diff --git a/utils/libmach/t.c b/utils/libmach/t.c
new file mode 100644
index 00000000..adea089b
--- /dev/null
+++ b/utils/libmach/t.c
@@ -0,0 +1,122 @@
+/*
+ * thumb definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "uregt.h"
+#include "mach.h"
+
+
+#define	REGOFF(x)	(ulong) (&((struct Ureg *) 0)->x)
+
+#define SP		REGOFF(r13)
+#define PC		REGOFF(pc)
+
+#define	REGSIZE		sizeof(struct Ureg)
+
+Reglist thumbreglist[] =
+{
+	{"LINK",	REGOFF(link),		RINT|RRDONLY, 'X'},
+	{"TYPE",	REGOFF(type),		RINT|RRDONLY, 'X'},
+	{"PSR",		REGOFF(psr),		RINT|RRDONLY, 'X'},
+	{"PC",		PC,			RINT, 'X'},
+	{"SP",		SP,			RINT, 'X'},
+	{"R15",		PC,			RINT, 'X'},
+	{"R14",		REGOFF(r14),		RINT, 'X'},
+	{"R13",		REGOFF(r13),		RINT, 'X'},
+	{"R12",		REGOFF(r12),		RINT, 'X'},
+	{"R11",		REGOFF(r11),		RINT, 'X'},
+	{"R10",		REGOFF(r10),		RINT, 'X'},
+	{"R9",		REGOFF(r9),		RINT, 'X'},
+	{"R8",		REGOFF(r8),		RINT, 'X'},
+	{"R7",		REGOFF(r7),		RINT, 'X'},
+	{"R6",		REGOFF(r6),		RINT, 'X'},
+	{"R5",		REGOFF(r5),		RINT, 'X'},
+	{"R4",		REGOFF(r4),		RINT, 'X'},
+	{"R3",		REGOFF(r3),		RINT, 'X'},
+	{"R2",		REGOFF(r2),		RINT, 'X'},
+	{"R1",		REGOFF(r1),		RINT, 'X'},
+	{"R0",		REGOFF(r0),		RINT, 'X'},
+	{  0 }
+};
+
+	/* the machine description */
+Mach mthumb =
+{
+	"thumb",
+	MARM,	/*MTHUMB,*/		/* machine type */
+	thumbreglist,	/* register set */
+	REGSIZE,	/* register set size */
+	0,		/* fp register set size */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"R15",		/* name of link register */
+	"setR12",	/* static base register name */
+	0,		/* static base register value */
+	0x1000,		/* page size */
+	0x80000000,	/* kernel base */
+	0,		/* kernel text mask */
+	2,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
+
+typedef struct pcentry pcentry;
+
+struct pcentry{
+	long start;
+	long stop;
+};
+
+static pcentry *pctab;
+static int npctab;
+
+void
+thumbpctab(Biobuf *b, Fhdr *fp)
+{
+	int n, o, ta;
+	uchar c[8];
+	pcentry *tab;
+
+	Bseek(b, fp->lnpcoff+fp->lnpcsz, 0);
+	o = (int)Boffset(b);
+	Bseek(b, 0, 2);
+	n = (int)Boffset(b)-o;
+	pctab = (pcentry*)malloc(n);
+	if(pctab == 0)
+		return;
+	ta = fp->txtaddr;
+	tab = pctab;
+	Bseek(b, fp->lnpcoff+fp->lnpcsz, 0);
+	while(Bread(b, c, sizeof(c)) == sizeof(c)){
+		tab->start = ta + (c[0]<<24)|(c[1]<<16)|(c[2]<<8)|c[3];
+		tab->stop = ta + (c[4]<<24)|(c[5]<<16)|(c[6]<<8)|c[7];
+		tab++;
+	}
+	npctab = n/sizeof(c);
+}
+
+int
+thumbpclookup(ulong pc)
+{
+	ulong l, u, m;
+	pcentry *tab = pctab;
+
+	l = 0;
+	u = npctab-1;
+	while(l < u){
+		m = (l+u)/2;
+		if(pc < tab[m].start)
+			u = m-1;
+		else if(pc > tab[m].stop)
+			l = m+1;
+		else
+			l = u = m;
+	}
+	if(l == u && u >= 0 && u < npctab && tab[u].start <= pc && pc <= tab[u].stop)
+		return 1;	// thumb
+	return 0;	// arm
+}
+
diff --git a/utils/libmach/tdb.c b/utils/libmach/tdb.c
new file mode 100644
index 00000000..8eddc43a
--- /dev/null
+++ b/utils/libmach/tdb.c
@@ -0,0 +1,839 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+static int debug = 0;
+
+typedef struct	Instr	Instr;
+struct	Instr
+{
+	Map	*map;
+	ulong	w;
+	ulong	addr;
+	uchar	op;			/* super opcode */
+
+	uchar	rd;
+	uchar	rn;
+	uchar	rs;
+
+	long	imm;			/* imm */
+
+	char*	curr;			/* fill point in buffer */
+	char*	end;			/* end of buffer */
+	char*	err;			/* error message */
+};
+
+typedef struct Opcode Opcode;
+struct Opcode
+{
+	char*	o;
+	void	(*fmt)(Opcode*, Instr*);
+	ulong	(*foll)(Map*, Rgetter, Instr*, ulong);
+	char*	a;
+};
+
+static	void	format(char*, Instr*, char*);
+static	char	FRAMENAME[] = ".frame";
+
+/*
+ * Thumb-specific debugger interface
+ */
+
+static	char	*thumbexcep(Map*, Rgetter);
+static	int	thumbfoll(Map*, ulong, Rgetter, ulong*);
+static	int	thumbinst(Map*, ulong, char, char*, int);
+static	int	thumbdas(Map*, ulong, char*, int);
+static	int	thumbinstlen(Map*, ulong);
+
+/*
+ *	Debugger interface
+ */
+Machdata thumbmach =
+{
+	{0x0, 0xE8},		/* break point */
+	2,				/* break point size */
+
+	leswab,			/* short to local byte order */
+	leswal,			/* long to local byte order */
+	leswav,			/* long to local byte order */
+	risctrace,		/* C traceback */
+	riscframe,		/* Frame finder */
+	thumbexcep,			/* print exception */
+	0,			/* breakpoint fixup */
+	0,			/* single precision float printer */
+	0,			/* double precision float printer */
+	thumbfoll,		/* following addresses */
+	thumbinst,		/* print instruction */
+	thumbdas,			/* dissembler */
+	thumbinstlen,		/* instruction size */
+};
+
+static void thumbrrh(Opcode *, Instr *);
+static void thumbbcc(Opcode *, Instr *);
+static void thumbb(Opcode *, Instr *);
+static void thumbbl(Opcode *, Instr *);
+
+static char*
+thumbexcep(Map *map, Rgetter rget)
+{
+	long c;
+
+	c = (*rget)(map, "TYPE");
+	switch (c&0x1f) {
+	case 0x11:
+		return "Fiq interrupt";
+	case 0x12:
+		return "Mirq interrupt";
+	case 0x13:
+		return "SVC/SWI Exception";
+	case 0x17:
+		return "Prefetch Abort/Data Abort";
+	case 0x18:
+		return "Data Abort";
+	case 0x1b:
+		return "Undefined instruction/Breakpoint";
+	case 0x1f:
+		return "Sys trap";
+	default:
+		return "Undefined trap";
+	}
+}
+
+static
+char*	cond[16] =
+{
+	"EQ",	"NE",	"CS",	"CC",
+	"MI",	"PL",	"VS",	"VC",
+	"HI",	"LS",	"GE",	"LT",
+	"GT",	"LE",	"\0",	"NV"
+};
+
+#define B(h, l)		bits(ins, h, l)
+
+static int
+bits(int i, int h, int l)
+{
+	if(h < l)
+		print("h < l in bits");
+	return (i&(((1<<(h-l+1))-1)<<l))>>l;
+}
+
+int
+thumbclass(long w)
+{
+	int o;
+	int ins = w;
+
+	if(ins&0xffff0000)
+		return 3+2+2+4+16+4+1+8+6+2+2+2+4+1+1+1+2;
+	o = B(15, 13);
+	switch(o){
+	case 0:
+		o = B(12, 11);
+		switch(o){
+			case 0:
+			case 1:
+			case 2:
+				return B(12, 11);
+			case 3:
+				if(B(10, 10) == 0)
+					return 3+B(9, 9);
+				else
+					return 3+2+B(9, 9);
+		}
+	case 1:
+		return 3+2+2+B(12, 11);
+	case 2:
+		o = B(12, 10);
+		if(o == 0)
+			return 3+2+2+4+B(9, 6);
+		if(o == 1){
+			o = B(9, 8);
+			if(o == 3)
+				return 3+2+2+4+16+B(9, 8);
+			return 3+2+2+4+16+B(9, 8);
+		}
+		if(o == 2 || o == 3)
+			return 3+2+2+4+16+4;
+		return 3+2+2+4+16+4+1+B(11, 9);
+	case 3:
+		return 3+2+2+4+16+4+1+8+B(12, 11);
+	case 4:
+		if(B(12, 12) == 0)
+			return 3+2+2+4+16+4+1+8+4+B(11, 11);
+		return 3+2+2+4+16+4+1+8+6+B(11, 11);
+	case 5:
+		if(B(12, 12) == 0)
+			return 3+2+2+4+16+4+1+8+6+2+B(11, 11);
+		if(B(11, 8) == 0)
+			return 3+2+2+4+16+4+1+8+6+2+2+B(7, 7);
+		return 3+2+2+4+16+4+1+8+6+2+2+2+B(11, 11);
+	case 6:
+		if(B(12, 12) == 0)
+			return 3+2+2+4+16+4+1+8+6+2+2+2+2+B(11, 11);
+		if(B(11, 8) == 0xf)
+			return 3+2+2+4+16+4+1+8+6+2+2+2+4;
+		return 3+2+2+4+16+4+1+8+6+2+2+2+4+1;
+	case 7:
+		o = B(12, 11);
+		switch(o){
+			case 0:
+				return 3+2+2+4+16+4+1+8+6+2+2+2+4+1+1;
+			case 1:
+				return 3+2+2+4+16+4+1+8+6+2+2+2+4+1+1+1+2;
+			case 2:
+				return 3+2+2+4+16+4+1+8+6+2+2+2+4+1+1+1;
+			case 3:
+				return 3+2+2+4+16+4+1+8+6+2+2+2+4+1+1+1+1;
+		}
+	}
+	return 0;
+}
+
+static int
+decode(Map *map, ulong pc, Instr *i)
+{
+	ushort w;
+
+	if(get2(map, pc, &w) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	i->w = w;
+	i->addr = pc;
+	i->op = thumbclass(w);
+	i->map = map;
+	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);
+}
+
+static int
+plocal(Instr *i)
+{
+	char *reg;
+	Symbol s;
+	char *fn;
+	int class;
+	int offset;
+
+	if(!findsym(i->addr, CTEXT, &s)) {
+		if(debug)fprint(2,"fn not found @%lux: %r\n", i->addr);
+		return 0;
+	}
+	fn = s.name;
+	if (!findlocal(&s, FRAMENAME, &s)) {
+		if(debug)fprint(2,"%s.%s not found @%s: %r\n", fn, FRAMENAME, s.name);
+			return 0;
+	}
+	if(s.value > i->imm) {
+		class = CAUTO;
+		offset = s.value-i->imm;
+		reg = "(SP)";
+	} else {
+		class = CPARAM;
+		offset = i->imm-s.value-4;
+		reg = "(FP)";
+	}
+	if(!getauto(&s, offset, class, &s)) {
+		if(debug)fprint(2,"%s %s not found @%ux: %r\n", fn,
+			class == CAUTO ? " auto" : "param", offset);
+		return 0;
+	}
+	bprint(i, "%s%c%d%s", s.name, class == CPARAM ? '+' : '-', s.value, reg);
+	return 1;
+}
+
+/*
+ * Print value v as name[+offset]
+ */
+static int
+gsymoff(char *buf, int n, long v, int space)
+{
+	Symbol s;
+	int r;
+	long delta;
+
+	r = delta = 0;		/* to shut compiler up */
+	if (v) {
+		r = findsym(v, space, &s);
+		if (r)
+			delta = v-s.value;
+		if (delta < 0)
+			delta = -delta;
+	}
+	if (v == 0 || r == 0 || delta >= 4096)
+		return snprint(buf, n, "#%lux", v);
+	if (strcmp(s.name, ".string") == 0)
+		return snprint(buf, n, "#%lux", v);
+	if (!delta)
+		return snprint(buf, n, "%s", s.name);
+	if (s.type != 't' && s.type != 'T')
+		return snprint(buf, n, "%s+%lux", s.name, v-s.value);
+	else
+		return snprint(buf, n, "#%lux", v);
+}
+
+static int
+thumbcondpass(Map *map, Rgetter rget, uchar cond)
+{
+	ulong psr;
+	uchar n;
+	uchar z;
+	uchar c;
+	uchar v;
+
+	psr = rget(map, "PSR");
+	n = (psr >> 31) & 1;
+	z = (psr >> 30) & 1;
+	c = (psr >> 29) & 1;
+	v = (psr >> 28) & 1;
+
+	switch(cond) {
+		case 0:		return z;
+		case 1:		return !z;
+		case 2:		return c;
+		case 3:		return !c;
+		case 4:		return n;
+		case 5:		return !n;
+		case 6:		return v;
+		case 7:		return !v;
+		case 8:		return c && !z;
+		case 9:		return !c || z;
+		case 10:	return n == v;
+		case 11:	return n != v;
+		case 12:	return !z && (n == v);
+		case 13:	return z && (n != v);
+		case 14:	return 1;
+		case 15:	return 0;
+	}
+	return 0;
+}
+
+static ulong
+thumbfbranch(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	char buf[8];
+
+	if(i->op == 30){	// BX
+		thumbrrh(nil, i);
+		sprint(buf, "R%ud", i->rn);
+		return rget(map, buf)&~1;		// clear T bit
+	}
+	if(i->op == 57){	// Bcc
+		thumbbcc(nil, i);
+		if(thumbcondpass(map, rget, (i->w >> 8) & 0xf))
+			return i->imm;
+		return pc+2;
+	}
+	if(i->op == 58){	// B
+		thumbb(nil, i);
+		return i->imm;
+	}
+	if(i->op == 60){	// BL
+		thumbbl(nil, i);
+		return i->imm;
+	}
+	print("bad thumbfbranch call");
+	return 0;
+}
+
+static ulong
+thumbfmov(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	char buf[8];
+	ulong rd;
+
+	thumbrrh(nil, i);
+	rd = i->rd;
+	if(rd != 15)
+		return pc+2;
+	sprint(buf, "R%ud", i->rn);
+	return rget(map, buf);
+}
+
+static ulong
+thumbfadd(Map *map, Rgetter rget, Instr *i, ulong pc)
+{
+	char buf[8];
+	ulong rd, v;
+
+	thumbrrh(nil, i);
+	rd = i->rd;
+	if(rd != 15)
+		return pc+2;
+	sprint(buf, "R%ud", i->rn);
+	v = rget(map, buf);
+	sprint(buf, "R15");
+	return rget(map, buf) + v;
+}
+
+static void
+thumbshift(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	i->imm = B(10, 6);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbrrr(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	i->rs = B(8, 6);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbirr(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	i->imm = B(8, 6);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbir(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(10, 8);
+	i->imm = B(7, 0);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbrr(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbrrh(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	if(B(6, 6))
+		i->rn += 8;
+	if(B(7, 7))
+		i->rd += 8;
+	if(o != nil){
+		if(i->w == 0x46b7 || i->w == 0x46f7 || i->w == 0x4730 || i->w == 0x4770)	// mov r6, pc or mov lr, pc or bx r6 or bx lr
+			format("RET", i, "");
+		else
+			format(o->o, i, o->a);
+	}
+}
+
+static void
+thumbpcrel(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rn = 15;
+	i->rd = B(10, 8);
+	i->imm = 4*(B(7, 0)+1);
+	if(i->addr & 3)
+		i->imm -= 2;
+	format(o->o, i, o->a);
+}
+
+static void
+thumbmovirr(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(2, 0);
+	i->rn = B(5, 3);
+	i->imm = B(10, 6);
+	if(strcmp(o->o, "MOVW") == 0)
+		i->imm *= 4;
+	else if(strncmp(o->o, "MOVH", 4) == 0)
+		i->imm *= 2;
+	format(o->o, i, o->a);
+}
+
+static void
+thumbmovsp(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rn = 13;
+	i->rd = B(10, 8);
+	i->imm = 4*B(7, 0);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbaddsppc(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->rd = B(10, 8);
+	i->imm = 4*B(7, 0);
+	if(i->op == 48)
+		i->imm += 4;
+	format(o->o, i, o->a);
+}
+
+static void
+thumbaddsp(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->imm = 4*B(6, 0);
+	format(o->o, i, o->a);
+}	
+
+static void
+thumbswi(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	i->imm = B(7, 0);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbbcc(Opcode *o, Instr *i)
+{
+	int off, ins = i->w;
+
+	off = B(7, 0);
+	if(off & 0x80)
+		off |= 0xffffff00;
+	i->imm = i->addr + 2*off + 4;
+	if(o != nil)
+		format(o->o, i, o->a);
+}
+
+static void
+thumbb(Opcode *o, Instr *i)
+{
+	int off, ins = i->w;
+
+	off = B(10, 0);
+	if(off & 0x400)
+		off |= 0xfffff800;
+	i->imm = i->addr + 2*off + 4;
+	if(o != nil)
+		format(o->o, i, o->a);
+}	
+
+static void
+thumbbl(Opcode *o, Instr *i)
+{
+	int off, h, ins = i->w;
+	static int reglink;
+
+	h = B(11, 11);
+	off = B(10, 0);
+	if(h == 0){
+		if(off & 0x400)
+			off |= 0xfffff800;
+		i->imm = i->addr + (off<<12) + 4;
+		reglink = i->imm;
+	}
+	else{
+		i->imm = reglink + 2*off;
+	}
+	if(o != nil)
+		format(o->o, i, o->a);
+}	
+
+static void
+thumbregs(Opcode *o, Instr *i)
+{
+	int ins = i->w;
+
+	if(i->op == 52 || i->op == 53)
+		i->rd = 13;
+	else
+		i->rd = B(10, 8);
+	i->imm = B(7, 0);
+	format(o->o, i, o->a);
+}
+
+static void
+thumbunk(Opcode *o, Instr *i)
+{
+	format(o->o, i, o->a);
+}
+	
+static Opcode opcodes[] =
+{
+	"LSL",	thumbshift,	0,	"$#%i,R%n,R%d",	// 0
+	"LSR",	thumbshift,	0,	"$#%i,R%n,R%d",	// 1
+	"ASR",	thumbshift,	0,	"$#%i,R%n,R%d",	// 2
+	"ADD",	thumbrrr,		0,	"R%s,R%n,R%d",		// 3
+	"SUB",	thumbrrr,		0,	"R%s,R%n,R%d",		// 4
+	"ADD",	thumbirr,		0,	"$#%i,R%n,R%d",	// 5
+	"SUB",	thumbirr,		0,	"$#%i,R%n,R%d",	// 6
+	"MOVW",	thumbir,		0,	"$#%i,R%d",		// 7
+	"CMP",	thumbir,		0,	"$#%i,R%d",		// 8
+	"ADD",	thumbir,		0,	"$#%i,R%d,R%d",	// 9
+	"SUB",	thumbir,		0,	"$#%i,R%d,R%d",	// 10
+	"AND",	thumbrr,		0,	"R%n,R%d,R%d",	// 11
+	"EOR",	thumbrr,		0,	"R%n,R%d,R%d",	// 12
+	"LSL",	thumbrr,		0,	"R%n,R%d,R%d",	// 13
+	"LSR",	thumbrr,		0,	"R%n,R%d,R%d",	// 14
+	"ASR",	thumbrr,		0,	"R%n,R%d,R%d",	// 15
+	"ADC",	thumbrr,		0,	"R%n,R%d,R%d",	// 16
+	"SBC",	thumbrr,		0,	"R%n,R%d,R%d",	// 17
+	"ROR",	thumbrr,		0,	"R%n,R%d,R%d",	// 18
+	"TST",	thumbrr,		0,	"R%n,R%d",		// 19
+	"NEG",	thumbrr,		0,	"R%n,R%d",		// 20
+	"CMP",	thumbrr,		0,	"R%n,R%d",		// 21
+	"CMPN",	thumbrr,		0,	"R%n,R%d",		// 22
+	"OR",	thumbrr,		0,	"R%n,R%d,R%d",	// 23
+	"MUL",	thumbrr,		0,	"R%n,R%d,R%d",	// 24
+	"BITC",	thumbrr,		0,	"R%n,R%d,R%d",	// 25
+	"MOVN",	thumbrr,		0,	"R%n,R%d",		// 26
+	"ADD",	thumbrrh,		thumbfadd,	"R%n,R%d,R%d",	// 27
+	"CMP",	thumbrrh,		0,	"R%n,R%d",		// 28
+	"MOVW",	thumbrrh,		thumbfmov,	"R%n,R%d",	// 29
+	"BX",		thumbrrh,		thumbfbranch,	"R%n",	// 30
+	"MOVW",	thumbpcrel,	0,	"$%I,R%d",		// 31
+	"MOVW",	thumbrrr,		0,	"R%d, [R%s,R%n]",	// 32
+	"MOVH",	thumbrrr,		0,	"R%d, [R%s,R%n]",	// 33
+	"MOVB",	thumbrrr,		0,	"R%d, [R%s,R%n]",	// 34
+	"MOVB",	thumbrrr,		0,	"[R%s,R%n],R%d",	// 35
+	"MOVW",	thumbrrr,		0,	"[R%s,R%n],R%d",	// 36
+	"MOVHU",	thumbrrr,		0,	"[R%s,R%n],R%d",	// 37
+	"MOVBU",	thumbrrr,		0,	"[R%s,R%n],R%d",	// 38
+	"MOVH",	thumbrrr,		0,	"[R%s,R%n],R%d",	// 39
+	"MOVW",	thumbmovirr,	0,	"R%d,%I",			// 40
+	"MOVW",	thumbmovirr,	0,	"%I,R%d",			// 41
+	"MOVB",	thumbmovirr,	0,	"R%d,%I",			// 42
+	"MOVBU",	thumbmovirr,	0,	"$%I,R%d",		// 43
+	"MOVH",	thumbmovirr,	0,	"R%d,%I",			// 44
+	"MOVHU",	thumbmovirr,	0,	"%I,R%d",			// 45
+	"MOVW",	thumbmovsp,	0,	"R%d,%I",			// 46
+	"MOVW",	thumbmovsp,	0,	"%I,R%d",			// 47
+	"ADD",	thumbaddsppc,0,	"$#%i,PC,R%d",		// 48
+	"ADD",	thumbaddsppc,0,	"$#%i,SP,R%d",		// 49
+	"ADD",	thumbaddsp,	0,	"$#%i,SP,SP",		// 50
+	"SUB",	thumbaddsp,	0,	"$#%i,SP,SP",		// 51
+	"PUSH",	thumbregs,	0,	"R%d, %r",			// 52
+	"POP",	thumbregs,	0,	"R%d, %r",			// 53
+	"STMIA",	thumbregs,	0,	"R%d, %r",			// 54
+	"LDMIA",	thumbregs,	0,	"R%d, %r",			// 55
+	"SWI",	thumbswi,	0,	"$#%i",			// 56
+	"B%c",	thumbbcc,	thumbfbranch,	"%b",		// 57
+	"B",		thumbb,		thumbfbranch,	"%b",		// 58
+	"BL",		thumbbl,		0,	"",				// 59
+	"BL",		thumbbl,		thumbfbranch,	"%b",		// 60
+	"UNK",	thumbunk,	0,	"",				// 61
+};
+
+static void
+gaddr(Instr *i)
+{
+	*i->curr++ = '$';
+	i->curr += gsymoff(i->curr, i->end-i->curr, i->imm, CANY);
+}
+
+static void
+format(char *mnemonic, Instr *i, char *f)
+{
+	int j, k, m, n;
+	int g;
+	char *fmt;
+	int ins = i->w;
+
+	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 'c':	/*Bcc */
+			bprint(i, "%s", cond[B(11, 8)]);
+			break;
+
+		case 's':
+			bprint(i, "%d", i->rs);
+			break;
+				
+		case 'n':
+			bprint(i, "%d", i->rn);
+			break;
+
+		case 'd':
+			bprint(i, "%d", i->rd);
+			break;
+
+		case 'i':
+			bprint(i, "%lux", i->imm);
+			break;
+
+		case 'b':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				i->imm, CTEXT);
+			break;
+
+		case 'I':
+			if (i->rn == 13) {
+				if (plocal(i))
+					break;
+			}
+			g = 0;
+			fmt = "#%lx(R%d)";
+			if (i->rn == 15) {
+				/* convert load of offset(PC) to a load immediate */
+				if (get4(i->map, i->addr + i->imm, &i->imm) > 0)
+				{
+					g = 1;
+					fmt = "";
+				}
+			}
+			if (mach->sb)
+			{
+				if (i->rn == 12)
+				{
+					i->imm += mach->sb;
+					g = 1;
+					fmt = "-SB(SB)";
+				}
+			}
+			if (g)
+			{
+				gaddr(i);
+				bprint(i, fmt, i->rn);
+			}
+			else
+				bprint(i, fmt, i->imm, i->rn);
+			break;
+
+		case 'r':
+			n = i->imm&0xff;
+			j = 0;
+			k = 0;
+			while(n) {
+				m = j;
+				while(n&0x1) {
+					j++;
+					n >>= 1;
+				}
+				if(j != m) {
+					if(k)
+						bprint(i, ",");
+					if(j == m+1)
+						bprint(i, "R%d", m);
+					else
+						bprint(i, "R%d-R%d", m, j-1);
+					k = 1;
+				}
+				j++;
+				n >>= 1;
+			}
+			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;
+
+	i.curr = buf;
+	i.end = buf+n-1;
+	if(decode(map, pc, &i) < 0)
+		return -1;
+
+	(*opcodes[i.op].fmt)(&opcodes[i.op], &i);
+	return 2;
+}
+
+static int
+thumbinst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	USED(modifier);
+	return printins(map, pc, buf, n);
+}
+
+static int
+thumbdas(Map *map, ulong pc, char *buf, int n)
+{
+	Instr i;
+
+	i.curr = buf;
+	i.end = buf+n;
+	if(decode(map, pc, &i) < 0)
+		return -1;
+	if(i.end-i.curr > 8)
+		i.curr = _hexify(buf, i.w, 7);
+	*i.curr = 0;
+	return 2;
+}
+
+static int
+thumbinstlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	if(decode(map, pc, &i) < 0)
+		return -1;
+	return 2;
+}
+
+static int
+thumbfoll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	ulong d;
+	Instr i;
+
+	if(decode(map, pc, &i) < 0)
+		return -1;
+
+	if(opcodes[i.op].foll) {
+		d = (*opcodes[i.op].foll)(map, rget, &i, pc);
+		if(d == -1)
+			return -1;
+	} else
+		d = pc+2;
+
+	foll[0] = d;
+	return 1;
+}
diff --git a/utils/libmach/tobj.c b/utils/libmach/tobj.c
new file mode 100644
index 00000000..d18de434
--- /dev/null
+++ b/utils/libmach/tobj.c
@@ -0,0 +1,133 @@
+/*
+ * 5obj.c - identify and parse a arm object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "5c/5.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	type;
+	char	sym;
+	char	name;
+};
+static Addr addr(Biobuf*);
+static char type2char(int);
+static void skip(Biobuf*, int);
+
+int
+_ist(char *s)
+{
+	return  s[0] == ANAME				/* ANAME */
+		&& s[1] == D_FILE			/* type */
+		&& s[2] == 1				/* sym */
+		&& s[3] == '<';				/* name of file */
+}
+
+int
+_readt(Biobuf *bp, Prog *p)
+{
+	int as, n;
+	Addr a;
+
+	as = Bgetc(bp);			/* as */
+	if(as < 0)
+		return 0;
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 6);		/* scond(1), reg(1), lineno(4) */
+	a = addr(bp);
+	addr(bp);
+	if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	long off;
+
+	a.type = Bgetc(bp);	/* a.type */
+	skip(bp,1);		/* reg */
+	a.sym = Bgetc(bp);	/* sym index */
+	a.name = Bgetc(bp);	/* sym type */
+	switch(a.type){
+	default:
+	case D_NONE:
+	case D_REG:
+	case D_FREG:
+	case D_PSR:
+	case D_FPCR:
+		break;
+	case D_OREG:
+	case D_CONST:
+	case D_BRANCH:
+	case D_SHIFT:
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+		if(a.sym && (a.name==D_PARAM || a.name==D_AUTO))
+			_offset(a.sym, off);
+		break;
+	case D_SCONST:
+		skip(bp, NSNAME);
+		break;
+	case D_FCONST:
+		skip(bp, 8);
+		break;
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}
diff --git a/utils/libmach/ureg2.h b/utils/libmach/ureg2.h
new file mode 100644
index 00000000..e237cb3d
--- /dev/null
+++ b/utils/libmach/ureg2.h
@@ -0,0 +1,28 @@
+struct Ureg
+{
+	ulong	r0;
+	ulong	r1;
+	ulong	r2;
+	ulong	r3;
+	ulong	r4;
+	ulong	r5;
+	ulong	r6;
+	ulong	r7;
+	ulong	a0;
+	ulong	a1;
+	ulong	a2;
+	ulong	a3;
+	ulong	a4;
+	ulong	a5;
+	ulong	a6;
+	ulong	sp;
+	ulong	usp;
+	ulong	magic;		/* for db to find bottom of ureg */
+	ushort	sr;
+	ulong	pc;
+	ushort	vo;
+#ifndef	UREGVARSZ
+#define	UREGVARSZ 23		/* for 68040; 15 is enough on 68020 */
+#endif
+	uchar	microstate[UREGVARSZ];	/* variable-sized portion */
+};
diff --git a/utils/libmach/ureg4.h b/utils/libmach/ureg4.h
new file mode 100644
index 00000000..5f95dcd9
--- /dev/null
+++ b/utils/libmach/ureg4.h
@@ -0,0 +1,46 @@
+struct Ureg
+{
+	ulong	status;
+	long	pc;
+	union
+	{
+		long	sp;		/* r29 */
+		long	usp;		/* r29 */
+	} u0;
+	ulong	cause;
+	ulong	badvaddr;
+	ulong	tlbvirt;
+
+	long	hhi;	long	hi;
+	long	hlo;	long	lo;
+	long	hr31;	long	r31;
+	long	hr30;	long	r30;
+	long	hr28;	long	r28;
+	long	hr27;	long	r27;
+	long	hr26;	long	r26;
+	long	hr25;	long	r25;
+	long	hr24;	long	r24;
+	long	hr23;	long	r23;
+	long	hr22;	long	r22;
+	long	hr21;	long	r21;
+	long	hr20;	long	r20;
+	long	hr19;	long	r19;
+	long	hr18;	long	r18;
+	long	hr17;	long	r17;
+	long	hr16;	long	r16;
+	long	hr15;	long	r15;
+	long	hr14;	long	r14;
+	long	hr13;	long	r13;
+	long	hr12;	long	r12;
+	long	hr11;	long	r11;
+	long	hr10;	long	r10;
+	long	hr9;	long	r9;
+	long	hr8;	long	r8;
+	long	hr7;	long	r7;
+	long	hr6;	long	r6;
+	long	hr5;	long	r5;
+	long	hr4;	long	r4;
+	long	hr3;	long	r3;
+	long	hr2;	long	r2;
+	long	hr1;	long	r1;
+};
diff --git a/utils/libmach/ureg5.h b/utils/libmach/ureg5.h
new file mode 100644
index 00000000..ffdad423
--- /dev/null
+++ b/utils/libmach/ureg5.h
@@ -0,0 +1,21 @@
+struct Ureg {
+	uint	r0;
+	uint	r1;
+	uint	r2;
+	uint	r3;
+	uint	r4;
+	uint	r5;
+	uint	r6;
+	uint	r7;
+	uint	r8;
+	uint	r9;
+	uint	r10;
+	uint	r11;
+	uint	r12;
+	uint	r13;
+	uint	r14;
+	uint	link;
+	uint	type;
+	uint	psr;
+	uint	pc;
+};
diff --git a/utils/libmach/ureg6.h b/utils/libmach/ureg6.h
new file mode 100644
index 00000000..46fa1f61
--- /dev/null
+++ b/utils/libmach/ureg6.h
@@ -0,0 +1,30 @@
+struct Ureg
+{
+	uvlong	r15;	/* general registers */
+	uvlong	r14;
+	uvlong	r13;
+	uvlong	r12;
+	uvlong	r11;
+	uvlong	r10;
+	uvlong	r9;
+	uvlong	r8;
+	uvlong	di;
+	uvlong	si;		/* ... */
+	uvlong	bp;		/* ... */
+	uvlong	nsp;
+	uvlong	bx;		/* ... */
+	uvlong	dx;		/* ... */
+	uvlong	cx;		/* ... */
+	uvlong	ax;		/* ... */
+	uvlong	gs;		/* data segments */
+	uvlong	fs;		/* ... */
+	uvlong	es;		/* ... */
+	uvlong	ds;		/* ... */
+	uvlong	trap;		/* trap type */
+	uvlong	ecode;		/* error code (or zero) */
+	uvlong	pc;		/* pc */
+	uvlong	cs;		/* old context */
+	uvlong	flags;		/* old flags */
+	uvlong	sp;
+	uvlong	ss;		/* old stack segment */
+};
diff --git a/utils/libmach/ureg8.h b/utils/libmach/ureg8.h
new file mode 100644
index 00000000..8bdf178d
--- /dev/null
+++ b/utils/libmach/ureg8.h
@@ -0,0 +1,25 @@
+struct Ureg
+{
+	ulong	di;		/* general registers */
+	ulong	si;		/* ... */
+	ulong	bp;		/* ... */
+	ulong	nsp;
+	ulong	bx;		/* ... */
+	ulong	dx;		/* ... */
+	ulong	cx;		/* ... */
+	ulong	ax;		/* ... */
+	ulong	gs;		/* data segments */
+	ulong	fs;		/* ... */
+	ulong	es;		/* ... */
+	ulong	ds;		/* ... */
+	ulong	trap;		/* trap type */
+	ulong	ecode;		/* error code (or zero) */
+	ulong	pc;		/* pc */
+	ulong	cs;		/* old context */
+	ulong	flags;		/* old flags */
+	union {
+		ulong	usp;
+		ulong	sp;
+	} u0;
+	ulong	ss;		/* old stack segment */
+};
diff --git a/utils/libmach/uregk.h b/utils/libmach/uregk.h
new file mode 100644
index 00000000..4ff12edc
--- /dev/null
+++ b/utils/libmach/uregk.h
@@ -0,0 +1,45 @@
+struct Ureg
+{
+	ulong	r0;			/* unnecessary; just for symmetry */
+	union{
+		ulong	sp;		/* r1 */
+		ulong	usp;		/* r1 */
+		ulong	r1;
+	} u0;
+	ulong	r2;
+	ulong	r3;
+	ulong	r4;
+	ulong	r5;
+	ulong	r6;
+	ulong	r7;
+	ulong	r8;
+	ulong	r9;
+	ulong	r10;
+	ulong	r11;
+	ulong	r12;
+	ulong	r13;
+	ulong	r14;
+	ulong	r15;
+	ulong	r16;
+	ulong	r17;
+	ulong	r18;
+	ulong	r19;
+	ulong	r20;
+	ulong	r21;
+	ulong	r22;
+	ulong	r23;
+	ulong	r24;
+	ulong	r25;
+	ulong	r26;
+	ulong	r27;
+	ulong	r28;
+	ulong	r29;
+	ulong	r30;
+	ulong	r31;
+	ulong	y;
+	ulong	tbr;
+	ulong	psr;
+	ulong	npc;
+	ulong	pc;
+	ulong	pad;	/* so structure is double word aligned */
+};
diff --git a/utils/libmach/uregq.h b/utils/libmach/uregq.h
new file mode 100644
index 00000000..409b13d3
--- /dev/null
+++ b/utils/libmach/uregq.h
@@ -0,0 +1,43 @@
+struct Ureg
+{
+	ulong	cause;
+	ulong	status;
+	ulong	pc;	/* SRR0 */
+	ulong	pad;
+	ulong	lr;
+	ulong	cr;
+	ulong	xer;
+	ulong	ctr;
+	ulong	r0;
+	ulong	sp;
+	ulong	r2;
+	ulong	r3;
+	ulong	r4;
+	ulong	r5;
+	ulong	r6;
+	ulong	r7;
+	ulong	r8;
+	ulong	r9;
+	ulong	r10;
+	ulong	r11;
+	ulong	r12;
+	ulong	r13;
+	ulong	r14;
+	ulong	r15;
+	ulong	r16;
+	ulong	r17;
+	ulong	r18;
+	ulong	r19;
+	ulong	r20;
+	ulong	r21;
+	ulong	r22;
+	ulong	r23;
+	ulong	r24;
+	ulong	r25;
+	ulong	r26;
+	ulong	r27;
+	ulong	r28;
+	ulong	r29;
+	ulong	r30;
+	ulong	r31;
+};
diff --git a/utils/libmach/uregt.h b/utils/libmach/uregt.h
new file mode 100644
index 00000000..ffdad423
--- /dev/null
+++ b/utils/libmach/uregt.h
@@ -0,0 +1,21 @@
+struct Ureg {
+	uint	r0;
+	uint	r1;
+	uint	r2;
+	uint	r3;
+	uint	r4;
+	uint	r5;
+	uint	r6;
+	uint	r7;
+	uint	r8;
+	uint	r9;
+	uint	r10;
+	uint	r11;
+	uint	r12;
+	uint	r13;
+	uint	r14;
+	uint	link;
+	uint	type;
+	uint	psr;
+	uint	pc;
+};
diff --git a/utils/libmach/uregv.h b/utils/libmach/uregv.h
new file mode 100644
index 00000000..def45d2d
--- /dev/null
+++ b/utils/libmach/uregv.h
@@ -0,0 +1,44 @@
+struct Ureg
+{
+	ulong	status;
+	ulong	pc;
+	union{
+		ulong	sp;		/* r29 */
+		ulong	usp;		/* r29 */
+	} u0;
+	ulong	cause;
+	ulong	badvaddr;
+	ulong	tlbvirt;
+	ulong	hi;
+	ulong	lo;
+	ulong	r31;
+	ulong	r30;
+	ulong	r28;
+	ulong	r27;		/* unused */
+	ulong	r26;		/* unused */
+	ulong	r25;
+	ulong	r24;
+	ulong	r23;
+	ulong	r22;
+	ulong	r21;
+	ulong	r20;
+	ulong	r19;
+	ulong	r18;
+	ulong	r17;
+	ulong	r16;
+	ulong	r15;
+	ulong	r14;
+	ulong	r13;
+	ulong	r12;
+	ulong	r11;
+	ulong	r10;
+	ulong	r9;
+	ulong	r8;
+	ulong	r7;
+	ulong	r6;
+	ulong	r5;
+	ulong	r4;
+	ulong	r3;
+	ulong	r2;
+	ulong	r1;
+};
diff --git a/utils/libmach/v.c b/utils/libmach/v.c
new file mode 100644
index 00000000..add94113
--- /dev/null
+++ b/utils/libmach/v.c
@@ -0,0 +1,116 @@
+/*
+ * mips definition
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "uregv.h"
+#include "mach.h"
+
+#define	REGOFF(x)	(ulong)(&((struct Ureg *) 0)->x)
+
+#define SP		REGOFF(u0.sp)
+#define PC		REGOFF(pc)
+#define	R1		REGOFF(r1)
+#define	R31		REGOFF(r31)
+#define	FP_REG(x)	(R1+4+4*(x))
+
+#define	REGSIZE		sizeof(struct Ureg)
+#define	FPREGSIZE	(4*33)
+
+Reglist mipsreglist[] = {
+	{"STATUS",	REGOFF(status),		RINT|RRDONLY, 'X'},
+	{"CAUSE",	REGOFF(cause),		RINT|RRDONLY, 'X'},
+	{"BADVADDR",	REGOFF(badvaddr),	RINT|RRDONLY, 'X'},
+	{"TLBVIRT",	REGOFF(tlbvirt),	RINT|RRDONLY, 'X'},
+	{"HI",		REGOFF(hi),		RINT|RRDONLY, 'X'},
+	{"LO",		REGOFF(lo),		RINT|RRDONLY, 'X'},
+	{"PC",		PC,		RINT, 'X'},
+	{"SP",		SP,		RINT, 'X'},
+	{"R31",		R31,		RINT, 'X'},
+	{"R30",		REGOFF(r30),	RINT, 'X'},
+	{"R28",		REGOFF(r28),	RINT, 'X'},
+	{"R27",		REGOFF(r27),	RINT, 'X'},
+	{"R26",		REGOFF(r26),	RINT, 'X'},
+	{"R25",		REGOFF(r25),	RINT, 'X'},
+	{"R24",		REGOFF(r24),	RINT, 'X'},
+	{"R23",		REGOFF(r23),	RINT, 'X'},
+	{"R22",		REGOFF(r22),	RINT, 'X'},
+	{"R21",		REGOFF(r21),	RINT, 'X'},
+	{"R20",		REGOFF(r20),	RINT, 'X'},
+	{"R19",		REGOFF(r19),	RINT, 'X'},
+	{"R18",		REGOFF(r18),	RINT, 'X'},
+	{"R17",		REGOFF(r17),	RINT, 'X'},
+	{"R16",		REGOFF(r16),	RINT, 'X'},
+	{"R15",		REGOFF(r15),	RINT, 'X'},
+	{"R14",		REGOFF(r14),	RINT, 'X'},
+	{"R13",		REGOFF(r13),	RINT, 'X'},
+	{"R12",		REGOFF(r12),	RINT, 'X'},
+	{"R11",		REGOFF(r11),	RINT, 'X'},
+	{"R10",		REGOFF(r10),	RINT, 'X'},
+	{"R9",		REGOFF(r9),	RINT, 'X'},
+	{"R8",		REGOFF(r8),	RINT, 'X'},
+	{"R7",		REGOFF(r7),	RINT, 'X'},
+	{"R6",		REGOFF(r6),	RINT, 'X'},
+	{"R5",		REGOFF(r5),	RINT, 'X'},
+	{"R4",		REGOFF(r4),	RINT, 'X'},
+	{"R3",		REGOFF(r3),	RINT, 'X'},
+	{"R2",		REGOFF(r2),	RINT, 'X'},
+	{"R1",		REGOFF(r1),	RINT, 'X'},
+	{"F0",		FP_REG(0),	RFLT, 'F'},
+	{"F1",		FP_REG(1),	RFLT, 'f'},
+	{"F2",		FP_REG(2),	RFLT, 'F'},
+	{"F3",		FP_REG(3),	RFLT, 'f'},
+	{"F4",		FP_REG(4),	RFLT, 'F'},
+	{"F5",		FP_REG(5),	RFLT, 'f'},
+	{"F6",		FP_REG(6),	RFLT, 'F'},
+	{"F7",		FP_REG(7),	RFLT, 'f'},
+	{"F8",		FP_REG(8),	RFLT, 'F'},
+	{"F9",		FP_REG(9),	RFLT, 'f'},
+	{"F10",		FP_REG(10),	RFLT, 'F'},
+	{"F11",		FP_REG(11),	RFLT, 'f'},
+	{"F12",		FP_REG(12),	RFLT, 'F'},
+	{"F13",		FP_REG(13),	RFLT, 'f'},
+	{"F14",		FP_REG(14),	RFLT, 'F'},
+	{"F15",		FP_REG(15),	RFLT, 'f'},
+	{"F16",		FP_REG(16),	RFLT, 'F'},
+	{"F17",		FP_REG(17),	RFLT, 'f'},
+	{"F18",		FP_REG(18),	RFLT, 'F'},
+	{"F19",		FP_REG(19),	RFLT, 'f'},
+	{"F20",		FP_REG(20),	RFLT, 'F'},
+	{"F21",		FP_REG(21),	RFLT, 'f'},
+	{"F22",		FP_REG(22),	RFLT, 'F'},
+	{"F23",		FP_REG(23),	RFLT, 'f'},
+	{"F24",		FP_REG(24),	RFLT, 'F'},
+	{"F25",		FP_REG(25),	RFLT, 'f'},
+	{"F26",		FP_REG(26),	RFLT, 'F'},
+	{"F27",		FP_REG(27),	RFLT, 'f'},
+	{"F28",		FP_REG(28),	RFLT, 'F'},
+	{"F29",		FP_REG(29),	RFLT, 'f'},
+	{"F30",		FP_REG(30),	RFLT, 'F'},
+	{"F31",		FP_REG(31),	RFLT, 'f'},
+	{"FPCR",	FP_REG(32),	RFLT, 'X'},
+	{  0 }
+};
+
+	/* the machine description */
+Mach mmips =
+{
+	"mips",
+	MMIPS,		/* machine type */
+	mipsreglist,	/* register set */
+	REGSIZE,	/* number of bytes in reg set */
+	FPREGSIZE,	/* number of bytes in fp reg set */
+	"PC",		/* name of PC */
+	"SP",		/* name of SP */
+	"R31",		/* name of link register */
+	"setR30",	/* static base register name */
+	0,		/* value */
+	0x1000,		/* page size */
+	0xC0000000,	/* kernel base */
+	0x40000000,	/* kernel text mask */
+	4,		/* quantization of pc */
+	4,		/* szaddr */
+	4,		/* szreg */
+	4,		/* szfloat */
+	8,		/* szdouble */
+};
diff --git a/utils/libmach/vcodas.c b/utils/libmach/vcodas.c
new file mode 100644
index 00000000..ce505ea2
--- /dev/null
+++ b/utils/libmach/vcodas.c
@@ -0,0 +1,553 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+
+	/* mips native disassembler */
+
+typedef struct {
+	long addr;			/* pc of instr */
+	uchar op;			/* bits 31-26 */
+	uchar rs;			/* bits 25-21 */
+	uchar rt;			/* bits 20-16 */
+	uchar rd;			/* bits 15-11 */
+	uchar sa;			/* bits 10-6 */
+	uchar function;			/* bits 5-0 */
+	long immediate;			/* bits 15-0 */
+	ulong cofun;			/* bits 24-0 */
+	ulong target;			/* bits 25-0 */
+	long w0;
+	char *curr;			/* current fill point */
+	char *end;			/* end of buffer */
+	char *err;
+} Instr;
+
+typedef struct {
+	char *mnemonic;
+	char *mipsco;
+} Opcode;
+
+static char mipscoload[] = "r%t,%l";
+static char mipscoalui[] = "r%t,r%s,%i";
+static char mipscoalu3op[] = "r%d,r%s,r%t";
+static char mipscoboc[] = "r%s,r%t,%b";
+static char mipscoboc0[] = "r%s,%b";
+static char mipscorsrt[] = "r%s,r%t";
+static char mipscorsi[] = "r%s,%i";
+static char mipscoxxx[] = "%w";
+static char mipscofp3[] = "f%a,f%d,f%t";	/* fd,fs,ft */
+static char mipscofp2[] = "f%a,f%d";		/* fd,fs */
+static char mipscofpc[] = "f%d,f%t";		/* fs,ft */
+
+static Opcode opcodes[64] = {
+	0,		0,
+	0,		0,
+	"j",		"%j",
+	"jal",		"%j",
+	"beq",		mipscoboc,
+	"bne",		mipscoboc,
+	"blez",		mipscoboc0,
+	"bgtz",		mipscoboc0,
+	"addi",		mipscoalui,
+	"addiu",	mipscoalui,
+	"slti",		mipscoalui,
+	"sltiu",	mipscoalui,
+	"andi",		mipscoalui,
+	"ori",		mipscoalui,
+	"xori",		mipscoalui,
+	"lui",		"r%t,%u",
+	"cop0",		0,
+	"cop1",		0,
+	"cop2",		0,
+	"cop3",		0,
+	"beql",		mipscoboc,
+	"bnel",		mipscoboc,
+	"blezl",	mipscoboc0,
+	"bgtzl",	mipscoboc0,
+	"instr18",	mipscoxxx,
+	"instr19",	mipscoxxx,
+	"instr1A",	mipscoxxx,
+	"instr1B",	mipscoxxx,
+	"instr1C",	mipscoxxx,
+	"instr1D",	mipscoxxx,
+	"instr1E",	mipscoxxx,
+	"instr1F",	mipscoxxx,
+	"lb",		mipscoload,
+	"lh",		mipscoload,
+	"lwl",		mipscoload,
+	"lw",		mipscoload,
+	"lbu",		mipscoload,
+	"lhu",		mipscoload,
+	"lwr",		mipscoload,
+	"instr27",	mipscoxxx,
+	"sb",		mipscoload,
+	"sh",		mipscoload,
+	"swl",		mipscoload,
+	"sw",		mipscoload,
+	"instr2C",	mipscoxxx,
+	"instr2D",	mipscoxxx,
+	"swr",		mipscoload,
+	"cache",	"",
+	"ll",		mipscoload,
+	"lwc1",		mipscoload,
+	"lwc2",		mipscoload,
+	"lwc3",		mipscoload,
+	"instr34",	mipscoxxx,
+	"ld",		mipscoload,
+	"ld",		mipscoload,
+	"ld",		mipscoload,
+	"sc",		mipscoload,
+	"swc1",		mipscoload,
+	"swc2",		mipscoload,
+	"swc3",		mipscoload,
+	"instr3C",	mipscoxxx,
+	"sd",		mipscoload,
+	"sd",		mipscoload,
+	"sd",		mipscoload,
+};
+
+static Opcode sopcodes[64] = {
+	"sll",		"r%d,r%t,$%a",
+	"special01",	mipscoxxx,
+	"srl",		"r%d,r%t,$%a",
+	"sra",		"r%d,r%t,$%a",
+	"sllv",		"r%d,r%t,R%s",
+	"special05",	mipscoxxx,
+	"srlv",		"r%d,r%t,r%s",
+	"srav",		"r%d,r%t,r%s",
+	"jr",		"r%s",
+	"jalr",		"r%d,r%s",
+	"special0A",	mipscoxxx,
+	"special0B",	mipscoxxx,
+	"syscall",	"",
+	"break",	"",
+	"special0E",	mipscoxxx,
+	"sync",		"",
+	"mfhi",		"r%d",
+	"mthi",		"r%s",
+	"mflo",		"r%d",
+	"mtlo",		"r%s",
+	"special14",	mipscoxxx,
+	"special15",	mipscoxxx,
+	"special16",	mipscoxxx,
+	"special17",	mipscoxxx,
+	"mult",		mipscorsrt,
+	"multu",	mipscorsrt,
+	"div",		mipscorsrt,
+	"divu",		mipscorsrt,
+	"special1C",	mipscoxxx,
+	"special1D",	mipscoxxx,
+	"special1E",	mipscoxxx,
+	"special1F",	mipscoxxx,
+	"add",		mipscoalu3op,
+	"addu",		mipscoalu3op,
+	"sub",		mipscoalu3op,
+	"subu",		mipscoalu3op,
+	"and",		mipscoalu3op,
+	"or",		mipscoalu3op,
+	"xor",		mipscoalu3op,
+	"nor",		mipscoalu3op,
+	"special28",	mipscoxxx,
+	"special29",	mipscoxxx,
+	"slt",		mipscoalu3op,
+	"sltu",		mipscoalu3op,
+	"special2C",	mipscoxxx,
+	"special2D",	mipscoxxx,
+	"special2E",	mipscoxxx,
+	"special2F",	mipscoxxx,
+	"tge",		mipscorsrt,
+	"tgeu",		mipscorsrt,
+	"tlt",		mipscorsrt,
+	"tltu",		mipscorsrt,
+	"teq",		mipscorsrt,
+	"special35",	mipscoxxx,
+	"tne",		mipscorsrt,
+	"special37",	mipscoxxx,
+	"special38",	mipscoxxx,
+	"special39",	mipscoxxx,
+	"special3A",	mipscoxxx,
+	"special3B",	mipscoxxx,
+	"special3C",	mipscoxxx,
+	"special3D",	mipscoxxx,
+	"special3E",	mipscoxxx,
+	"special3F",	mipscoxxx,
+};
+
+static Opcode ropcodes[32] = {
+	"bltz",		mipscoboc0,
+	"bgez",		mipscoboc0,
+	"bltzl",	mipscoboc0,
+	"bgezl",	mipscoboc0,
+	"regimm04",	mipscoxxx,
+	"regimm05",	mipscoxxx,
+	"regimm06",	mipscoxxx,
+	"regimm07",	mipscoxxx,
+	"tgei",		mipscorsi,
+	"tgeiu",	mipscorsi,
+	"tlti",		mipscorsi,
+	"tltiu",	mipscorsi,
+	"teqi",		mipscorsi,
+	"regimm0D",	mipscoxxx,
+	"tnei",		mipscorsi,
+	"regimm0F",	mipscoxxx,
+	"bltzal",	mipscoboc0,
+	"bgezal",	mipscoboc0,
+	"bltzall",	mipscoboc0,
+	"bgezall",	mipscoboc0,
+	"regimm14",	mipscoxxx,
+	"regimm15",	mipscoxxx,
+	"regimm16",	mipscoxxx,
+	"regimm17",	mipscoxxx,
+	"regimm18",	mipscoxxx,
+	"regimm19",	mipscoxxx,
+	"regimm1A",	mipscoxxx,
+	"regimm1B",	mipscoxxx,
+	"regimm1C",	mipscoxxx,
+	"regimm1D",	mipscoxxx,
+	"regimm1E",	mipscoxxx,
+	"regimm1F",	mipscoxxx,
+};
+
+static Opcode fopcodes[64] = {
+	"add.%f",	mipscofp3,
+	"sub.%f",	mipscofp3,
+	"mul.%f",	mipscofp3,
+	"div.%f",	mipscofp3,
+	"sqrt.%f",	mipscofp2,
+	"abs.%f",	mipscofp2,
+	"mov.%f",	mipscofp2,
+	"neg.%f",	mipscofp2,
+	"finstr08",	mipscoxxx,
+	"finstr09",	mipscoxxx,
+	"finstr0A",	mipscoxxx,
+	"finstr0B",	mipscoxxx,
+	"round.w.%f",	mipscofp2,
+	"trunc.w%f",	mipscofp2,
+	"ceil.w%f",	mipscofp2,
+	"floor.w%f",	mipscofp2,
+	"finstr10",	mipscoxxx,
+	"finstr11",	mipscoxxx,
+	"finstr12",	mipscoxxx,
+	"finstr13",	mipscoxxx,
+	"finstr14",	mipscoxxx,
+	"finstr15",	mipscoxxx,
+	"finstr16",	mipscoxxx,
+	"finstr17",	mipscoxxx,
+	"finstr18",	mipscoxxx,
+	"finstr19",	mipscoxxx,
+	"finstr1A",	mipscoxxx,
+	"finstr1B",	mipscoxxx,
+	"finstr1C",	mipscoxxx,
+	"finstr1D",	mipscoxxx,
+	"finstr1E",	mipscoxxx,
+	"finstr1F",	mipscoxxx,
+	"cvt.s.%f",	mipscofp2,
+	"cvt.d.%f",	mipscofp2,
+	"cvt.e.%f",	mipscofp2,
+	"cvt.q.%f",	mipscofp2,
+	"cvt.w.%f",	mipscofp2,
+	"finstr25",	mipscoxxx,
+	"finstr26",	mipscoxxx,
+	"finstr27",	mipscoxxx,
+	"finstr28",	mipscoxxx,
+	"finstr29",	mipscoxxx,
+	"finstr2A",	mipscoxxx,
+	"finstr2B",	mipscoxxx,
+	"finstr2C",	mipscoxxx,
+	"finstr2D",	mipscoxxx,
+	"finstr2E",	mipscoxxx,
+	"finstr2F",	mipscoxxx,
+	"c.f.%f",	mipscofpc,
+	"c.un.%f",	mipscofpc,
+	"c.eq.%f",	mipscofpc,
+	"c.ueq.%f",	mipscofpc,
+	"c.olt.%f",	mipscofpc,
+	"c.ult.%f",	mipscofpc,
+	"c.ole.%f",	mipscofpc,
+	"c.ule.%f",	mipscofpc,
+	"c.sf.%f",	mipscofpc,
+	"c.ngle.%f",	mipscofpc,
+	"c.seq.%f",	mipscofpc,
+	"c.ngl.%f",	mipscofpc,
+	"c.lt.%f",	mipscofpc,
+	"c.nge.%f",	mipscofpc,
+	"c.le.%f",	mipscofpc,
+	"c.ngt.%f",	mipscofpc,
+};
+
+static char fsub[16] = {
+	's', 'd', 'e', 'q', 'w', '?', '?', '?',
+	'?', '?', '?', '?', '?', '?', '?', '?'
+};
+
+
+static int
+mkinstr(Instr *i, Map *map, ulong pc)
+{
+	long w;
+
+	if (get4(map, pc, &w) < 0) {
+		werrstr("can't read instruction: %r");
+		return -1;
+	}
+	i->addr = pc;
+	i->op = (w >> 26) & 0x3F;
+	i->rs = (w >> 21) & 0x1F;
+	i->rt = (w >> 16) & 0x1F;
+	i->rd = (w >> 11) & 0x1F;
+	i->sa = (w >> 6) & 0x1F;
+	i->function = w & 0x3F;
+	i->immediate = w & 0x0000FFFF;
+	if (i->immediate & 0x8000)
+		i->immediate |= ~0x0000FFFF;
+	i->cofun = w & 0x01FFFFFF;
+	i->target = w & 0x03FFFFFF;
+	i->w0 = w;
+	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);
+}
+
+static void
+format(char *mnemonic, Instr *i, char *f)
+{
+	if (mnemonic)
+		format(0, i, mnemonic);
+	if (f == 0)
+		return;
+	if (i->curr < i->end)
+		*i->curr++ = '\t';
+	for ( ; *f && i->curr < i->end; f++) {
+		if (*f != '%') {
+			*i->curr++ = *f;
+			continue;
+		}
+		switch (*++f) {
+
+		case 's':
+			bprint(i, "%d", i->rs);
+			break;
+
+		case 't':
+			bprint(i, "%d", i->rt);
+			break;
+
+		case 'd':
+			bprint(i, "%d", i->rd);
+			break;
+
+		case 'a':
+			bprint(i, "%d", i->sa);
+			break;
+
+		case 'l':
+			if (i->rs == 30) {
+				i->curr += symoff(i->curr, i->end-i->curr, i->immediate+mach->sb, CANY);
+				bprint(i, "(SB)");
+			} else 
+				bprint(i, "%lx(r%d)", i->immediate, i->rs);
+			break;
+
+		case 'i':
+			bprint(i, "$%lx", i->immediate);
+			break;
+
+		case 'u':
+			*i->curr++ = '$';
+			i->curr += symoff(i->curr, i->end-i->curr, i->immediate, CANY);
+			bprint(i, "(SB)");
+			break;
+
+		case 'j':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				(i->target<<2)|(i->addr & 0xF0000000), CANY);
+			bprint(i, "(SB)");
+			break;
+
+		case 'b':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				(i->immediate<<2)+i->addr+4, CANY);
+			break;
+
+		case 'c':
+			bprint(i, "%lux", i->cofun);
+			break;
+
+		case 'w':
+			bprint(i, "[%lux]", i->w0);
+			break;
+
+		case 'f':
+			*i->curr++ = fsub[i->rs & 0x0F];
+			break;
+
+		case '\0':
+			*i->curr++ = '%';
+			return;
+
+		default:
+			bprint(i, "%%%c", *f);
+			break;
+		}
+	}
+}
+
+static void
+copz(int cop, Instr *i)
+{
+	char *f, *m, buf[16];
+
+	m = buf;
+	f = "%t,%d";
+	switch (i->rs) {
+
+	case 0:
+		sprint(buf, "mfc%d", cop);
+		break;
+
+	case 2:
+		sprint(buf, "cfc%d", cop);
+		break;
+
+	case 4:
+		sprint(buf, "mtc%d", cop);
+		break;
+
+	case 6:
+		sprint(buf, "ctc%d", cop);
+		break;
+
+	case 8:
+		f = "%b";
+		switch (i->rt) {
+
+		case 0:
+			sprint(buf, "bc%df", cop);
+			break;
+
+		case 1:
+			sprint(buf, "bc%dt", cop);
+			break;
+
+		case 2:
+			sprint(buf, "bc%dfl", cop);
+			break;
+
+		case 3:
+			sprint(buf, "bc%dtl", cop);
+			break;
+
+		default:
+			sprint(buf, "cop%d", cop);
+			f = mipscoxxx;
+			break;
+		}
+		break;
+
+	default:
+		sprint(buf, "cop%d", cop);
+		if (i->rs & 0x10)
+			f = "function %c";
+		else
+			f = mipscoxxx;
+		break;
+	}
+	format(m, i, f);
+}
+
+static void
+cop0(Instr *i)
+{
+	char *m = 0;
+
+	if (i->rs >= 0x10) {
+		switch (i->cofun) {
+	
+		case 1:
+			m = "tlbr";
+			break;
+	
+		case 2:
+			m = "tlbwi";
+			break;
+	
+		case 6:
+			m = "tlbwr";
+			break;
+	
+		case 8:
+			m = "tlbp";
+			break;
+	
+		case 16:
+			m = "rfe";
+			break;
+	
+		case 32:
+			m = "eret";
+			break;
+		}
+		if (m) {
+			format(m, i, 0);
+			if (i->curr < i->end)
+				*i->curr++ = 0;
+			return;
+		}
+	}
+	copz(0, i);
+}
+
+int
+_mipscoinst(Map *map, ulong pc, char *buf, int n)
+{
+	Instr i;
+	Opcode *o;
+	uchar op;
+
+	i.curr = buf;
+	i.end = buf+n-1;
+	if (mkinstr(&i, map, pc) < 0)
+		return -1;
+	switch (i.op) {
+
+	case 0x00:					/* SPECIAL */
+		o = sopcodes;
+		op = i.function;
+		break;
+
+	case 0x01:					/* REGIMM */
+		o = ropcodes;
+		op = i.rt;
+		break;
+
+	case 0x10:					/* COP0 */
+		cop0(&i);
+		return 4;
+
+	case 0x11:					/* COP1 */
+		if (i.rs & 0x10) {
+			o = fopcodes;
+			op = i.function;
+			break;
+		}
+		/*FALLTHROUGH*/
+	case 0x12:					/* COP2 */
+	case 0x13:					/* COP3 */
+		copz(i.op-0x10, &i);
+		return 4;
+
+	default:
+		o = opcodes;
+		op = i.op;
+		break;
+	}
+	format(o[op].mnemonic, &i, o[op].mipsco);
+	return 4;
+}
diff --git a/utils/libmach/vdb.c b/utils/libmach/vdb.c
new file mode 100644
index 00000000..0624a106
--- /dev/null
+++ b/utils/libmach/vdb.c
@@ -0,0 +1,1094 @@
+#include <lib9.h>
+#include <bio.h>
+#include "mach.h"
+/*
+ * Mips-specific debugger interface
+ */
+
+extern	char	*mipsexcep(Map*, Rgetter);
+extern	int	mipsfoll(Map*, ulong, Rgetter, ulong*);
+extern	int	mipsinst(Map*, ulong, char, char*, int);
+extern	int	mipsdas(Map*, ulong, char*, int);
+extern	int	mipsinstlen(Map*, ulong);
+/*
+ *	Debugger interface
+ */
+Machdata mipsmach =
+{
+	{0, 0, 0, 0xD},		/* break point */
+	4,			/* break point size */
+
+	beswab,			/* short to local byte order */
+	beswal,			/* long to local byte order */
+	beswav,			/* vlong to local byte order */
+	risctrace,		/* C traceback */
+	riscframe,		/* Frame finder */
+	mipsexcep,		/* print exception */
+	0,			/* breakpoint fixup */
+	beieeesftos,		/* single precision float printer */
+	beieeedftos,		/* double precisioin float printer */
+	mipsfoll,		/* following addresses */
+	mipsinst,		/* print instruction */
+	mipsdas,		/* dissembler */
+	mipsinstlen,		/* instruction size */
+};
+
+static char *excname[] =
+{
+	"external interrupt",
+	"TLB modification",
+	"TLB miss (load or fetch)",
+	"TLB miss (store)",
+	"address error (load or fetch)",
+	"address error (store)",
+	"bus error (fetch)",
+	"bus error (data load or store)",
+	"system call",
+	"breakpoint",
+	"reserved instruction",
+	"coprocessor unusable",
+	"arithmetic overflow",
+	"undefined 13",
+	"undefined 14",
+	"system call",
+	/* the following is made up */
+	"floating point exception"		/* FPEXC */
+};
+
+char*
+mipsexcep(Map *map, Rgetter rget)
+{
+	int e;
+	long c;
+
+	c = (*rget)(map, "CAUSE");
+	if(c & 0x00002000)	/* INTR3 */
+		e = 16;		/* Floating point exception */
+	else
+		e = (c>>2)&0x0F;
+	return excname[e];
+}
+
+	/* mips disassembler and related functions */
+
+static	char FRAMENAME[] = ".frame";
+
+typedef struct {
+	ulong addr;
+	uchar op;			/* bits 31-26 */
+	uchar rs;			/* bits 25-21 */
+	uchar rt;			/* bits 20-16 */
+	uchar rd;			/* bits 15-11 */
+	uchar sa;			/* bits 10-6 */
+	uchar function;			/* bits 5-0 */
+	long immediate;			/* bits 15-0 */
+	ulong cofun;			/* bits 24-0 */
+	ulong target;			/* bits 25-0 */
+	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->rs = (w >> 21) & 0x1F;
+	i->rt = (w >> 16) & 0x1F;
+	i->rd = (w >> 11) & 0x1F;
+	i->sa = (w >> 6) & 0x1F;
+	i->function = w & 0x3F;
+	i->immediate = w & 0x0000FFFF;
+	if (i->immediate & 0x8000)
+		i->immediate |= ~0x0000FFFF;
+	i->cofun = w & 0x01FFFFFF;
+	i->target = w & 0x03FFFFFF;
+	i->w0 = w;
+	return 1;
+}
+
+static int
+mkinstr(ulong pc, Instr *i)
+{
+	Instr x;
+
+	if (decode(pc, i) < 0)
+		return -1;
+	/*
+	 * 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;
+		}
+	}
+	/*
+	 * if it's a LWC1 followed by another LWC1
+	 * into an adjacent register, it's a load of
+	 * a floating point double.
+	 */
+	else if (i->op == 0x31 && (i->rt & 0x01)) {
+		if (decode(pc+4, &x) < 0)
+			return 0;
+		if (x.op == 0x31 && x.rt == (i->rt - 1) && x.rs == i->rs) {
+			i->rt -= 1;
+			i->w1 = x.w0;
+			i->size++;
+			return 1;
+		}
+	}
+	/*
+	 * similarly for double stores
+	 */
+	else if (i->op == 0x39 && (i->rt & 0x01)) {
+		if (decode(pc+4, &x) < 0)
+			return 0;
+		if (x.op == 0x39 && x.rt == (i->rt - 1) && x.rs == i->rs) {
+			i->rt -= 1;
+			i->w1 = x.w0;
+			i->size++;
+		}
+	}
+	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 void
+branch(Opcode *o, Instr *i)
+{
+	if (i->rs == 0 && i->rt == 0)
+		format("JMP", i, "%b");
+	else if (i->rs == 0)
+		format(o->mnemonic, i, "R%t,%b");
+	else if (i->rt < 2)
+		format(o->mnemonic, i, "R%s,%b");
+	else
+		format(o->mnemonic, i, "R%s,R%t,%b");
+}
+
+static void
+addi(Opcode *o, Instr *i)
+{
+	if (i->rs == i->rt)
+		format(o->mnemonic, i, "%i,R%t");
+	else if (i->rs == 0)
+		format("MOVW", i, "%i,R%t");
+	else if (i->rs == 30) {
+		bprint(i, "MOVW\t$");
+		i->curr += symoff(i->curr, i->end-i->curr,
+					i->immediate+mach->sb, CANY);
+		bprint(i, "(SB),R%d", i->rt);
+	}
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+andi(Opcode *o, Instr *i)
+{
+	if (i->rs == i->rt)
+		format(o->mnemonic, i, "%i,R%t");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+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->immediate) {
+		if(!getauto(&s, s.value-i->immediate, CAUTO, &s))
+			return 0;
+		reg = "(SP)";
+		offset = i->immediate;
+	} else {
+		offset = i->immediate-s.value;
+		if (!getauto(&s, offset-4, CPARAM, &s))
+			return 0;
+		reg = "(FP)";
+	}
+	if (store)
+		bprint(i, "%s\t%c%d,%s+%d%s", m, r, i->rt, s.name, offset, reg);
+	else
+		bprint(i, "%s\t%s+%d%s,%c%d", m, s.name, offset, reg, r, i->rt);
+	return 1;
+}
+
+static void
+lw(Opcode *o, Instr *i, char r)
+{
+	char *m;
+
+	if (r == 'F') {
+		if (i->size == 2)
+			m = "MOVD";
+		else
+			m = "MOVF";
+	}
+	else
+		m = o->mnemonic;
+	if (i->rs == 29 && plocal(i, m, r, 0))
+			return;
+
+	if (i->rs == 30 && mach->sb) {
+		bprint(i, "%s\t", m);
+		i->curr += symoff(i->curr, i->end-i->curr, i->immediate+mach->sb, CANY);
+		bprint(i, "(SB),%c%d", r, i->rt);
+		return;
+	}
+	if (r == 'F')
+		format(m, i, "%l,F%t");
+	else
+		format(m, i, o->ken);
+}
+
+static void
+load(Opcode *o, Instr *i)
+{
+	lw(o, i, 'R');
+}
+
+static void
+lwc1(Opcode *o, Instr *i)
+{
+	lw(o, i, 'F');
+}
+
+static void
+sw(Opcode *o, Instr *i, char r)
+{
+	char *m;
+
+	if (r == 'F') {
+		if (i->size == 2)
+			m = "MOVD";
+		else
+			m = "MOVF";
+	}
+	else
+		m = o->mnemonic;
+	if (i->rs == 29 && plocal(i, m, r, 1))
+			return;
+
+	if (i->rs == 30 && mach->sb) {
+		bprint(i, "%s\t%c%d,", m, r, i->rt);
+		i->curr += symoff(i->curr, i->end-i->curr, i->immediate+mach->sb, CANY);
+		bprint(i, "(SB)");
+		return;
+	}
+	if (r == 'F')
+		format(m, i, "F%t,%l");
+	else
+		format(m, i, o->ken);
+}
+
+static void
+store(Opcode *o, Instr *i)
+{
+	sw(o, i, 'R');
+}
+
+static void
+swc1(Opcode *o, Instr *i)
+{
+	sw(o, i, 'F');
+}
+
+static void
+sll(Opcode *o, Instr *i)
+{
+	if (i->w0 == 0)
+		bprint(i, "NOOP");
+	else if (i->rd == i->rt)
+		format(o->mnemonic, i, "$%a,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+sl32(Opcode *o, Instr *i)
+{
+	i->sa += 32;
+	if (i->rd == i->rt)
+		format(o->mnemonic, i, "$%a,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+sllv(Opcode *o, Instr *i)
+{
+	if (i->rd == i->rt)
+		format(o->mnemonic, i, "R%s,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+jal(Opcode *o, Instr *i)
+{
+	if (i->rd == 31)
+		format("JAL", i, "(R%s)");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+add(Opcode *o, Instr *i)
+{
+	if (i->rd == i->rs)
+		format(o->mnemonic, i, "R%t,R%d");
+	else if (i->rd == i->rt)
+		format(o->mnemonic, i, "R%s,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+sub(Opcode *o, Instr *i)
+{
+	if (i->rd == i->rs)
+		format(o->mnemonic, i, "R%t,R%d");
+	else
+		format(o->mnemonic, i, o->ken);
+}
+
+static void
+or(Opcode *o, Instr *i)
+{
+	if (i->rs == 0 && i->rt == 0)
+		format("MOVW", i, "$0,R%d");
+	else if (i->rs == 0)
+		format("MOVW", i, "R%t,R%d");
+	else if (i->rt == 0)
+		format("MOVW", i, "R%s,R%d");
+	else
+		add(o, i);
+}
+
+static void
+nor(Opcode *o, Instr *i)
+{
+	if (i->rs == 0 && i->rt == 0 && i->rd == 0)
+		format("NOP", i, 0);
+	else
+		add(o, i);
+}
+
+static char mipscoload[] = "r%t,%l";
+static char mipsload[] = "%l,R%t";
+static char mipsstore[] = "R%t,%l";
+static char mipsalui[] = "%i,R%s,R%t";
+static char mipsalu3op[] = "R%t,R%s,R%d";
+static char mipsrtrs[] = "R%t,R%s";
+static char mipscorsrt[] = "r%s,r%t";
+static char mipscorsi[] = "r%s,%i";
+static char mipscoxxx[] = "%w";
+static char mipscofp3[] = "f%a,f%d,f%t";	/* fd,fs,ft */
+static char mipsfp3[] = "F%t,F%d,F%a";
+static char mipscofp2[] = "f%a,f%d";		/* fd,fs */
+static char mipsfp2[] = "F%d,F%a";
+static char mipscofpc[] = "f%d,f%t";		/* fs,ft */
+static char mipsfpc[] = "F%t,F%d";
+
+static Opcode opcodes[64] = {
+	0,		0,	0,
+	0,		0,	0,
+	"JMP",		0,	"%j",
+	"JAL",		0,	"%j",
+	"BEQ",	   branch,	0,
+	"BNE",	   branch,	0,
+	"BLEZ",	   branch,	0,
+	"BGTZ",	   branch,	0,
+	"ADD",	     addi,	mipsalui,
+	"ADDU",	     addi,	mipsalui,
+	"SGT",		0,	mipsalui,
+	"SGTU",		0,	mipsalui,
+	"AND",	     andi,	mipsalui,
+	"OR",	     andi,	mipsalui,
+	"XOR",	     andi,	mipsalui,
+	"MOVW",		0,	"$%u,R%t",
+	"cop0",		0,	0,
+	"cop1",		0,	0,
+	"cop2",		0,	0,
+	"cop3",		0,	0,
+	"BEQL",	   branch,	0,
+	"BNEL",	   branch,	0,
+	"BLEZL",   branch,	0,
+	"BGTZL",   branch,	0,
+	"instr18",	0,	mipscoxxx,
+	"instr19",	0,	mipscoxxx,
+	"MOVVL",     load,	mipsload,
+	"MOVVR",     load,	mipsload,
+	"instr1C",	0,	mipscoxxx,
+	"instr1D",	0,	mipscoxxx,
+	"instr1E",	0,	mipscoxxx,
+	"instr1F",	0,	mipscoxxx,
+	"MOVB",	     load,	mipsload,
+	"MOVH",	     load,	mipsload,
+	"lwl",		0,	mipscoload,
+	"MOVW",	     load,	mipsload,
+	"MOVBU",     load,	mipsload,
+	"MOVHU",     load,	mipsload,
+	"lwr",		0,	mipscoload,
+	"instr27",	0,	mipscoxxx,
+	"MOVB",	    store,	mipsstore,
+	"MOVH",	    store,	mipsstore,
+	"swl",		0,	mipscoload,
+	"MOVW",	    store,	mipsstore,
+	"MOVVL",    store,	mipsstore,
+	"MOVVR",    store,	mipsstore,
+	"swr",		0,	mipscoload,
+	"CACHE",	0,	"%C,%l",
+	"ll",		0,	mipscoload,
+	"MOVW",	     lwc1,	mipscoload,
+	"lwc2",		0,	mipscoload,
+	"lwc3",		0,	mipscoload,
+	"instr34",	0,	mipscoxxx,
+	"ldc1",		0,	mipscoload,
+	"ldc2",		0,	mipscoload,
+	"MOVV",	    load,	mipsload,
+	"sc",		0,	mipscoload,
+	"swc1",	     swc1,	mipscoload,
+	"swc2",		0,	mipscoload,
+	"swc3",		0,	mipscoload,
+	"instr3C",	0,	mipscoxxx,
+	"sdc1",		0,	mipscoload,
+	"sdc2",		0,	mipscoload,
+	"MOVV",	    store,	mipsstore,
+};
+
+static Opcode sopcodes[64] = {
+	"SLL",	      sll,	"$%a,R%t,R%d",
+	"special01",	0,	mipscoxxx,
+	"SRL",	      sll,	"$%a,R%t,R%d",
+	"SRA",	      sll,	"$%a,R%t,R%d",
+	"SLL",	     sllv,	"R%s,R%t,R%d",
+	"special05",	0,	mipscoxxx,
+	"SRL",	     sllv,	"R%s,R%t,R%d",
+	"SRA",	     sllv,	"R%s,R%t,R%d",
+	"JMP",		0,	"(R%s)",
+	"jal",	      jal,	"r%d,r%s",
+	"special0A",	0,	mipscoxxx,
+	"special0B",	0,	mipscoxxx,
+	"SYSCALL",	0,	0,
+	"BREAK",	0,	0,
+	"special0E",	0,	mipscoxxx,
+	"SYNC",		0,	0,
+	"MOVW",		0,	"HI,R%d",
+	"MOVW",		0,	"R%s,HI",
+	"MOVW",		0,	"LO,R%d",
+	"MOVW",		0,	"R%s,LO",
+	"SLLV",	     sllv,	"R%s,R%t,R%d",
+	"special15",	0,	mipscoxxx,
+	"SRLV",	     sllv,	"R%s,R%t,R%d",
+	"SRAV",	     sllv,	"R%s,R%t,R%d",
+	"MUL",		0,	mipsrtrs,
+	"MULU",		0,	mipsrtrs,
+	"DIV",		0,	mipsrtrs,
+	"DIVU",		0,	mipsrtrs,
+	"special1C",	0,	mipscoxxx,
+	"special1D",	0,	mipscoxxx,
+	"DDIV",		0,	"R%s,R%t",
+	"special1F",	0,	mipscoxxx,
+	"ADD",	      add,	mipsalu3op,
+	"ADDU",	      add,	mipsalu3op,
+	"SUB",	      sub,	mipsalu3op,
+	"SUBU",	      sub,	mipsalu3op,
+	"AND",	      add,	mipsalu3op,
+	"OR",	       or,	mipsalu3op,
+	"XOR",	      add,	mipsalu3op,
+	"NOR",	      nor,	mipsalu3op,
+	"special28",	0,	mipscoxxx,
+	"special29",	0,	mipscoxxx,
+	"SGT",		0,	mipsalu3op,
+	"SGTU",		0,	mipsalu3op,
+	"special2C",	0,	mipscoxxx,
+	"special2D",	0,	mipscoxxx,
+	"special2E",	0,	mipscoxxx,
+	"DSUBU",	0,	"R%s,R%t,R%d",
+	"tge",		0,	mipscorsrt,
+	"tgeu",		0,	mipscorsrt,
+	"tlt",		0,	mipscorsrt,
+	"tltu",		0,	mipscorsrt,
+	"teq",		0,	mipscorsrt,
+	"special35",	0,	mipscoxxx,
+	"tne",		0,	mipscorsrt,
+	"special37",	0,	mipscoxxx,
+	"SLLV",	      sll,	"$%a,R%t,R%d",
+	"special39",	0,	mipscoxxx,
+	"SRLV",	      sll,	"$%a,R%t,R%d",
+	"SRAV",	      sll,	"$%a,R%t,R%d",
+	"SLLV",	     sl32,	"$%a,R%t,R%d",
+	"special3D",	0,	mipscoxxx,
+	"SRLV",	     sl32,	"$%a,R%t,R%d",
+	"SRAV",	     sl32,	"$%a,R%t,R%d",
+};
+
+static Opcode ropcodes[32] = {
+	"BLTZ",	   branch,	0,
+	"BGEZ",	   branch,	0,
+	"BLTZL",   branch,	0,
+	"BGEZL",   branch,	0,
+	"regimm04",	0,	mipscoxxx,
+	"regimm05",	0,	mipscoxxx,
+	"regimm06",	0,	mipscoxxx,
+	"regimm07",	0,	mipscoxxx,
+	"tgei",		0,	mipscorsi,
+	"tgeiu",	0,	mipscorsi,
+	"tlti",		0,	mipscorsi,
+	"tltiu",	0,	mipscorsi,
+	"teqi",		0,	mipscorsi,
+	"regimm0D",	0,	mipscoxxx,
+	"tnei",		0,	mipscorsi,
+	"regimm0F",	0,	mipscoxxx,
+	"BLTZAL",  branch,	0,
+	"BGEZAL",  branch,	0,
+	"BLTZALL", branch,	0,
+	"BGEZALL", branch,	0,
+	"regimm14",	0,	mipscoxxx,
+	"regimm15",	0,	mipscoxxx,
+	"regimm16",	0,	mipscoxxx,
+	"regimm17",	0,	mipscoxxx,
+	"regimm18",	0,	mipscoxxx,
+	"regimm19",	0,	mipscoxxx,
+	"regimm1A",	0,	mipscoxxx,
+	"regimm1B",	0,	mipscoxxx,
+	"regimm1C",	0,	mipscoxxx,
+	"regimm1D",	0,	mipscoxxx,
+	"regimm1E",	0,	mipscoxxx,
+	"regimm1F",	0,	mipscoxxx,
+};
+
+static Opcode fopcodes[64] = {
+	"ADD%f",	0,	mipsfp3,
+	"SUB%f",	0,	mipsfp3,
+	"MUL%f",	0,	mipsfp3,
+	"DIV%f",	0,	mipsfp3,
+	"sqrt.%f",	0,	mipscofp2,
+	"ABS%f",	0,	mipsfp2,
+	"MOV%f",	0,	mipsfp2,
+	"NEG%f",	0,	mipsfp2,
+	"finstr08",	0,	mipscoxxx,
+	"finstr09",	0,	mipscoxxx,
+	"finstr0A",	0,	mipscoxxx,
+	"finstr0B",	0,	mipscoxxx,
+	"round.w.%f",	0,	mipscofp2,
+	"trunc.w%f",	0,	mipscofp2,
+	"ceil.w%f",	0,	mipscofp2,
+	"floor.w%f",	0,	mipscofp2,
+	"finstr10",	0,	mipscoxxx,
+	"finstr11",	0,	mipscoxxx,
+	"finstr12",	0,	mipscoxxx,
+	"finstr13",	0,	mipscoxxx,
+	"finstr14",	0,	mipscoxxx,
+	"finstr15",	0,	mipscoxxx,
+	"finstr16",	0,	mipscoxxx,
+	"finstr17",	0,	mipscoxxx,
+	"finstr18",	0,	mipscoxxx,
+	"finstr19",	0,	mipscoxxx,
+	"finstr1A",	0,	mipscoxxx,
+	"finstr1B",	0,	mipscoxxx,
+	"finstr1C",	0,	mipscoxxx,
+	"finstr1D",	0,	mipscoxxx,
+	"finstr1E",	0,	mipscoxxx,
+	"finstr1F",	0,	mipscoxxx,
+	"cvt.s.%f",	0,	mipscofp2,
+	"cvt.d.%f",	0,	mipscofp2,
+	"cvt.e.%f",	0,	mipscofp2,
+	"cvt.q.%f",	0,	mipscofp2,
+	"cvt.w.%f",	0,	mipscofp2,
+	"finstr25",	0,	mipscoxxx,
+	"finstr26",	0,	mipscoxxx,
+	"finstr27",	0,	mipscoxxx,
+	"finstr28",	0,	mipscoxxx,
+	"finstr29",	0,	mipscoxxx,
+	"finstr2A",	0,	mipscoxxx,
+	"finstr2B",	0,	mipscoxxx,
+	"finstr2C",	0,	mipscoxxx,
+	"finstr2D",	0,	mipscoxxx,
+	"finstr2E",	0,	mipscoxxx,
+	"finstr2F",	0,	mipscoxxx,
+	"c.f.%f",	0,	mipscofpc,
+	"c.un.%f",	0,	mipscofpc,
+	"CMPEQ%f",	0,	mipsfpc,
+	"c.ueq.%f",	0,	mipscofpc,
+	"c.olt.%f",	0,	mipscofpc,
+	"c.ult.%f",	0,	mipscofpc,
+	"c.ole.%f",	0,	mipscofpc,
+	"c.ule.%f",	0,	mipscofpc,
+	"c.sf.%f",	0,	mipscofpc,
+	"c.ngle.%f",	0,	mipscofpc,
+	"c.seq.%f",	0,	mipscofpc,
+	"c.ngl.%f",	0,	mipscofpc,
+	"CMPGT%f",	0,	mipsfpc,
+	"c.nge.%f",	0,	mipscofpc,
+	"CMPGE%f",	0,	mipsfpc,
+	"c.ngt.%f",	0,	mipscofpc,
+};
+
+static char *cop0regs[32] = {
+	"INDEX", "RANDOM", "TLBPHYS", "EntryLo0",
+	"CONTEXT", "PageMask", "Wired",	"Error",
+	"BADVADDR", "Count", "TLBVIRT", "Compare",
+	"STATUS", "CAUSE", "EPC", "PRID",
+	"Config", "LLadr", "WatchLo", "WatchHi",
+	"20", "21", "22", "23",
+	"24", "25", "26", "CacheErr",
+	"TagLo", "TagHi", "ErrorEPC", "31"
+};
+
+static char fsub[16] = {
+	'F', 'D', 'e', 'q', 'W', '?', '?', '?',
+	'?', '?', '?', '?', '?', '?', '?', '?'
+};
+
+static char *cacheps[] = {
+	"I", "D", "SI", "SD"
+};
+
+static char *cacheop[] = {
+	"IWBI", "ILT", "IST", "CDE", "HI", "HWBI", "HWB", "HSV"
+};
+
+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 's':
+			bprint(i, "%d", i->rs);
+			break;
+
+		case 't':
+			bprint(i, "%d", i->rt);
+			break;
+
+		case 'd':
+			bprint(i, "%d", i->rd);
+			break;
+
+		case 'a':
+			bprint(i, "%d", i->sa);
+			break;
+
+		case 'l':
+			bprint(i, "%lx(R%d)",i->immediate, i->rs);
+			break;
+
+		case 'i':
+			bprint(i, "$%lx", i->immediate);
+			break;
+
+		case 'u':
+			i->curr += symoff(i->curr, i->end-i->curr, i->immediate, CANY);
+			bprint(i, "(SB)");
+			break;
+
+		case 'j':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				(i->target<<2)|(i->addr & 0xF0000000), CANY);
+			bprint(i, "(SB)");
+			break;
+
+		case 'b':
+			i->curr += symoff(i->curr, i->end-i->curr,
+				(i->immediate<<2)+i->addr+4, CANY);
+			break;
+
+		case 'c':
+			bprint(i, "$%lx", i->cofun);
+			break;
+
+		case 'w':
+			bprint(i, "[%lux]", i->w0);
+			break;
+
+		case 'm':
+			bprint(i, "M(%s)", cop0regs[i->rd]);
+			break;
+
+		case 'f':
+			*i->curr++ = fsub[i->rs & 0x0F];
+			break;
+
+		case 'C':
+			bprint(i, "%s%s", cacheps[i->rt & 3], cacheop[(i->rt>>2) & 7]);
+			break;
+
+		case '\0':
+			*i->curr++ = '%';
+			return;
+
+		default:
+			bprint(i, "%%%c", *f);
+			break;
+		}
+	}
+	*i->curr = 0;
+}
+
+static void
+copz(int cop, Instr *i)
+{
+	char *f, *m, buf[16];
+
+	m = buf;
+	f = "%t,%d";
+	switch (i->rs) {
+
+	case 0:
+		sprint(buf, "mfc%d", cop);
+		break;
+
+	case 2:
+		sprint(buf, "cfc%d", cop);
+		break;
+
+	case 4:
+		sprint(buf, "mtc%d", cop);
+		break;
+
+	case 6:
+		sprint(buf, "ctc%d", cop);
+		break;
+
+	case 8:
+		f = "%b";
+		switch (i->rt) {
+
+		case 0:
+			sprint(buf, "bc%df", cop);
+			break;
+
+		case 1:
+			sprint(buf, "bc%dt", cop);
+			break;
+
+		case 2:
+			sprint(buf, "bc%dfl", cop);
+			break;
+
+		case 3:
+			sprint(buf, "bc%dtl", cop);
+			break;
+
+		default:
+			sprint(buf, "cop%d", cop);
+			f = mipscoxxx;
+			break;
+		}
+		break;
+
+	default:
+		sprint(buf, "cop%d", cop);
+		if (i->rs & 0x10)
+			f = "function %c";
+		else
+			f = mipscoxxx;
+		break;
+	}
+	format(m, i, f);
+}
+
+static void
+cop0(Instr *i)
+{
+	char *m = 0;
+
+	if (i->rs < 8) {
+		switch (i->rs) {
+
+		case 0:
+		case 1:
+			format("MOVW", i, "%m,R%t");
+			return;
+
+		case 4:
+		case 5:
+			format("MOVW", i, "R%t,%m");
+			return;
+		}
+	}
+	else if (i->rs >= 0x10) {
+		switch (i->cofun) {
+	
+		case 1:
+			m = "TLBR";
+			break;
+	
+		case 2:
+			m = "TLBWI";
+			break;
+	
+		case 6:
+			m = "TLBWR";
+			break;
+	
+		case 8:
+			m = "TLBP";
+			break;
+	
+		case 16:
+			m = "RFE";
+			break;
+	
+		case 32:
+			m = "ERET";
+			break;
+		}
+		if (m) {
+			format(m, i, 0);
+			return;
+		}
+	}
+	copz(0, i);
+}
+
+static void
+cop1(Instr *i)
+{
+	char *m = "MOVW";
+
+	switch (i->rs) {
+
+	case 0:
+		format(m, i, "F%d,R%t");
+		return;
+
+	case 2:
+		format(m, i, "FCR%d,R%t");
+		return;
+
+	case 4:
+		format(m, i, "R%t,F%d");
+		return;
+
+	case 6:
+		format(m, i, "R%t,FCR%d");
+		return;
+
+	case 8:
+		switch (i->rt) {
+
+		case 0:
+			format("BFPF", i, "%b");
+			return;
+
+		case 1:
+			format("BFPT", i, "%b");
+			return;
+		}
+		break;
+	}
+	copz(1, i);
+}
+
+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 0x00:					/* SPECIAL */
+		o = sopcodes;
+		op = i.function;
+		break;
+
+	case 0x01:					/* REGIMM */
+		o = ropcodes;
+		op = i.rt;
+		break;
+
+	case 0x10:					/* COP0 */
+		cop0(&i);
+		return i.size*4;
+
+	case 0x11:					/* COP1 */
+		if (i.rs & 0x10) {
+			o = fopcodes;
+			op = i.function;
+			break;
+		}
+		cop1(&i);
+		return i.size*4;
+
+	case 0x12:					/* COP2 */
+	case 0x13:					/* COP3 */
+		copz(i.op-0x10, &i);
+		return i.size*4;
+
+	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;
+}
+
+extern	int	_mipscoinst(Map *, ulong, char*, int);
+
+	/* modifier 'I' toggles the default disassembler type */
+int
+mipsinst(Map *map, ulong pc, char modifier, char *buf, int n)
+{
+	if ((asstype == AMIPSCO && modifier == 'i')
+		|| (asstype == AMIPS && modifier == 'I'))
+		return _mipscoinst(map, pc, buf, n);
+	else
+		return printins(map, pc, buf, n);
+}
+
+int
+mipsdas(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;
+}
+
+int
+mipsinstlen(Map *map, ulong pc)
+{
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	return i.size*4;
+}
+
+int
+mipsfoll(Map *map, ulong pc, Rgetter rget, ulong *foll)
+{
+	ulong w, l;
+	char buf[8];
+	Instr i;
+
+	mymap = map;
+	if (mkinstr(pc, &i) < 0)
+		return -1;
+	w = i.w0;
+	if((w&0xF3600000) == 0x41000000){	/* branch on coprocessor */
+    Conditional:
+		foll[0] = pc+8;
+		l = ((w&0xFFFF)<<2);
+		if(w & 0x8000)
+			l |= 0xFFFC0000;
+		foll[1] = pc+4 + l;
+		return 2;
+	}
+
+	l = (w&0xFC000000)>>26;
+	switch(l){
+	case 0:		/* SPECIAL */
+		if((w&0x3E) == 0x08){	/* JR, JALR */
+			sprint(buf, "R%ld", (w>>21)&0x1F);
+			foll[0] = (*rget)(map, buf);
+			return 1;
+		}
+		foll[0] = pc+i.size*4;
+		return 1;
+	case 0x30:	/* Load-Linked followed by NOP, STC */
+		foll[0] = pc+12;
+		return 1;
+	case 1:		/* BCOND */
+	case 4:		/* BEQ */
+	case 20:	/* BEQL */
+	case 5:		/* BNE */
+	case 21:	/* BNEL */
+	case 6:		/* BLEZ */
+	case 22:	/* BLEZL */
+	case 7:		/* BGTZ */
+	case 23:	/* BGTZL */
+		goto Conditional;
+	case 2:		/* J */
+	case 3:		/* JAL */
+		foll[0] = (pc&0xF0000000) | ((w&0x03FFFFFF)<<2);
+		return 1;
+	}
+
+	foll[0] = pc+i.size*4;
+	return 1;
+}
diff --git a/utils/libmach/vobj.c b/utils/libmach/vobj.c
new file mode 100644
index 00000000..f676d219
--- /dev/null
+++ b/utils/libmach/vobj.c
@@ -0,0 +1,129 @@
+/*
+ * vobj.c - identify and parse a mips object file
+ */
+#include <lib9.h>
+#include <bio.h>
+#include "vc/v.out.h"
+#include "obj.h"
+
+typedef struct Addr	Addr;
+struct Addr
+{
+	char	type;
+	char	sym;
+	char	name;
+};
+static Addr addr(Biobuf*);
+static char type2char(int);
+static void skip(Biobuf*, int);
+
+int
+_isv(char *s)
+{
+	return  s[0] == ANAME				/* ANAME */
+		&& s[1] == D_FILE			/* type */
+		&& s[2] == 1				/* sym */
+		&& s[3] == '<';				/* name of file */
+}
+
+int
+_readv(Biobuf *bp, Prog *p)
+{
+	int as, n;
+	Addr a;
+
+	as = Bgetc(bp);			/* as */
+	if(as < 0)
+		return 0;
+	p->kind = aNone;
+	if(as == ANAME || as == ASIGNAME){
+		if(as == ASIGNAME)
+			skip(bp, 4);	/* signature */
+		p->kind = aName;
+		p->type = type2char(Bgetc(bp));		/* type */
+		p->sym = Bgetc(bp);			/* sym */
+		n = 0;
+		for(;;) {
+			as = Bgetc(bp);
+			if(as < 0)
+				return 0;
+			n++;
+			if(as == 0)
+				break;
+		}
+		p->id = malloc(n);
+		if(p->id == 0)
+			return 0;
+		Bseek(bp, -n, 1);
+		if(Bread(bp, p->id, n) != n)
+			return 0;
+		return 1;
+	}
+	if(as == ATEXT)
+		p->kind = aText;
+	else if(as == AGLOBL)
+		p->kind = aData;
+	skip(bp, 5);		/* reg(1), lineno(4) */
+	a = addr(bp);
+	addr(bp);
+	if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
+		p->kind = aNone;
+	p->sym = a.sym;
+	return 1;
+}
+
+static Addr
+addr(Biobuf *bp)
+{
+	Addr a;
+	long off;
+
+	a.type = Bgetc(bp);	/* a.type */
+	skip(bp,1);		/* reg */
+	a.sym = Bgetc(bp);	/* sym index */
+	a.name = Bgetc(bp);	/* sym type */
+	switch(a.type){
+	default:
+	case D_NONE: case D_REG: case D_FREG: case D_MREG:
+	case D_FCREG: case D_LO: case D_HI:
+		break;
+	case D_OREG:
+	case D_CONST:
+	case D_BRANCH:
+		off = Bgetc(bp);
+		off |= Bgetc(bp) << 8;
+		off |= Bgetc(bp) << 16;
+		off |= Bgetc(bp) << 24;
+		if(off < 0)
+			off = -off;
+		if(a.sym && (a.name==D_PARAM || a.name==D_AUTO))
+			_offset(a.sym, off);
+		break;
+	case D_SCONST:
+		skip(bp, NSNAME);
+		break;
+	case D_FCONST:
+		skip(bp, 8);
+		break;
+	}
+	return a;
+}
+
+static char
+type2char(int t)
+{
+	switch(t){
+	case D_EXTERN:		return 'U';
+	case D_STATIC:		return 'b';
+	case D_AUTO:		return 'a';
+	case D_PARAM:		return 'p';
+	default:		return UNKNOWN;
+	}
+}
+
+static void
+skip(Biobuf *bp, int n)
+{
+	while (n-- > 0)
+		Bgetc(bp);
+}