diff --git a/src/cmd/acid/Notes b/src/cmd/acid/Notes
index 597bf58..90cfc2a 100644
--- a/src/cmd/acid/Notes
+++ b/src/cmd/acid/Notes
@@ -20,6 +20,8 @@
 
 map() expects a 5-tuple too
 
+new acid maps() prints maps nicely.
+
 strace expects a list of register names and values like
 	{"PC", *PC, "SP", *SP}
 
@@ -41,6 +43,34 @@
 
 both textfile and deltextfile update symbols.
 
+new types: register is something that when dereferenced gives you
+	the registers.  the Ureg is no longer mapped at 0.
+	refconst is something that gives a constant when dereferenced.
+
+new builtin register("AX") creates register values
+new builtin refconst(0x123) creates refconst values
+
+new builtin var("foo") is equivalent to the variable foo
+	(it returns foo but can also be used as the lhs of an assignment).
+
+new acid function getregs() returns a list of the current values of registers.
+new acid function setregs() sets the current registers to those values.
+	note that getregs and setregs operate on register locations, not the
+		register values themselves.  
+new acid function resetregs() sets registers to register("AX"), etc.
+new acid function clearregs() sets all registers to constant -1.
+
+the default register settings are as in resetregs(), not small numbers.
+the Ureg is not mapped at 0 anymore.
+
+new acid variables coretext, pids, systype, corefile, cmdline.
+
+new behavior: local variable lookup, stk, etc., use the acid values of registers
+	(*PC, *SP, and so on), so the thread support code can change the context
+	completely.
+
+unary + is applicable to more data types and prints more often.
+
 ====
 
 yet to be done:
diff --git a/src/cmd/acid/acid.h b/src/cmd/acid/acid.h
index 4471800..866816e 100644
--- a/src/cmd/acid/acid.h
+++ b/src/cmd/acid/acid.h
@@ -44,6 +44,7 @@
 Extern Node*	code;
 Extern int	na;
 Extern int	wtflag;
+Extern Regs*	acidregs;
 Extern Regs*	correg;
 Extern Map*	cormap;
 Extern Map*	symmap;
@@ -76,6 +77,8 @@
 	TSTRING,
 	TLIST,
 	TCODE,
+	TREG,
+	TCON,
 	NUMT,
 };
 
@@ -129,6 +132,8 @@
 		String*	string;
 		List*	l;
 		Node*	cc;
+		char*	reg;
+		Node*	con;
 	} u;
 };
 
@@ -182,6 +187,7 @@
 	int	len;
 };
 
+int	acidregsrw(Regs*, char*, ulong*, int);
 List*	addlist(List*, List*);
 void	addvarsym(Fhdr*);
 List*	al(int);
@@ -212,6 +218,7 @@
 char*	getstatus(int);
 void*	gmalloc(long);
 void	indir(Map*, ulong, char, Node*);
+void	indirreg(Regs*, char*, char, Node*);
 void	initexpr(void);
 void	initprint(void);
 void	installbuiltin(void);
@@ -257,7 +264,8 @@
 void	varreg(void);
 void	varsym(void);
 void	whatis(Lsym*);
-void	windir(Map*, Node*, Node*, Node*);
+void	windir(Map*, Node, Node*, Node*);
+void	windirreg(Regs*, char*, Node*, Node*);
 void	yyerror(char*, ...);
 int	yylex(void);
 int	yyparse(void);
@@ -313,5 +321,6 @@
 	OFMT,
 	OEVAL,
 	OWHAT,
+	OUPLUS,
 	NUMO,
 };
diff --git a/src/cmd/acid/builtin.c b/src/cmd/acid/builtin.c
index 490c452..316c492 100644
--- a/src/cmd/acid/builtin.c
+++ b/src/cmd/acid/builtin.c
@@ -44,6 +44,9 @@
 void textfile(Node*, Node*);
 void deltextfile(Node*, Node*);
 void stringn(Node*, Node*);
+void xregister(Node*, Node*);
+void refconst(Node*, Node*);
+void dolook(Node*, Node*);
 
 typedef struct Btab Btab;
 struct Btab
@@ -52,13 +55,12 @@
 	void	(*fn)(Node*, Node*);
 } tab[] =
 {
+	"access",	doaccess,
 	"atof",		cvtatof,
 	"atoi",		cvtatoi,
 	"deltextfile",	deltextfile,
 	"error",	doerror,
 	"file",		getfile,
-	"readfile",	readfile,
-	"access",	doaccess,
 	"filepc",	filepc,
 	"fnbound",	funcbound,
 	"fmt",		fmt,
@@ -76,8 +78,11 @@
 	"print",	bprint,
 	"printto",	printto,
 	"rc",		rc,
+	"readfile",	readfile,
 	"reason",	reason,
+	"refconst",	refconst,
 	"regexp",	regexp,
+	"register",	xregister,
 	"setproc",	setproc,
 	"start",	start,
 	"startstop",	startstop,
@@ -87,6 +92,7 @@
 	"stringn",	stringn,
 	"sysstop",		sysstop,
 	"textfile",	textfile,
+	"var",	dolook,
 	"waitstop",	waitstop,
 	0
 };
@@ -317,6 +323,65 @@
 }
 
 void
+xregister(Node *r, Node *args)
+{
+	Regdesc *rp;
+	Node res;
+
+	if(args == 0)
+		error("register(string): arg count");
+	expr(args, &res);
+	if(res.type != TSTRING)
+		error("register(string): arg type");
+
+	if((rp = regdesc(res.store.u.string->string)) == nil)
+		error("no such register");
+
+	r->op = OCONST;
+	r->type = TREG;
+	r->store.fmt = rp->format;
+	r->store.u.reg = rp->name;
+}
+
+void
+refconst(Node *r, Node *args)
+{
+	Node *n;
+
+	if(args == 0)
+		error("refconst(expr): arg count");
+
+	n = an(OCONST, ZN, ZN);
+	expr(args, n);
+
+	r->op = OCONST;
+	r->type = TCON;
+	r->store.u.con = n;
+}
+
+void
+dolook(Node *r, Node *args)
+{
+	Node res;
+	Lsym *l;
+
+	if(args == 0)
+		error("var(string): arg count");
+	expr(args, &res);
+	if(res.type != TSTRING)
+		error("var(string): arg type");
+
+	r->op = OCONST;
+	if((l = look(res.store.u.string->string)) == nil || l->v->set == 0){
+		r->type = TLIST;
+		r->store.u.l = nil;
+	}else{
+		r->type = l->v->type;
+		r->store = l->v->store;
+	}
+}
+
+void
 status(Node *r, Node *args)
 {
 	Node res;
@@ -350,7 +415,7 @@
 	r->op = OCONST;
 	r->type = TSTRING;
 	r->store.fmt = 's';
-	r->store.u.string = strnode((*mach->exc)(cormap, correg));
+	r->store.u.string = strnode((*mach->exc)(cormap, acidregs));
 }
 
 void
@@ -367,7 +432,7 @@
 	if(res.type != TINT)
 		error("follow(addr): arg type");
 
-	n = (*mach->foll)(cormap, correg, res.store.u.ival, f);
+	n = (*mach->foll)(cormap, acidregs, res.store.u.ival, f);
 	if (n < 0)
 		error("follow(addr): %r");
 	tail = &r->store.u.l;
@@ -953,7 +1018,7 @@
 			*val = sregs[i].val;
 			return 0;
 		}
-	return rget(correg, name, val);
+	return rget(acidregs, name, val);
 }
 
 void
@@ -1058,6 +1123,65 @@
 	int i;
 	char buf[512];
 	extern char *typenames[];
+	Node *n;
+
+	switch(type){
+	case TREG:
+		Bprint(bout, "register(\"%s\")", res->u.reg);
+		return;
+	case TCON:
+		Bprint(bout, "refconst(");
+		n = res->u.con;
+		patom(n->type, &n->store);
+		Bprint(bout, ")");
+		return;
+	}
+
+	switch(res->fmt){
+	case 'c':
+	case 'C':
+	case 'r':
+	case 'B':
+	case 'b':
+	case 'X':
+	case 'x':
+	case 'W':
+	case 'D':
+	case 'd':
+	case 'u':
+	case 'U':
+	case 'Z':
+	case 'V':
+	case 'Y':
+	case 'o':
+	case 'O':
+	case 'q':
+	case 'Q':
+	case 'a':
+	case 'A':
+	case 'I':
+	case 'i':
+		if(type != TINT){
+		badtype:
+			Bprint(bout, "*%s\\%c*", typenames[(uchar)type], res->fmt);
+			return;
+		}
+		break;
+
+	case 'f':
+	case 'F':
+		if(type != TFLOAT)
+			goto badtype;
+		break;
+
+	case 's':
+	case 'g':
+	case 'G':
+	case 'R':
+		if(type != TSTRING)
+			goto badtype;
+		break;
+	}
 
 	switch(res->fmt) {
 	case 'c':
@@ -1129,24 +1253,15 @@
 		break;
 	case 'f':
 	case 'F':
-		if(type != TFLOAT)
-			Bprint(bout, "*%c<%s>*", res->fmt, typenames[(uchar)type]);
-		else
-			Bprint(bout, "%g", res->u.fval);
+		Bprint(bout, "%g", res->u.fval);
 		break;
 	case 's':
 	case 'g':
 	case 'G':
-		if(type != TSTRING)
-			Bprint(bout, "*%c<%s>*", res->fmt, typenames[(uchar)type]);
-		else
-			Bwrite(bout, res->u.string->string, res->u.string->len);
+		Bwrite(bout, res->u.string->string, res->u.string->len);
 		break;
 	case 'R':
-		if(type != TSTRING)
-			Bprint(bout, "*%c<%s>*", res->fmt, typenames[(uchar)type]);
-		else
-			Bprint(bout, "%S", (Rune*)res->u.string->string);
+		Bprint(bout, "%S", (Rune*)res->u.string->string);
 		break;
 	case 'a':
 	case 'A':
@@ -1155,14 +1270,10 @@
 		break;
 	case 'I':
 	case 'i':
-		if(type != TINT)
-			Bprint(bout, "*%c<%s>*", res->fmt, typenames[(uchar)type]);
-		else {
-			if (symmap == nil || (*mach->das)(symmap, res->u.ival, res->fmt, buf, sizeof(buf)) < 0)
-				Bprint(bout, "no instruction");
-			else
-				Bprint(bout, "%s", buf);
-		}
+		if (symmap == nil || (*mach->das)(symmap, res->u.ival, res->fmt, buf, sizeof(buf)) < 0)
+			Bprint(bout, "no instruction");
+		else
+			Bprint(bout, "%s", buf);
 		break;
 	}
 }
@@ -1406,6 +1517,7 @@
 			unmapfile(corhdr, cormap);
 			mapfile(fp, base, cormap, nil);
 			free(correg);
+			correg = nil;
 			mapfile(corhdr, 0, cormap, &correg);
 		}
 		if(symopen(fp) < 0)
@@ -1476,8 +1588,6 @@
 		error("symbol file %s not open", file);
 }
 
-int xget1(Map *m, ulong addr, u8int *a, int n);
-
 void
 stringn(Node *r, Node *args)
 {
@@ -1507,7 +1617,7 @@
 
 	r->type = TSTRING;
 	for(i=0; i<n; i++){
-		ret = xget1(cormap, addr, (uchar*)&buf[i], 1);
+		ret = get1(cormap, addr, (uchar*)&buf[i], 1);
 		if(ret < 0){
 			free(buf);
 			error("indir: %r");
diff --git a/src/cmd/acid/dbg.y b/src/cmd/acid/dbg.y
index afdf538..3d1886c 100644
--- a/src/cmd/acid/dbg.y
+++ b/src/cmd/acid/dbg.y
@@ -282,8 +282,7 @@
 		}
 		| '+' monexpr
 		{
-			$$ = con(0);
-			$$ = an(OADD, $2, $$);
+			$$ = an(OUPLUS, $2, ZN);
 		}
 		| '-' monexpr
 		{
diff --git a/src/cmd/acid/exec.c b/src/cmd/acid/exec.c
index edf2690..2022da5 100644
--- a/src/cmd/acid/exec.c
+++ b/src/cmd/acid/exec.c
@@ -202,56 +202,6 @@
 	}
 }
 
-static char*
-regbyoff(ulong addr)
-{
-	Regdesc *r;
-
-	if(mach == nil)
-		error("no mach, no registers");
-	for(r=mach->reglist; r->name; r++)
-		if(r->offset == addr)
-			return r->name;
-	error("no register at %#lux", addr);
-	return nil;
-}
-
-int
-xget1(Map *m, ulong addr, u8int *a, int n)
-{
-	if(addr < 0x100 && correg)
-		return lget1(m, correg, locreg(regbyoff(addr)), a, n);
-	else
-		return get1(m, addr, a, n);
-}
-
-int
-xget2(Map *m, ulong addr, u16int *a)
-{
-	if(addr < 0x100 && correg)
-		return lget2(m, correg, locreg(regbyoff(addr)), a);
-	else
-		return get2(m, addr, a);
-}
-
-int
-xget4(Map *m, ulong addr, u32int *a)
-{
-	if(addr < 0x100 && correg)
-		return lget4(m, correg, locreg(regbyoff(addr)), a);
-	else
-		return get4(m, addr, a);
-}
-
-int
-xget8(Map *m, ulong addr, u64int *a)
-{
-	if(addr < 0x100 && correg)
-		return lget8(m, correg, locreg(regbyoff(addr)), a);
-	else
-		return get8(m, addr, a);
-}
-
 void
 indir(Map *m, ulong addr, char fmt, Node *r)
 {
@@ -272,7 +222,7 @@
 	case 'C':
 	case 'b':
 		r->type = TINT;
-		ret = xget1(m, addr, &cval, 1);
+		ret = get1(m, addr, &cval, 1);
 		if (ret < 0)
 			error("indir: %r");
 		r->store.u.ival = cval;
@@ -284,7 +234,7 @@
 	case 'q':
 	case 'r':
 		r->type = TINT;
-		ret = xget2(m, addr, &sval);
+		ret = get2(m, addr, &sval);
 		if (ret < 0)
 			error("indir: %r");
 		r->store.u.ival = sval;
@@ -298,7 +248,7 @@
 	case 'O':
 	case 'Q':
 		r->type = TINT;
-		ret = xget4(m, addr, &ival);
+		ret = get4(m, addr, &ival);
 		if (ret < 0)
 			error("indir: %r");
 		r->store.u.ival = ival;
@@ -308,7 +258,7 @@
 	case 'Y':
 	case 'Z':
 		r->type = TINT;
-		ret = xget8(m, addr, &vval);
+		ret = get8(m, addr, &vval);
 		if (ret < 0)
 			error("indir: %r");
 		r->store.u.ival = vval;
@@ -316,7 +266,7 @@
 	case 's':
 		r->type = TSTRING;
 		for(i = 0; i < sizeof(buf)-1; i++) {
-			ret = xget1(m, addr, (uchar*)&buf[i], 1);
+			ret = get1(m, addr, (uchar*)&buf[i], 1);
 			if (ret < 0)
 				error("indir: %r");
 			addr++;
@@ -331,7 +281,7 @@
 	case 'R':
 		r->type = TSTRING;
 		for(i = 0; i < sizeof(buf)-2; i += 2) {
-			ret = xget1(m, addr, (uchar*)&buf[i], 2);
+			ret = get1(m, addr, (uchar*)&buf[i], 2);
 			if (ret < 0)
 				error("indir: %r");
 			addr += 2;
@@ -351,14 +301,14 @@
 		r->store.u.string = strnode(buf);
 		break;
 	case 'f':
-		ret = xget1(m, addr, (uchar*)buf, mach->szfloat);
+		ret = get1(m, addr, (uchar*)buf, mach->szfloat);
 		if (ret < 0)
 			error("indir: %r");
 		mach->ftoa32(buf, sizeof(buf), (void*) buf);
 		convflt(r, buf);
 		break;
 	case 'g':
-		ret = xget1(m, addr, (uchar*)buf, mach->szfloat);
+		ret = get1(m, addr, (uchar*)buf, mach->szfloat);
 		if (ret < 0)
 			error("indir: %r");
 		mach->ftoa32(buf, sizeof(buf), (void*) buf);
@@ -366,14 +316,14 @@
 		r->store.u.string = strnode(buf);
 		break;
 	case 'F':
-		ret = xget1(m, addr, (uchar*)buf, mach->szdouble);
+		ret = get1(m, addr, (uchar*)buf, mach->szdouble);
 		if (ret < 0)
 			error("indir: %r");
 		mach->ftoa64(buf, sizeof(buf), (void*) buf);
 		convflt(r, buf);
 		break;
 	case '3':	/* little endian ieee 80 with hole in bytes 8&9 */
-		ret = xget1(m, addr, (uchar*)reg, 10);
+		ret = get1(m, addr, (uchar*)reg, 10);
 		if (ret < 0)
 			error("indir: %r");
 		memmove(reg+10, reg+8, 2);	/* open hole */
@@ -382,14 +332,14 @@
 		convflt(r, buf);
 		break;
 	case '8':	/* big-endian ieee 80 */
-		ret = xget1(m, addr, (uchar*)reg, 10);
+		ret = get1(m, addr, (uchar*)reg, 10);
 		if (ret < 0)
 			error("indir: %r");
 		beieeeftoa80(buf, sizeof(buf), reg);
 		convflt(r, buf);
 		break;
 	case 'G':
-		ret = xget1(m, addr, (uchar*)buf, mach->szdouble);
+		ret = get1(m, addr, (uchar*)buf, mach->szdouble);
 		if (ret < 0)
 			error("indir: %r");
 		mach->ftoa64(buf, sizeof(buf), (void*) buf);
@@ -400,21 +350,70 @@
 }
 
 void
-windir(Map *m, Node *addr, Node *rval, Node *r)
+indirreg(Regs *regs, char *name, char fmt, Node *r)
+{
+	ulong val;
+
+	if(regs == 0)
+		error("no register set for *%s=", name);
+
+	r->op = OCONST;
+	r->store.fmt = fmt;
+	switch(fmt){
+	default:
+		error("bad pointer format '%c' for *%s", fmt, name);
+	case 'c':
+	case 'C':
+	case 'b':
+	case 'x':
+	case 'd':
+	case 'u':
+	case 'o':
+	case 'q':
+	case 'r':
+	case 'a':
+	case 'A':
+	case 'B':
+	case 'X':
+	case 'D':
+	case 'U':
+	case 'O':
+	case 'Q':
+	case 'V':
+	case 'W':
+	case 'Y':
+	case 'Z':
+		if(rget(regs, name, &val) < 0)
+			error("reading %s: %r", name);
+		r->type = TINT;
+		r->store.u.ival = val;
+		break;
+	case 'f':
+	case 'g':
+	case 'F':
+	case '3':
+	case '8':
+	case 'G':
+		error("floating point registers not supported");
+		break;
+	}
+}
+
+void
+windir(Map *m, Node aes, Node *rval, Node *r)
 {
 	uchar cval;
 	ushort sval;
-	Node res, aes;
+	Node res;
 	int ret;
 
 	if(m == 0)
 		error("no map for */@=");
 
-	expr(rval, &res);
-	expr(addr, &aes);
-
 	if(aes.type != TINT)
-		error("bad type lhs of @/*");
+		error("bad type lhs of */@=");
+
+	expr(rval, &res);
 
 	if(m != cormap && wtflag == 0)
 		error("not in write mode");
@@ -466,6 +465,58 @@
 }
 
 void
+windirreg(Regs *regs, char *name, Node *rval, Node *r)
+{
+	Node res;
+
+	if(regs == 0)
+		error("no register set for *%s=", name);
+
+	expr(rval, &res);
+
+	r->type = res.type;
+	r->store.fmt = res.store.fmt;
+	r->store = res.store;
+
+	switch(res.store.fmt){
+	default:
+		error("bad format '%c' for *%s=", res.store.fmt, name);
+	case 'c':
+	case 'C':
+	case 'b':
+	case 'x':
+	case 'd':
+	case 'u':
+	case 'o':
+	case 'q':
+	case 'r':
+	case 'a':
+	case 'A':
+	case 'B':
+	case 'X':
+	case 'D':
+	case 'U':
+	case 'O':
+	case 'Q':
+	case 'V':
+	case 'W':
+	case 'Y':
+	case 'Z':
+		if(rput(regs, name, res.store.u.ival) < 0)
+			error("writing %s: %r", name);
+		break;
+	case 'f':
+	case 'g':
+	case 'F':
+	case '3':
+	case '8':
+	case 'G':
+		error("floating point registers not supported");
+		break;
+	}
+}
+
+void
 call(char *fn, Node *parameters, Node *local, Node *body, Node *retexp)
 {
 	int np, i;
diff --git a/src/cmd/acid/expr.c b/src/cmd/acid/expr.c
index 9cfac9e..6a0430d 100644
--- a/src/cmd/acid/expr.c
+++ b/src/cmd/acid/expr.c
@@ -63,11 +63,29 @@
 	}
 }
 
-void
+Lsym*
 chklval(Node *lp)
 {
-	if(lp->op != ONAME)
-		error("need l-value");
+	Node res;
+	Lsym *s;
+
+	if(lp->op == ONAME)
+		return lp->sym;
+
+	if(lp->op == OCALL){
+		s = chklval(lp->left);
+		if(strcmp(s->name, "var") == 0	
+		&& (lp->builtin || s->proc == 0)){
+			if(lp->right == 0)
+				error("var(string): arg count");
+			expr(lp->right, &res);
+			if(res.type != TSTRING)
+				error("var(string): arg type");
+			return mkvar(res.store.u.string->string);
+		}
+	}
+	error("need l-value");
+	return nil;	
 }
 
 void
@@ -107,12 +125,24 @@
 	if(m == 0)
 		m = symmap;
 	expr(n->left, &l);
-	if(l.type != TINT)
+	switch(l.type){
+	default:
 		error("bad type for *");
-	if(m == 0)
-		error("no map for *");
-	indir(m, l.store.u.ival, l.store.fmt, res);
-	res->store.comt = l.store.comt;
+	case TINT:
+		if(m == 0)
+			error("no map for *");
+		indir(m, l.store.u.ival, l.store.fmt, res);
+		res->store.comt = l.store.comt;
+		break;
+	case TREG:
+		indirreg(correg, l.store.u.reg, l.store.fmt, res);
+		res->store.comt = l.store.comt;
+		break;
+	case TCON:
+		*res = *l.store.u.con;
+		res->store.comt = l.store.comt;
+		break;
+	}
 }
 
 void
@@ -145,7 +175,7 @@
 	while(*p && *p == '$')
 		p++;
 	lp = n->left;
-	if(localaddr(cormap, correg, p, lp->sym->name, &ival) < 0)
+	if(localaddr(cormap, acidregs, p, lp->sym->name, &ival) < 0)
 		error("colon: %r");
 		
 	res->store.u.ival = ival;
@@ -296,19 +326,24 @@
 oasgn(Node *n, Node *res)
 {
 	Node *lp, r;
+	Node aes;
 	Value *v;
 
 	lp = n->left;
 	switch(lp->op) {
 	case OINDM:
-		windir(cormap, lp->left, n->right, res);
+		expr(lp->left, &aes);
+		if(aes.type == TREG)
+			windirreg(correg, aes.store.u.reg, n->right, res);
+		else
+			windir(cormap, aes, n->right, res);
 		break;
 	case OINDC:
-		windir(symmap, lp->left, n->right, res);
+		expr(lp->left, &aes);
+		windir(symmap, aes, n->right, res);
 		break;
 	default:
-		chklval(lp);
-		v = lp->sym->v;
+		v = chklval(lp)->v;
 		expr(n->right, &r);
 		v->set = 1;
 		v->type = r.type;
@@ -871,8 +906,7 @@
 {
 	Value *v;
 
-	chklval(n->left);
-	v = n->left->sym->v;
+	v = chklval(n->left)->v;
 	res->op = OCONST;
 	res->type = v->type;
 	switch(v->type) {
@@ -899,8 +933,7 @@
 {
 	Value *v;
 
-	chklval(n->left);
-	v = n->left->sym->v;
+	v = chklval(n->left)->v;
 	res->op = OCONST;
 	res->type = v->type;
 	res->store = v->store;
@@ -932,9 +965,7 @@
 	res->type = TLIST;
 	res->store.u.l = 0;
 
-	chklval(n->left);
-	s = n->left->sym;
-
+	s = chklval(n->left);
 	if(n->builtin && !s->builtin){
 		error("no builtin %s", s->name);
 		return;
@@ -959,6 +990,12 @@
 }
 
 void
+ouplus(Node *n, Node *res)
+{
+	expr(n->left, res);
+}
+
+void
 owhat(Node *n, Node *res)
 {
 	res->op = OCONST;		/* Default return value */
@@ -1021,6 +1058,7 @@
 	expop[OFMT] = ofmt;
 	expop[OEVAL] = oeval;
 	expop[OWHAT] = owhat;
+	expop[OUPLUS] = ouplus;
 }
 
 void
@@ -1030,3 +1068,54 @@
 	initexpop();
 }
 
+int
+acidregsrw(Regs *r, char *name, ulong *u, int isr)
+{
+	Lsym *l;
+	Value *v;
+	Node *n;
+	ulong addr;
+	u32int u32;
+
+	if(!isr){
+		werrstr("cannot write registers");
+		return -1;
+	}
+	USED(r);
+	l = look(name);
+	if(l == nil){
+		werrstr("register %s not found", name);
+		return -1;
+	}
+	v = l->v;
+	switch(v->type){
+	default:
+		werrstr("*%s: bad type", name);
+		return -1;
+	case TREG:
+		if(correg == nil){
+			werrstr("*%s: register %s not mapped", name, v->store.u.reg);
+			return -1;
+		}
+		return rget(correg, v->store.u.reg, u);
+	case TCON:
+		n = v->store.u.con;
+		if(n->op != OCONST || n->type != TINT){
+			werrstr("*%s: bad register constant", name);
+			return -1;
+		}
+		*u = n->store.u.ival;
+		return 0;
+	case TINT:
+		if(cormap == nil){
+			werrstr("*%s: core not mapped", name);
+			return -1;
+		}
+		addr = v->store.u.ival;
+		/* XXX should use format to determine size */
+		if(get4(cormap, addr, &u32) < 0)
+			return -1;
+		*u = u32;
+		return 0;
+	}
+}
diff --git a/src/cmd/acid/main.c b/src/cmd/acid/main.c
index 87f5979..e885b01 100644
--- a/src/cmd/acid/main.c
+++ b/src/cmd/acid/main.c
@@ -106,6 +106,8 @@
 	pushfile(0);
 	loadvars();
 	installbuiltin();
+	acidregs = mallocz(sizeof *acidregs, 1);
+	acidregs->rw = acidregsrw;
 
 	if(mtype && machbyname(mtype) == 0)
 		print("unknown machine %s", mtype);
@@ -172,16 +174,29 @@
 */
 }
 
+void
+setstring(char *var, char *s)
+{
+	Lsym *l;
+	Value *v;
+
+	l = mkvar(var);
+	v = l->v;
+	v->store.fmt = 's';
+	v->set = 1;
+	v->store.u.string = strnode(s ? s : "");
+	v->type = TSTRING;
+}
+
 static int
 attachfiles(int argc, char **argv)
 {
 	int fd;
 	volatile int pid;
-	char *s;
+	char *s, *t;
 	int i, omode;
 	Fhdr *hdr;
 	Lsym *l;
-	Value *v;
 
 	pid = 0;
 	interactive = 0;
@@ -220,7 +235,6 @@
 		}
 		fprint(2, "%s: %s %s %s\n", argv[i], hdr->aname, hdr->mname, hdr->fname);
 		if(hdr->ftype == FCORE){
-			fprint(2, "cmd: %s\n", hdr->cmd);
 			if(pid){
 				fprint(2, "already have pid %d; ignoring core %s\n", pid, argv[i]);
 				uncrackhdr(hdr);
@@ -252,12 +266,28 @@
 				symfil = s;
 			}
 		}
-		/* XXX pull command from core */
+		if(corhdr){
+			/*
+			 * prog gives only the basename of the command,
+			 * so try the command line for a path.
+			 */
+			if((s = strdup(corhdr->cmdline)) != nil){
+				t = strchr(s, ' ');
+				if(t)
+					*t = 0;
+				if((t = searchpath(s)) != nil){
+					fprint(2, "core: text %s\n", t);
+					symfil = t;
+				}
+				free(s);
+			}
+		}
 
 		if((symhdr = crackhdr(symfil, omode)) == nil){
 			fprint(2, "crackhdr %s: %r\n", symfil);
 			symfil = nil;
-		}
+		}else
+			fprint(2, "%s: %s %s %s\n", symfil, symhdr->aname, symhdr->mname, symhdr->fname);	
 	}
 
 	if(symhdr)
@@ -281,33 +311,15 @@
 	}
 
 Run:
-	l = mkvar("objtype");
-	v = l->v;
-	v->store.fmt = 's';
-	v->set = 1;
-	v->store.u.string = strnode(mach->name);
-	v->type = TSTRING;
+	setstring("objtype", mach->name);
+	setstring("textfile", symfil);
+	setstring("systype", symhdr ? symhdr->aname : "");
+	setstring("corefile", corfil);
 
-	l = mkvar("textfile");
-	v = l->v;
-	v->store.fmt = 's';
-	v->set = 1;
-	v->store.u.string = strnode(symfil ? symfil : "");
-	v->type = TSTRING;
-
-	l = mkvar("systype");
-	v = l->v;
-	v->store.fmt = 's';
-	v->set = 1;
-	v->store.u.string = strnode(symhdr ? symhdr->aname : "");
-	v->type = TSTRING;
-
-	l = mkvar("corefile");
-	v = l->v;
-	v->store.fmt = 's';
-	v->set = 1;
-	v->store.u.string = strnode(corfil ? corfil : "");
-	v->type = TSTRING;
+	l = mkvar("pids");
+	l->v->set = 1;
+	l->v->type = TLIST;
+	l->v->store.u.l = nil;
 
 	if(pid)
 		sproc(pid);
@@ -320,6 +332,11 @@
 void
 setcore(Fhdr *hdr)
 {
+	int i;
+	Lsym *l;
+	Value *v;
+	List **tail, *tl;
+
 	unmapproc(cormap);
 	unmapfile(corhdr, cormap);
 	free(correg);
@@ -331,6 +348,31 @@
 		error("mapfile %s: %r", hdr->filename);
 	corhdr = hdr;
 	corfil = hdr->filename;
+
+	l = mkvar("pid");
+	v = l->v;
+	v->store.fmt = 'D';
+	v->set = 1;
+	v->store.u.ival = hdr->pid;
+
+	setstring("corefile", corfil);
+	setstring("cmdline", hdr->cmdline);
+
+	l = mkvar("pids");
+	l->v->set = 1;
+	l->v->type = TLIST;
+	l->v->store.u.l = nil;
+	tail = &l->v->store.u.l;
+	for(i=0; i<hdr->nthread; i++){
+		tl = al(TINT);
+		tl->store.u.ival = hdr->thread[i].id;
+		tl->store.fmt = 'X';
+		*tail = tl;
+		tail = &tl->next;
+	}
+
+	if(hdr->nthread)
+		sproc(hdr->thread[0].id);
 }
 
 void
@@ -338,16 +380,21 @@
 {
 	Lsym *s;
 	List *f;
+	int first;
 
 	Bprint(bout, "\n");
 
+	first = 1;
 	s = look("proclist");
 	if(s && s->v->type == TLIST) {
 		for(f = s->v->store.u.l; f; f = f->next){
 			detachproc((int)f->store.u.ival);
-			Bprint(bout, "/bin/kill -9 %d\n", (int)f->store.u.ival);
+			Bprint(bout, "%s %d", first ? "/bin/kill -9" : "", (int)f->store.u.ival);
+			first = 0;
 		}
 	}
+	if(!first)
+		Bprint(bout, "\n");
 	exits(0);
 }
 
@@ -545,6 +592,9 @@
 				case TCODE:
 					marktree(v->store.u.cc);
 					break;
+				case TCON:
+					marktree(v->store.u.con);
+					break;
 				}
 			}
 		}
diff --git a/src/cmd/acid/print.c b/src/cmd/acid/print.c
index 0c66e02..58acdfc 100644
--- a/src/cmd/acid/print.c
+++ b/src/cmd/acid/print.c
@@ -401,6 +401,10 @@
 		if(n->sym)
 			Bprint(bout, " %s", n->sym->name);
 		break;
+	case OUPLUS:
+		Bprint(bout, "+");
+		pexpr(l);
+		break;
 	}
 }
 
diff --git a/src/cmd/acid/proc.c b/src/cmd/acid/proc.c
index a0aed61..02c4453 100644
--- a/src/cmd/acid/proc.c
+++ b/src/cmd/acid/proc.c
@@ -21,30 +21,39 @@
 	if(pid == xpid)
 		return;
 
-	if(xpid <= 0)
-		error("bad pid");
+	if(corhdr){
+		free(correg);
+		correg = nil;
+		correg = coreregs(corhdr, xpid);
+		if(correg == nil)
+			error("no such pid in core dump");
+	}else{
+		/* XXX should only change register set here if cormap already mapped */		
+		if(xpid <= 0)
+			error("bad pid");
+		unmapproc(cormap);
+		unmapfile(corhdr, cormap);
+		free(correg);
+		correg = nil;
 
-	unmapproc(cormap);
-	unmapfile(corhdr, cormap);
-	free(correg);
-	correg = nil;
+		if(mapproc(xpid, cormap, &correg) < 0)
+			error("setproc %d: %r", xpid);
 
-	if(mapproc(xpid, cormap, &correg) < 0)
-		error("setproc %d: %r", xpid);
+		/* XXX check text file here? */
 
-	/* XXX check text file here? */
-
+		for(i=0; i<cormap->nseg; i++){
+			if(cormap->seg[i].file == nil){
+				if(strcmp(cormap->seg[i].name, "data") == 0)
+					cormap->seg[i].name = "*data";
+				if(strcmp(cormap->seg[i].name, "text") == 0)
+					cormap->seg[i].name = "*text";
+			}
+		}
+	}
 	pid = xpid;
 	s = look("pid");
 	s->v->store.u.ival = pid;
 
-	for(i=0; i<cormap->nseg; i++)
-		if(cormap->seg[i].file == nil){
-			if(strcmp(cormap->seg[i].name, "data") == 0)
-				cormap->seg[i].name = "*data";
-			if(strcmp(cormap->seg[i].name, "text") == 0)
-				cormap->seg[i].name = "*text";
-		}
 	install(pid);
 }
 
@@ -165,6 +174,7 @@
 	s->v->set = 1;
 }
 
+/*
 static int
 installed(int pid)
 {
@@ -175,6 +185,7 @@
 			return 1;
 	return 0;
 }
+*/
 
 void
 deinstall(int pid)
diff --git a/src/cmd/acid/util.c b/src/cmd/acid/util.c
index 355fd5b..3ea3c4c 100644
--- a/src/cmd/acid/util.c
+++ b/src/cmd/acid/util.c
@@ -61,7 +61,6 @@
 			continue;
 		addvarsym(fp);
 	}
-
 	if(l->v->store.u.l == nil)
 		print("no debugging symbols\n");
 }
@@ -217,9 +216,9 @@
 		l = mkvar(r->name);
 		v = l->v;
 		v->set = 1;
-		v->store.u.ival = r->offset;
+		v->store.u.reg = r->name;
 		v->store.fmt = r->format;
-		v->type = TINT;
+		v->type = TREG;
 
 		li = al(TSTRING);
 		li->store.u.string = strnode(r->name);