retire the dec alpha port

11 files changed, 0 insertions, 5406 deletions

diff --git a/sys/src/cmd/7l/asm.c b/sys/src/cmd/7l/asm.c
deleted file mode 100644
index a92ab88b5..000000000
--- a/sys/src/cmd/7l/asm.c
+++ /dev/null
@@ -1,1220 +0,0 @@
-#include	"l.h"
-
-#define	LPUT(c)\
-	{\
-		cbp[0] = (c);\
-		cbp[1] = (c)>>8;\
-		cbp[2] = (c)>>16;\
-		cbp[3] = (c)>>24;\
-		cbp += 4;\
-		cbc -= 4;\
-		if(cbc <= 0)\
-			cflush();\
-	}
-
-#define	CPUT(c)\
-	{\
-		cbp[0] = (c);\
-		cbp++;\
-		cbc--;\
-		if(cbc <= 0)\
-			cflush();\
-	}
-
-#define	VLPUT(c)\
-	{\
-		cbp[0] = (c);\
-		cbp[1] = (c)>>8;\
-		cbp[2] = (c)>>16;\
-		cbp[3] = (c)>>24;\
-		cbp[4] = (c)>>32;\
-		cbp[5] = (c)>>40;\
-		cbp[6] = (c)>>48;\
-		cbp[7] = (c)>>56;\
-		cbp += 8;\
-		cbc -= 8;\
-		if(cbc <= 0)\
-			cflush();\
-	}
-#define	LPUTBE(c)\
-	{\
-		cbp[0] = (c)>>24;\
-		cbp[1] = (c)>>16;\
-		cbp[2] = (c)>>8;\
-		cbp[3] = (c);\
-		cbp += 4;\
-		cbc -= 4;\
-		if(cbc <= 0)\
-			cflush();\
-	}
-
-long
-entryvalue(void)
-{
-	char *a;
-	Sym *s;
-
-	a = INITENTRY;
-	if(*a >= '0' && *a <= '9')
-		return atolwhex(a);
-	s = lookup(a, 0);
-	if(s->type == 0)
-		return INITTEXT;
-	if(s->type != STEXT && s->type != SLEAF)
-		diag("entry not text: %s", s->name);
-	return s->value;
-}
-
-void
-asmb(void)
-{
-	Prog *p;
-	vlong t;
-	Optab *o;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f asm\n", cputime());
-	Bflush(&bso);
-	seek(cout, HEADR, 0);
-	pc = INITTEXT;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			curtext = p;
-			autosize = p->to.offset + 8;
-		}
-		if(p->pc != pc) {
-			diag("phase error %lux sb %lux",
-				p->pc, pc);
-			if(!debug['a'])
-				prasm(curp);
-			pc = p->pc;
-		}
-		if (p->as == AMOVQ || p->as == AMOVT) {
-			if ((p->from.reg == REGSP) && (p->from.offset&7) != 0
-			|| (p->to.reg == REGSP) && (p->to.offset&7) != 0)
-				diag("bad stack alignment: %P", p);
-			if ((p->from.reg == REGSB) && (p->from.offset&7) != 0
-			|| (p->to.reg == REGSB) && (p->to.offset&7) != 0)
-				diag("bad global alignment: %P", p);
-		}
-		curp = p;
-		o = oplook(p);	/* could probably avoid this call */
-		if(asmout(p, o)) {
-			p = p->link;
-			pc += 4;
-		}
-		pc += o->size;
-	}
-	if(debug['a'])
-		Bprint(&bso, "\n");
-	Bflush(&bso);
-	cflush();
-
-	curtext = P;
-	switch(HEADTYPE) {
-	case 0:
-		seek(cout, rnd(HEADR+textsize, 8192), 0);
-		break;
-	case 1:
-	case 2:
-	case 3:
-		seek(cout, HEADR+textsize, 0);
-		break;
-	}
-	for(t = 0; t < datsize; t += sizeof(buf)-100) {
-		if(datsize-t > sizeof(buf)-100)
-			datblk(t, sizeof(buf)-100);
-		else
-			datblk(t, datsize-t);
-	}
-
-	symsize = 0;
-	lcsize = 0;
-	if(!debug['s']) {
-		if(debug['v'])
-			Bprint(&bso, "%5.2f sym\n", cputime());
-		Bflush(&bso);
-		switch(HEADTYPE) {
-		case 0:
-			seek(cout, rnd(HEADR+textsize, 8192)+datsize, 0);
-			break;
-		case 2:
-		case 1:
-		case 3:
-			seek(cout, HEADR+textsize+datsize, 0);
-			break;
-		}
-		if(!debug['s'])
-			asmsym();
-		if(debug['v'])
-			Bprint(&bso, "%5.2f pc\n", cputime());
-		Bflush(&bso);
-		if(!debug['s'])
-			asmlc();
-		cflush();
-	}
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f header\n", cputime());
-	Bflush(&bso);
-	seek(cout, 0L, 0);
-	switch(HEADTYPE) {
-	case 0:
-		lput(0x0183L);		/* magic and sections */
-		lput(0L);			/* time and date */
-		vlput(rnd(HEADR+textsize, 8192)+datsize);
-		lput(symsize);			/* nsyms */
-		lput(0x50L|(7L<<16));		/* size of optional hdr and flags */
-		lput(0413|(0x101L<<16));	/* magic and version */
-		lput(-1);			/* pad for alignment */
-
-		vlput(rnd(HEADR+textsize, 8192));		/* sizes */
-		vlput(datsize);
-		vlput(bsssize);
-		vlput(entryvalue());		/* va of entry */
-		vlput(INITTEXT-HEADR);		/* va of base of text */
-		vlput(INITDAT);			/* va of base of data */
-		vlput(INITDAT+datsize);		/* va of base of bss */
-		lput(~0L);			/* gp reg mask */
-		/* dubious stuff starts here */
-		lput(0L);
-		lput(0L);
-		lput(0L);
-		lput(0L);
-		lput(~0L);			/* gp value ?? */
-		break;
-	case 1:
-		lput(0x0183L);		/* magic and sections */
-		lput(0L);			/* time and date */
-		vlput(HEADR+textsize+datsize);
-		lput(symsize);			/* nsyms */
-		lput(0x54L|(7L<<16));		/* size of optional hdr and flags */
-		lput(0407|(0x101L<<16));	/* magic and version */
-		lput(-1);			/* pad for alignment */
-
-		vlput(textsize);		/* sizes */
-		vlput(datsize);
-		vlput(bsssize);
-		vlput(entryvalue());		/* va of entry */
-		vlput(INITTEXT);		/* va of base of text */
-		vlput(INITDAT);			/* va of base of data */
-		vlput(INITDAT+datsize);		/* va of base of bss */
-		lput(~0L);			/* gp reg mask */
-		/* dubious stuff starts here */
-		lput(lcsize);
-		lput(0L);
-		lput(0L);
-		lput(0L);
-		lput(~0L);			/* gp value ?? */
-		lput(0L);			/* complete mystery */
-		break;
-	case 2:
-		lputbe(0x84b);			/* magic */
-		lputbe(textsize);		/* sizes */
-		lputbe(datsize);
-		lputbe(bsssize);
-		lputbe(symsize);		/* nsyms */
-		lputbe(entryvalue());		/* va of entry */
-		lputbe(0L);
-		lputbe(lcsize);
-		break;
-	case 3:
-		/* ``headerless'' boot image -- magic no is a branch */
-		lput(0xc3e00007);		/* magic (branch) */
-		lputbe(textsize);		/* sizes */
-		lputbe(datsize);
-		lputbe(bsssize);
-		lputbe(symsize);		/* nsyms */
-		lputbe(entryvalue());		/* va of entry */
-		lputbe(0L);
-		lputbe(lcsize);
-		break;
-	}
-	cflush();
-}
-
-void
-lput(long l)
-{
-	LPUT(l);
-}
-
-void
-lputbe(long l)
-{
-	LPUTBE(l);
-}
-
-void
-vlput(vlong l)
-{
-	VLPUT(l);
-}
-
-void
-cflush(void)
-{
-	int n;
-
-	n = sizeof(buf.cbuf) - cbc;
-	if(n)
-		write(cout, buf.cbuf, n);
-	cbp = buf.cbuf;
-	cbc = sizeof(buf.cbuf);
-}
-
-void
-asmsym(void)
-{
-	Prog *p;
-	Auto *a;
-	Sym *s;
-	int h;
-
-	s = lookup("etext", 0);
-	if(s->type == STEXT)
-		putsymb(s->name, 'T', s->value, s->version);
-
-	for(h=0; h<NHASH; h++)
-		for(s=hash[h]; s!=S; s=s->link)
-			switch(s->type) {
-			case SCONST:
-				putsymb(s->name, 'D', s->value, s->version);
-				continue;
-
-			case SDATA:
-				putsymb(s->name, 'D', s->value+INITDAT, s->version);
-				continue;
-
-			case SBSS:
-				putsymb(s->name, 'B', s->value+INITDAT, s->version);
-				continue;
-
-			case SFILE:
-				putsymb(s->name, 'f', s->value, s->version);
-				continue;
-			}
-
-	for(p=textp; p!=P; p=p->cond) {
-		s = p->from.sym;
-		if(s->type != STEXT && s->type != SLEAF)
-			continue;
-
-		/* filenames first */
-		for(a=p->to.autom; a; a=a->link)
-			if(a->type == D_FILE)
-				putsymb(a->sym->name, 'z', a->offset, 0);
-			else
-			if(a->type == D_FILE1)
-				putsymb(a->sym->name, 'Z', a->offset, 0);
-
-		if(s->type == STEXT)
-			putsymb(s->name, 'T', s->value, s->version);
-		else
-			putsymb(s->name, 'L', s->value, s->version);
-
-		/* frame, auto and param after */
-		putsymb(".frame", 'm', p->to.offset+8, 0);
-		for(a=p->to.autom; a; a=a->link)
-			if(a->type == D_AUTO)
-				putsymb(a->sym->name, 'a', -a->offset, 0);
-			else
-			if(a->type == D_PARAM)
-				putsymb(a->sym->name, 'p', a->offset, 0);
-	}
-	if(debug['v'] || debug['n'])
-		Bprint(&bso, "symsize = %lud\n", symsize);
-	Bflush(&bso);
-}
-
-void
-putsymb(char *s, int t, long v, int ver)
-{
-	int i, f;
-
-	if(t == 'f')
-		s++;
-	LPUTBE(v);
-	if(ver)
-		t += 'a' - 'A';
-	CPUT(t+0x80);			/* 0x80 is variable length */
-
-	if(t == 'Z' || t == 'z') {
-		CPUT(s[0]);
-		for(i=1; s[i] != 0 || s[i+1] != 0; i += 2) {
-			CPUT(s[i]);
-			CPUT(s[i+1]);
-		}
-		CPUT(0);
-		CPUT(0);
-		i++;
-	}
-	else {
-		for(i=0; s[i]; i++)
-			CPUT(s[i]);
-		CPUT(0);
-	}
-	symsize += 4 + 1 + i + 1;
-
-	if(debug['n']) {
-		if(t == 'z' || t == 'Z') {
-			Bprint(&bso, "%c %.8lux ", t, v);
-			for(i=1; s[i] != 0 || s[i+1] != 0; i+=2) {
-				f = ((s[i]&0xff) << 8) | (s[i+1]&0xff);
-				Bprint(&bso, "/%x", f);
-			}
-			Bprint(&bso, "\n");
-			return;
-		}
-		if(ver)
-			Bprint(&bso, "%c %.8lux %s<%d>\n", t, v, s, ver);
-		else
-			Bprint(&bso, "%c %.8lux %s\n", t, v, s);
-	}
-}
-
-#define	MINLC	4
-void
-asmlc(void)
-{
-	long oldpc, oldlc;
-	Prog *p;
-	long v, s;
-
-	oldpc = INITTEXT;
-	oldlc = 0;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->line == oldlc || p->as == ATEXT || p->as == ANOP) {
-			if(p->as == ATEXT)
-				curtext = p;
-			if(debug['L'])
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			continue;
-		}
-		if(debug['L'])
-			Bprint(&bso, "\t\t%6ld", lcsize);
-		v = (p->pc - oldpc) / MINLC;
-		while(v) {
-			s = 127;
-			if(v < 127)
-				s = v;
-			CPUT(s+128);	/* 129-255 +pc */
-			if(debug['L'])
-				Bprint(&bso, " pc+%ld*%d(%ld)", s, MINLC, s+128);
-			v -= s;
-			lcsize++;
-		}
-		s = p->line - oldlc;
-		oldlc = p->line;
-		oldpc = p->pc + MINLC;
-		if(s > 64 || s < -64) {
-			CPUT(0);	/* 0 vv +lc */
-			CPUT(s>>24);
-			CPUT(s>>16);
-			CPUT(s>>8);
-			CPUT(s);
-			if(debug['L']) {
-				if(s > 0)
-					Bprint(&bso, " lc+%ld(%d,%ld)\n",
-						s, 0, s);
-				else
-					Bprint(&bso, " lc%ld(%d,%ld)\n",
-						s, 0, s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-			lcsize += 5;
-			continue;
-		}
-		if(s > 0) {
-			CPUT(0+s);	/* 1-64 +lc */
-			if(debug['L']) {
-				Bprint(&bso, " lc+%ld(%ld)\n", s, 0+s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-		} else {
-			CPUT(64-s);	/* 65-128 -lc */
-			if(debug['L']) {
-				Bprint(&bso, " lc%ld(%ld)\n", s, 64-s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-		}
-		lcsize++;
-	}
-	while(lcsize & 1) {
-		s = 129;
-		CPUT(s);
-		lcsize++;
-	}
-	if(debug['v'] || debug['L'])
-		Bprint(&bso, "lcsize = %ld\n", lcsize);
-	Bflush(&bso);
-}
-
-void
-datblk(long s, long n)
-{
-	Prog *p;
-	char *cast;
-	long l, fl, j, d;
-	int i, c;
-
-	memset(buf.dbuf, 0, n+100);
-	for(p = datap; p != P; p = p->link) {
-		curp = p;
-		l = p->from.sym->value + p->from.offset - s;
-		c = p->reg;
-		i = 0;
-		if(l < 0) {
-			if(l+c <= 0)
-				continue;
-			while(l < 0) {
-				l++;
-				i++;
-			}
-		}
-		if(l >= n)
-			continue;
-		if(p->as != AINIT && p->as != ADYNT) {
-			for(j=l+(c-i)-1; j>=l; j--)
-				if(buf.dbuf[j]) {
-					print("%P\n", p);
-					diag("multiple initialization");
-					break;
-				}
-		}
-		switch(p->to.type) {
-		default:
-			diag("unknown mode in initialization\n%P", p);
-			break;
-
-		case D_FCONST:
-			switch(c) {
-			default:
-			case 4:
-				fl = ieeedtof(p->to.ieee);
-				cast = (char*)&fl;
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[fnuxi8[i]];
-					l++;
-				}
-				break;
-			case 8:
-				cast = (char*)p->to.ieee;
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[fnuxi8[i]];
-					l++;
-				}
-				break;
-			}
-			break;
-
-		case D_SCONST:
-			for(; i<c; i++) {
-				buf.dbuf[l] = p->to.sval[i];
-				l++;
-			}
-			break;
-
-		case D_CONST:
-			d = p->to.offset;
-			if(p->to.sym) {
-				if(p->to.sym->type == STEXT ||
-				   p->to.sym->type == SLEAF)
-					d += p->to.sym->value;
-				if(p->to.sym->type == SDATA)
-					d += p->to.sym->value + INITDAT;
-				if(p->to.sym->type == SBSS)
-					d += p->to.sym->value + INITDAT;
-			}
-			cast = (char*)&d;
-			switch(c) {
-			default:
-				diag("bad nuxi %d %d\n%P", c, i, curp);
-				break;
-			case 1:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi1[i]];
-					l++;
-				}
-				break;
-			case 2:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi2[i]];
-					l++;
-				}
-				break;
-			case 4:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi4[i]];
-					l++;
-				}
-				break;
-			case 8:
-				for(; i<4; i++) {
-					buf.dbuf[l] = cast[inuxi4[i]];
-					l++;
-				}
-				d = p->to.offset >> 32;
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi4[i-4]];
-					l++;
-				}
-				break;
-			}
-			break;
-		}
-	}
-	write(cout, buf.dbuf, n);
-}
-
-#define	OP_RRR(op,r1,r2,r3)\
-	(op|(((r1)&31L)<<16)|(((r2)&31L)<<21)|((r3)&31L))
-#define	OP_IRR(op,i,r2,r3)\
-	(op|(((i)&255L)<<13)|0x1000|(((r2)&31L)<<21)|((r3)&31L))
-#define	OP_MEM(op,d,r1,r2)\
-	(op|(((r1)&31L)<<16)|(((r2)&31L)<<21)|((d)&0xffff))
-#define OP_BR(op,d,r1)\
-	(op|((d)&0x1fffff)|(((r1)&31L)<<21))
-
-int
-asmout(Prog *p, Optab *o)
-{
-	long o1, o2, o3, o4, o5, o6;
-	vlong v;
-	int r, a;
-
-	o1 = 0;
-	o2 = 0;
-	o3 = 0;
-	o4 = 0;
-	o5 = 0;
-	o6 = 0;
-	switch(o->type) {
-	default:
-		diag("unknown type %d", o->type);
-		if(!debug['a'])
-			prasm(p);
-		break;
-
-	case 0:		/* pseudo ops */
-		break;
-
-	case 1:		/* register-register moves */
-		if(p->as == AMOVB || p->as == AMOVW)		/* noop should rewrite */
-			diag("forbidden SEX: %P", p);
-		if(p->as == AMOVBU || p->as == AMOVWU) {
-			v = 1;
-			if (p->as == AMOVWU)
-				v = 3;
-			o1 = OP_IRR(opcode(AZAPNOT), v, p->from.reg, p->to.reg);
-		}
-		else {
-			a = AOR;
-			if(p->as == AMOVL)
-				a = AADDL;
-			if(p->as == AMOVLU)
-				a = AEXTLL;
-			o1 = OP_RRR(opcode(a), REGZERO, p->from.reg, p->to.reg);
-		}
-		break;
-
-	case 2:		/* <operate> r1,[r2],r3 */
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		o1 = OP_RRR(opcode(p->as), p->from.reg, r, p->to.reg);
-		break;
-
-	case 3:		/* <operate> $n,[r2],r3 */
-		v = regoff(&p->from);
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		o1 = OP_IRR(opcode(p->as), v, r, p->to.reg);
-		break;
-
-	case 4:		/* beq r1,sbra */
-		if(p->cond == P)
-			v = -4 >> 2;
-		else
-			v = (p->cond->pc - pc-4) >> 2;
-		o1 = OP_BR(opcode(p->as), v, p->from.reg);
-		break;
-
-	case 5:		/* jmp [r1],0(r2) */
-		r = p->reg;
-		a = p->as;
-		if(r == NREG) {
-			r = o->param;
-/*			if(a == AJMP && p->to.reg == REGLINK)
-				a = ARET; /* this breaks the kernel -- maybe we need to clear prediction stack on each context switch... */
-		}
-		o1 = OP_MEM(opcode(a), 0, p->to.reg, r);
-		break;
-
-	case 6:		/* movq $n,r1 and movq $soreg,r1 */
-		r = p->from.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->from);
-		o1 = OP_MEM(opcode(AMOVA), v, r, p->to.reg);
-		break;
-
-	case 7:		/* movbu r1, r2 */
-		v = 1;
-		if (p->as == AMOVWU)
-			v = 3;
-		o1 = OP_IRR(opcode(AZAPNOT), v, p->from.reg, p->to.reg);
-		break;
-
-	case 8:		/* mov r, soreg ==> stq o(r) */
-		r = p->to.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->to);
-		if (p->as == AMOVQ || p->as == AMOVT)
-			if ((r == REGSP || r == REGSB) && (v&7) != 0)
-				diag("bad alignment: %P", p);
-		o1 = OP_MEM(opcode(p->as+AEND), v, r, p->from.reg);
-		break;
-
-	case 9:		/* mov soreg, r ==> ldq o(r) */
-		r = p->from.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->from);
-		if (p->as == AMOVQ || p->as == AMOVT)
-			if ((r == REGSP || r == REGSB) && (v&7) != 0)
-				diag("bad alignment: %P", p);
-		o1 = OP_MEM(opcode(p->as), v, r, p->to.reg);
-		break;
-
-	case 10:	/* movb r1,r2 */
-		v = 64 - 8;
-		if (p->as == AMOVW)
-			v = 64 - 16;
-		o1 = OP_IRR(opcode(ASLLQ), v, p->from.reg, p->to.reg);
-		o2 = OP_IRR(opcode(ASRAQ), v, p->to.reg, p->to.reg);
-		break;
-
-	case 11:	/* jmp lbra */
-		if(p->cond == P)
-			v = -4 >> 2;
-		else
-			v = (p->cond->pc - pc-4) >> 2;
-		a = ABR;
-		r = REGZERO;
-		if (p->as == AJSR) {
-			a = ABSR;
-			r = REGLINK;
-		}
-		o1 = OP_BR(opcode(a), v, r);
-		break;
-
-	case 12:	/* addq $n,[r2],r3 ==> lda */
-		v = regoff(&p->from);
-		if (p->as == ASUBQ)
-			v = -v;
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		o1 = OP_MEM(opcode(AMOVA), v, r, p->to.reg);
-		break;
-
-	case 13:	/* <op> $scon,[r2],r3 */
-		v = regoff(&p->from);
-		if(p->to.reg == REGTMP || p->reg == REGTMP)
-			diag("cant synthesize large constant\n%P", p);
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		o1 = OP_MEM(opcode(AMOVA), v, REGZERO, REGTMP);
-		o2 = OP_RRR(opcode(p->as), REGTMP, r, p->to.reg);
-		break;
-
-	case 14:	/* <op> $lcon,[r2],r3 */
-		v = regoff(&p->from);
-		if(v & 0x8000)
-			v += 0x10000;
-		if(p->to.reg == REGTMP || p->reg == REGTMP)
-			diag("cant synthesize large constant\n%P", p);
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		o1 = OP_MEM(opcode(AMOVA), v, REGZERO, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, REGTMP);
-		o3 = OP_RRR(opcode(p->as), REGTMP, r, p->to.reg);
-		break;
-
-	case 15:	/* mov $lcon,r1 */
-		v = regoff(&p->from);
-		if(v & 0x8000)
-			v += 0x10000;
-		o1 = OP_MEM(opcode(AMOVA), v, o->param, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, p->to.reg);
-		break;
-
-	case 16:	/* mov $qcon,r1 */
-		v = regoff(&p->from);
-		if(v & 0x8000)
-			v += 0x10000;
-		if((v>>31)&1)
-			v += (1LL<<32);
-		if((v>>47)&1)
-			v += (1LL<<48);
-		o1 = OP_MEM(opcode(AMOVA), v>>32, o->param, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>48, REGTMP, REGTMP);
-		o3 = OP_IRR(opcode(ASLLQ), 32, REGTMP, REGTMP);
-		o4 = OP_MEM(opcode(AMOVA), v, REGTMP, REGTMP);
-		o5 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, p->to.reg);
-		break;
-
-	case 17:	/* mov f1,f2 ==> fcpys f1,f1,f2 */
-		o1 = OP_RRR(opcode(ACPYS), p->from.reg, p->from.reg, p->to.reg);
-		break;
-
-	case 18:	/* call_pal imm */
-		v = regoff(&p->from);
-		o1 = OP_MEM(opcode(ACALL_PAL), v, 0, 0);
-		break;
-
-	case 19:	/* mov r, loreg ==> ldah,stq */
-		r = p->to.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->to);
-		if (p->as == AMOVQ || p->as == AMOVT)
-			if ((r == REGSP || r == REGSB) && (v&7) != 0)
-				diag("bad alignment: %P", p);
-		if(v & 0x8000)
-			v += 0x10000;
-		o1 = OP_MEM(opcode(AMOVAH), v>>16, r, REGTMP);
-		o2 = OP_MEM(opcode(p->as+AEND), v, REGTMP, p->from.reg);
-		break;
-
-	case 20:	/* mov loreg, r ==> ldah,ldq */
-		r = p->from.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->from);
-		if (p->as == AMOVQ || p->as == AMOVT)
-			if ((r == REGSP || r == REGSB) && (v&7) != 0)
-				diag("bad alignment: %P", p);
-		if(v & 0x8000)
-			v += 0x10000;
-		o1 = OP_MEM(opcode(AMOVAH), v>>16, r, REGTMP);
-		o2 = OP_MEM(opcode(p->as), v, REGTMP, p->to.reg);
-		break;
-
-#ifdef	NEVER
-	case 21:	/* mov r1,$qoreg */
-		r = p->to.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->to);
-		if(v & 0x8000)
-			v += 0x10000;
-		if((v>>31)&1)
-			v += (1LL<<32);
-		if((v>>47)&1)
-			v += (1LL<<48);
-		o1 = OP_MEM(opcode(AMOVA), v>>32, r, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>48, REGTMP, REGTMP);
-		o3 = OP_IRR(opcode(ASLLQ), 32, REGTMP, REGTMP);
-		o4 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, REGTMP);
-		o5 = OP_MEM(opcode(p->as+AEND), v, REGTMP, p->from.reg);
-		break;
-
-	case 22:	/* mov $qoreg,r1 */
-		r = p->from.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->from);
-		if(v & 0x8000)
-			v += 0x10000;
-		if((v>>31)&1)
-			v += (1LL<<32);
-		if((v>>47)&1)
-			v += (1LL<<48);
-		o1 = OP_MEM(opcode(AMOVA), v>>32, r, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>48, REGTMP, REGTMP);
-		o3 = OP_IRR(opcode(ASLLQ), 32, REGTMP, REGTMP);
-		o4 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, REGTMP);
-		o5 = OP_MEM(opcode(p->as), v, REGTMP, p->to.reg);
-		break;
-#endif
-
-	case 23:	/* <op> $qcon,r1 */
-		if(p->to.reg == REGTMP || p->reg == REGTMP)
-			diag("cant synthesize large constant\n%P", p);
-		v = regoff(&p->from);
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		if(v & 0x8000)
-			v += 0x10000;
-		if((v>>31)&1)
-			v += (1LL<<32);
-		if((v>>47)&1)
-			v += (1LL<<48);
-		o1 = OP_MEM(opcode(AMOVA), v>>32, REGZERO, REGTMP);
-		o2 = OP_MEM(opcode(AMOVAH), v>>48, REGTMP, REGTMP);
-		o3 = OP_IRR(opcode(ASLLQ), 32, REGTMP, REGTMP);
-		o4 = OP_MEM(opcode(AMOVA), v, REGTMP, REGTMP);
-		o5 = OP_MEM(opcode(AMOVAH), v>>16, REGTMP, REGTMP);
-		o6 = OP_RRR(opcode(p->as), REGTMP, r, p->to.reg);
-		break;
-
-	case 24:	/* movq Fn, FPCR */
-		r = p->from.reg;
-		o1 = OP_RRR(opcode(AADDT+AEND), r, r, r);
-		break;
-
-	case 25:	/* movq FPCR, Fn */
-		r = p->to.reg;
-		o1 = OP_RRR(opcode(AADDS+AEND), r, r, r);
-		break;
-
-	case 26:	/* movq Rn, C_PREG */
-		r = p->from.reg;
-		o1 = OP_RRR(opcode(ASUBQ+AEND), r, r, 0) | p->to.reg & 255;
-		break;
-
-	case 27:	/* movq C_PREG, Rn */
-		r = p->to.reg;
-		o1 = OP_RRR(opcode(AADDQ+AEND), r, r, 0) | p->from.reg & 255;
-		break;
-
-	case 28:	/* cvttq r1,r3 */
-		r = p->from.reg;
-		o1 = OP_RRR(opcode(p->as), r, REGZERO, p->to.reg);
-		break;
-
-	case 29:	/* movq pcc, rpcc -> Rn */
-		o1 = OP_MEM(opcode(ARPCC), 0, REGZERO, p->to.reg);
-		break;
-
-	case 30:	/* rei/mb/trapb */
-		o1 = OP_MEM(opcode(p->as), 0, REGZERO, REGZERO);
-		break;
-
-	case 31:	/* fetch (Rn) */
-		o1 = OP_MEM(opcode(p->as), 0, REGZERO, p->from.reg);
-		break;
-
-	case 32:	/* movqp r, soreg ==> stqp o(r) */
-		r = p->to.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->to);
-		if (v < -0x800 || v >= 0x800)
-			diag("physical store out of range\n%P", p);
-		v &= 0xfff;
-		o1 = OP_MEM(opcode(p->as+AEND), v, r, p->from.reg);
-		break;
-
-	case 33:	/* movqp soreg, r ==> ldqp o(r) */
-		r = p->from.reg;
-		if(r == NREG)
-			r = o->param;
-		v = regoff(&p->from);
-		if (v < -0x800 || v >= 0x800)
-			diag("physical load out of range\n%P", p);
-		v &= 0xfff;
-		o1 = OP_MEM(opcode(p->as), v, r, p->to.reg);
-		break;
-
-	case 34:	/* <operate> $-n,[r2],r3 */
-		v = regoff(&p->from);
-		r = p->reg;
-		if(r == NREG)
-			r = p->to.reg;
-		switch (a = p->as) {
-		case AAND:
-			a = AANDNOT;
-			break;
-		case AANDNOT:
-			a = AAND;
-			break;
-		case AOR:
-			a = AORNOT;
-			break;
-		case AORNOT:
-			a = AOR;
-			break;
-		case AXOR:
-			a = AXORNOT;
-			break;
-		case AXORNOT:
-			a = AXOR;
-			break;
-		default:
-			diag("bad in NCON case: %P", p);
-		}
-		v = ~v;
-		o1 = OP_IRR(opcode(a), v, r, p->to.reg);
-		break;
-
-	case 40:	/* word */
-		o1 = regoff(&p->to);
-		break;
-
-	}
-	switch(o->size) {
-	default:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux:\t\t%P\n", p->pc, p);
-		break;
-	case 4:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux\t%P\n", p->pc, o1, p);
-		LPUT(o1);
-		break;
-	case 8:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %P\n", p->pc, o1, o2, p);
-		LPUT(o1);
-		LPUT(o2);
-		break;
-	case 12:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %P\n", p->pc, o1, o2, o3, p);
-		LPUT(o1);
-		LPUT(o2);
-		LPUT(o3);
-		break;
-	case 16:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %P\n",
-				p->pc, o1, o2, o3, o4, p);
-		LPUT(o1);
-		LPUT(o2);
-		LPUT(o3);
-		LPUT(o4);
-		break;
-	case 20:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %P\n",
-				p->pc, o1, o2, o3, o4, o5, p);
-		LPUT(o1);
-		LPUT(o2);
-		LPUT(o3);
-		LPUT(o4);
-		LPUT(o5);
-		break;
-	case 24:
-		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux %P\n",
-				p->pc, o1, o2, o3, o4, o5, o6, p);
-		LPUT(o1);
-		LPUT(o2);
-		LPUT(o3);
-		LPUT(o4);
-		LPUT(o5);
-		LPUT(o6);
-		break;
-	}
-	return 0;
-}
-
-#define	OP(x,y)	(((x)<<26)|((y)<<5))
-#define	FP(x)	OP(22, (x)|0xc0)	/* note: this sets round/trap modes (dynamic, software?). not used for cvtxx? */
-#define	FP2(x)	OP(22, (x) /*|0x080*/)	/* note: this sets round/trap modes (chopped, software?). used for cvtxx? */
-#define	FP3(x)	OP(22, (x)|0x080)	/* note: this sets round/trap modes (dynamic, software?). not used for cvtxx? */
-
-long
-opcode(int a)
-{
-	switch (a) {
-	/* loads */
-	case AMOVB:		/* misnomer; pretend it's ok for now */
-diag("opcode(AMOVB)");
-	case AMOVBU:		return OP(10, 0);	/* v 3 */
-	case AMOVW:		/* misnomer; pretend it's ok for now */
-diag("opcode(AMOVW)");
-	case AMOVWU:		return OP(12, 0);	/* v 3 */
-	case AMOVL:		return OP(40, 0);
-	case AMOVQ:		return OP(41, 0);
-	case AMOVQU:		return OP(11, 0);
-	case AMOVS:		return OP(34, 0);
-	case AMOVT:		return OP(35, 0);
-
-	/* stores */
-	case AMOVB+AEND:		/* misnomer; pretend it's ok for now */
-	case AMOVBU+AEND:	return OP(14, 0);	/* v 3 */
-	case AMOVW+AEND:	/* misnomer; pretend it's ok for now */
-	case AMOVWU+AEND:	return OP(13, 0);	/* v 3 */
-	case AMOVL+AEND:	return OP(44, 0);
-	case AMOVQ+AEND:	return OP(45, 0);
-	case AMOVQU+AEND:	return OP(15, 0);
-	case AMOVS+AEND:	return OP(38, 0);
-	case AMOVT+AEND:	return OP(39, 0);
-
-	/* physical */
-	case AMOVLP+AEND:	return OP(31, 0)|0x8000;
-	case AMOVQP+AEND:	return OP(31, 0)|0x9000;
-	case AMOVLP:		return OP(27, 0)|0x8000;
-	case AMOVQP:		return OP(27, 0)|0x9000;
-
-	/* load address */
-	case AMOVA:		return OP(8, 0);
-	case AMOVAH:		return OP(9, 0);
-
-	/* locking */
-	case AMOVLL:		return OP(42, 0);	/* load locked */
-	case AMOVQL:		return OP(43, 0);	/* load locked */
-	case AMOVLC+AEND:	return OP(46, 0);	/* store cond */
-	case AMOVQC+AEND:	return OP(47, 0);	/* store cond */
-
-	case AADDL:		return OP(16, 0);
-	case AADDLV:		return OP(16, 64);
-	case AADDQ:		return OP(16, 32);
-	case AADDQV:		return OP(16, 96);
-	case AS4ADDL:		return OP(16, 2);
-	case AS4ADDQ:		return OP(16, 34);
-	case AS8ADDL:		return OP(16, 18);
-	case AS8ADDQ:		return OP(16, 50);
-	case AS4SUBL:		return OP(16, 11);
-	case AS4SUBQ:		return OP(16, 43);
-	case AS8SUBL:		return OP(16, 27);
-	case AS8SUBQ:		return OP(16, 59);
-	case ASUBL:		return OP(16, 9);
-	case ASUBLV:		return OP(16, 73);
-	case ASUBQ:		return OP(16, 41);
-	case ASUBQV:		return OP(16, 105);
-	case ACMPEQ:		return OP(16, 45);
-	case ACMPGT:		return OP(16, 77);
-	case ACMPGE:		return OP(16, 109);
-	case ACMPUGT:		return OP(16, 29);
-	case ACMPUGE:		return OP(16, 61);
-	case ACMPBLE:		return OP(16, 15);
-
-	case AAND:		return OP(17, 0);
-	case AANDNOT:		return OP(17, 8);
-	case AOR:		return OP(17, 32);
-	case AORNOT:		return OP(17, 40);
-	case AXOR:		return OP(17, 64);
-	case AXORNOT:		return OP(17, 72);
-
-	case ACMOVEQ:		return OP(17, 36);
-	case ACMOVNE:		return OP(17, 38);
-	case ACMOVLT:		return OP(17, 68);
-	case ACMOVGE:		return OP(17, 70);
-	case ACMOVLE:		return OP(17, 100);
-	case ACMOVGT:		return OP(17, 102);
-	case ACMOVLBS:		return OP(17, 20);
-	case ACMOVLBC:		return OP(17, 22);
-
-	case AMULL:		return OP(19, 0);
-	case AMULQ:		return OP(19, 32);
-	case AMULLV:		return OP(19, 64);
-	case AMULQV:		return OP(19, 96);
-	case AUMULH:		return OP(19, 48);
-
-	case ASLLQ:		return OP(18, 57);
-	case ASRLQ:		return OP(18, 52);
-	case ASRAQ:		return OP(18, 60);
-
-	case AEXTBL:		return OP(18, 6);
-	case AEXTWL:		return OP(18, 22);
-	case AEXTLL:		return OP(18, 38);
-	case AEXTQL:		return OP(18, 54);
-	case AEXTWH:		return OP(18, 90);
-	case AEXTLH:		return OP(18, 106);
-	case AEXTQH:		return OP(18, 122);
-
-	case AINSBL:		return OP(18, 11);
-	case AINSWL:		return OP(18, 27);
-	case AINSLL:		return OP(18, 43);
-	case AINSQL:		return OP(18, 59);
-	case AINSWH:		return OP(18, 87);
-	case AINSLH:		return OP(18, 103);
-	case AINSQH:		return OP(18, 119);
-
-	case AMSKBL:		return OP(18, 2);
-	case AMSKWL:		return OP(18, 18);
-	case AMSKLL:		return OP(18, 34);
-	case AMSKQL:		return OP(18, 50);
-	case AMSKWH:		return OP(18, 82);
-	case AMSKLH:		return OP(18, 98);
-	case AMSKQH:		return OP(18, 114);
-
-	case AZAP:		return OP(18, 48);
-	case AZAPNOT:		return OP(18, 49);
-
-	case AJMP:		return OP(26, 0);
-	case AJSR:		return OP(26, 512);
-	case ARET:		return OP(26, 1024);
-
-	case ABR:		return OP(48, 0);
-	case ABSR:		return OP(52, 0);
-
-	case ABEQ:		return OP(57, 0);
-	case ABNE:		return OP(61, 0);
-	case ABLT:		return OP(58, 0);
-	case ABGE:		return OP(62, 0);
-	case ABLE:		return OP(59, 0);
-	case ABGT:		return OP(63, 0);
-	case ABLBC:		return OP(56, 0);
-	case ABLBS:		return OP(60, 0);
-
-	case AFBEQ:		return OP(49, 0);
-	case AFBNE:		return OP(53, 0);
-	case AFBLT:		return OP(50, 0);
-	case AFBGE:		return OP(54, 0);
-	case AFBLE:		return OP(51, 0);
-	case AFBGT:		return OP(55, 0);
-
-	case ATRAPB:		return OP(24, 0);
-	case AMB:		return OP(24, 0x200);
-	case AFETCH:		return OP(24, 0x400);
-	case AFETCHM:		return OP(24, 0x500);
-	case ARPCC:		return OP(24, 0x600);
-
-	case ACPYS:		return OP(23, 32);
-	case ACPYSN:		return OP(23, 33);
-	case ACPYSE:		return OP(23, 34);
-	case AADDS+AEND:	return OP(23, 37);	/* MF_FPCR */
-	case AADDT+AEND:	return OP(23, 36);	/* MT_FPCR */
-	case ACVTLQ:		return OP(23, 16);
-	case ACVTQL:		return OP(23, 48);	/* XXX trap mode */
-	case AFCMOVEQ:		return OP(23, 42);
-	case AFCMOVNE:		return OP(23, 43);
-	case AFCMOVLT:		return OP(23, 44);
-	case AFCMOVGE:		return OP(23, 45);
-	case AFCMOVLE:		return OP(23, 46);
-	case AFCMOVGT:		return OP(23, 47);
-
-	case AADDS:		return FP(0);
-	case AADDT:		return FP(32);
-	case ACMPTEQ:		return FP3(37);
-	case ACMPTGT:		return FP3(38);
-	case ACMPTGE:		return FP3(39);
-	case ACMPTUN:		return FP3(36);
-
-	case ACVTQS:		return FP2(60);
-	case ACVTQT:		return FP2(62);
-	case ACVTTS:		return FP2(44);
-	case ACVTTQ:		return FP2(47);
-
-	case ADIVS:		return FP(3);
-	case ADIVT:		return FP(35);
-	case AMULS:		return FP(2);
-	case AMULT:		return FP(34);
-	case ASUBS:		return FP(1);
-	case ASUBT:		return FP(33);
-
-	case ACALL_PAL:		return 0;
-	case AREI:		return OP(30, 0x400);	/* HW_REI */
-
-	case AADDQ+AEND:	return OP(25,0);	/* HW_MFPR */
-	case ASUBQ+AEND:	return OP(29,0);	/* HW_MTPR */
-	}
-	diag("bad op %A(%d)", a, a);
-	return 0;
-}
-
diff --git a/sys/src/cmd/7l/compat.c b/sys/src/cmd/7l/compat.c
deleted file mode 100644
index 1d9f89e43..000000000
--- a/sys/src/cmd/7l/compat.c
+++ /dev/null
@@ -1,56 +0,0 @@
-#include	"l.h"
-
-/*
- * fake malloc
- */
-void*
-malloc(ulong n)
-{
-	void *p;
-
-	while(n & 7)
-		n++;
-	while(nhunk < n)
-		gethunk();
-	p = hunk;
-	nhunk -= n;
-	hunk += n;
-	return p;
-}
-
-void
-free(void *p)
-{
-	USED(p);
-}
-
-void*
-calloc(ulong m, ulong n)
-{
-	void *p;
-
-	n *= m;
-	p = malloc(n);
-	memset(p, 0, n);
-	return p;
-}
-
-void*
-realloc(void *p, ulong n)
-{
-	fprint(2, "realloc(0x%p %ld) called\n", p, n);
-	abort();
-	return 0;
-}
-
-void*
-mysbrk(ulong size)
-{
-	return sbrk(size);
-}
-
-void
-setmalloctag(void *v, uintptr pc)
-{
-	USED(v, pc);
-}
diff --git a/sys/src/cmd/7l/l.h b/sys/src/cmd/7l/l.h
deleted file mode 100644
index e5f853c82..000000000
--- a/sys/src/cmd/7l/l.h
+++ /dev/null
@@ -1,316 +0,0 @@
-#include	<u.h>
-#include	<libc.h>
-#include	<bio.h>
-#include	"../7c/7.out.h"
-
-typedef	struct	Adr	Adr;
-typedef	struct	Sym	Sym;
-typedef	struct	Autom	Auto;
-typedef	struct	Prog	Prog;
-typedef	struct	Optab	Optab;
-typedef	struct	Oprang	Oprang;
-typedef	uchar	Opcross[32][2][32];
-typedef	struct	Count	Count;
-
-#define	P		((Prog*)0)
-#define	S		((Sym*)0)
-#define	TNAME		(curtext&&curtext->from.sym?curtext->from.sym->name:noname)
-
-struct	Adr
-{
-	union
-	{
-		vlong	offset;
-		char*	sval;
-		Ieee*	ieee;
-	};
-	union
-	{
-		Auto*	autom;
-		Sym*	sym;
-	};
-	char	type;
-	char	reg;
-	char	name;
-	char	class;
-};
-struct	Prog
-{
-	Adr	from;
-	Adr	to;
-	union
-	{
-		long	regused;
-		Prog*	forwd;
-	};
-	Prog*	cond;
-	Prog*	link;
-	long	pc;
-	long	line;
-	uchar	mark;
-	uchar	optab;
-	uchar	as;
-	char	reg;
-};
-struct	Sym
-{
-	char	*name;
-	short	type;
-	short	version;
-	short	become;
-	short	frame;
-	long	value;
-	Sym*	link;
-};
-struct	Autom
-{
-	Sym*	sym;
-	Auto*	link;
-	long	offset;
-	short	type;
-};
-struct	Optab
-{
-	uchar	as;
-	char	a1;
-	char	a2;
-	char	a3;
-	char	type;
-	char	size;
-	char	param;
-};
-struct	Oprang
-{
-	Optab*	start;
-	Optab*	stop;
-};
-struct	Count
-{
-	long	count;
-	long	outof;
-};
-
-enum
-{
-	STEXT		= 1,
-	SDATA,
-	SBSS,
-	SDATA1,
-	SXREF,
-	SLEAF,
-	SFILE,
-	SCONST,
-
-	C_NONE		= 0,
-	C_REG,
-	C_FREG,
-	C_FCREG,
-	C_PREG,
-	C_PCC,
-	C_ZCON,
-	C_BCON,
-	C_NCON,
-	C_SCON,
-	C_UCON,
-	C_LCON,
-	C_QCON,
-	C_SACON,
-	C_SECON,
-	C_LACON,
-	C_LECON,
-	C_SBRA,
-	C_LBRA,
-	C_SAUTO,
-	C_SEXT,
-	C_LAUTO,
-	C_LEXT,
-	C_ZOREG,
-	C_SOREG,
-	C_LOREG,
-	C_GOK,
-
-	NSCHED		= 20,
-
-/* mark flags */
-	FOLL		= 1<<0,
-	LABEL		= 1<<1,
-	LEAF		= 1<<2,
-	SYNC		= 1<<3,
-	BRANCH		= 1<<4,
-	LABEL2		= 1<<5,
-	COMPARE		= 1<<6,
-	NOSCHED		= 1<<7,
-
-	BIG		= 32760,
-	STRINGSZ	= 200,
-	NHASH		= 10007,
-	NHUNK		= 100000,
-	MINSIZ		= 64,
-	NENT		= 100,
-	MAXIO		= 8192,
-	MAXHIST		= 20,				/* limit of path elements for history symbols */
-};
-
-union
-{
-	struct
-	{
-		uchar	cbuf[MAXIO];			/* output buffer */
-		uchar	xbuf[MAXIO];			/* input buffer */
-	};
-	char	dbuf[1];
-} buf;
-
-long	HEADR;			/* length of header */
-int	HEADTYPE;		/* type of header */
-long	INITDAT;		/* data location */
-long	INITRND;		/* data round above text location */
-long	INITTEXT;		/* text location */
-char*	INITENTRY;		/* entry point */
-long	autosize;
-Biobuf	bso;
-long	bsssize;
-int	cbc;
-uchar*	cbp;
-int	cout;
-Auto*	curauto;
-Auto*	curhist;
-Prog*	curp;
-Prog*	curtext;
-Prog*	datap;
-long	datsize;
-char	debug[128];
-Prog*	etextp;
-Prog*	firstp;
-char	fnuxi8[8];
-char*	noname;
-Sym*	hash[NHASH];
-Sym*	histfrog[MAXHIST];
-int	histfrogp;
-int	histgen;
-char*	library[50];
-char*	libraryobj[50];
-int	libraryp;
-int	xrefresolv;
-char*	hunk;
-char	inuxi1[1];
-char	inuxi2[2];
-char	inuxi4[4];
-Prog*	lastp;
-long	lcsize;
-char	literal[32];
-int	nerrors;
-long	nhunk;
-vlong	offset;
-Opcross	opcross[7];
-Oprang	oprange[ALAST];
-char*	outfile;
-long	pc;
-Prog	*prog_divq;
-Prog	*prog_divqu;
-Prog	*prog_modq;
-Prog	*prog_modqu;
-Prog	*prog_divl;
-Prog	*prog_divlu;
-Prog	*prog_modl;
-Prog	*prog_modlu;
-uchar	repop[ALAST];
-long	symsize;
-Prog*	textp;
-long	textsize;
-long	thunk;
-int	version;
-char	xcmp[32][32];
-Prog	zprg;
-int	dtype;
-
-extern	char*	anames[];
-extern	Optab	optab[];
-
-#pragma	varargck	type	"A"	int
-#pragma	varargck	type	"A"	uint
-#pragma	varargck	type	"D"	Adr*
-#pragma	varargck	type	"N"	Adr*
-#pragma	varargck	type	"P"	Prog*
-#pragma	varargck	type	"S"	char*
-
-#pragma	varargck	argpos	diag 1
-
-int	Aconv(Fmt*);
-int	Dconv(Fmt*);
-int	Nconv(Fmt*);
-int	Pconv(Fmt*);
-int	Sconv(Fmt*);
-int	aclass(Adr*);
-void	addhist(long, int);
-void	addnop(Prog*);
-void	append(Prog*, Prog*);
-void	asmb(void);
-void	asmlc(void);
-int	asmout(Prog*, Optab*);
-void	asmsym(void);
-long	atolwhex(char*);
-Prog*	brloop(Prog*);
-Biobuf	bso;
-void	buildop(void);
-void	buildrep(int, int);
-void	cflush(void);
-int	cmp(int, int);
-int	compound(Prog*);
-int	conflict(long, long);
-double	cputime(void);
-void	datblk(long, long);
-int	depend(long, long);
-void	diag(char*, ...);
-Prog *divsubr(int);
-void	dodata(void);
-void	doprof1(void);
-void	doprof2(void);
-long	entryvalue(void);
-void	errorexit(void);
-void	exchange(Prog*);
-int	find1(long, int);
-void	follow(void);
-Prog *genXXX(Prog *, int, Adr*, int, Adr*);
-Prog *genRRR(Prog *, int, int, int, int);
-Prog *genIRR(Prog *, int, vlong, int, int);
-Prog *genstore(Prog *, int, int, vlong, int);
-Prog *genload(Prog *, int, vlong, int, int);
-Prog *genjmp(Prog *, int, vlong, int);
-void	gethunk(void);
-void	histtoauto(void);
-double	ieeedtod(Ieee*);
-long	ieeedtof(Ieee*);
-void	initdiv(void);
-void	ldobj(int, long, char*);
-void	loadlib(void);
-void	listinit(void);
-Sym*	lookup(char*, int);
-void	lput(long);
-void	lputbe(long);
-void	mkfwd(void);
-void*	mysbrk(ulong);
-void	names(void);
-void	nocache(Prog*);
-void	noops(void);
-void	nuxiinit(void);
-void	objfile(char*);
-int	ocmp(void*, void*);
-long	opcode(int);
-Optab*	oplook(Prog*);
-void	patch(void);
-void	prasm(Prog*);
-void	prepend(Prog*, Prog*);
-Prog*	prg(void);
-int	pseudo(Prog*);
-void	putsymb(char*, int, long, int);
-vlong	regoff(Adr*);
-long	regused(Prog*);
-int	relinv(int);
-long	rnd(long, long);
-void	sched(Prog*, Prog*);
-void	span(void);
-void	vlput(vlong);
-void	undef(void);
-void	xdefine(char*, int, long);
-void	xfol(Prog*);
diff --git a/sys/src/cmd/7l/list.c b/sys/src/cmd/7l/list.c
deleted file mode 100644
index c2dc9da3f..000000000
--- a/sys/src/cmd/7l/list.c
+++ /dev/null
@@ -1,246 +0,0 @@
-#include "l.h"
-
-void
-listinit(void)
-{
-
-	fmtinstall('A', Aconv);
-	fmtinstall('D', Dconv);
-	fmtinstall('P', Pconv);
-	fmtinstall('S', Sconv);
-	fmtinstall('N', Nconv);
-}
-
-void
-prasm(Prog *p)
-{
-	print("%P\n", p);
-}
-
-int
-Pconv(Fmt *fp)
-{
-	char str[STRINGSZ];
-	Prog *p;
-	int a;
-
-	p = va_arg(fp->args, Prog*);
-	curp = p;
-	a = p->as;
-	if(a == ADATA)
-		snprint(str, sizeof str, "(%ld)	%A	%D/%d,%D",
-			p->line, a, &p->from, p->reg, &p->to);
-	else
-	if(p->reg == NREG)
-		snprint(str, sizeof str, "(%ld)	%A	%D,%D",
-			p->line, a, &p->from, &p->to);
-	else
-	if(p->from.type != D_FREG)
-		snprint(str, sizeof str, "(%ld)	%A	%D,R%d,%D",
-			p->line, a, &p->from, p->reg, &p->to);
-	else
-		snprint(str, sizeof str, "(%ld)	%A	%D,F%d,%D",
-			p->line, a, &p->from, p->reg, &p->to);
-	return fmtstrcpy(fp, str);
-}
-
-int
-Aconv(Fmt *fp)
-{
-	char *s;
-	int a;
-
-	a = va_arg(fp->args, int);
-	s = "???";
-	if(a >= AXXX && a <= AEND)
-		s = anames[a];
-	return fmtstrcpy(fp, s);
-}
-
-int
-Dconv(Fmt *fp)
-{
-	char str[STRINGSZ];
-	Adr *a;
-	long v;
-
-	a = va_arg(fp->args, Adr*);
-	switch(a->type) {
-
-	default:
-		snprint(str, sizeof str, "GOK-type(%d)", a->type);
-		break;
-
-	case D_NONE:
-		str[0] = 0;
-		if(a->name != D_NONE || a->reg != NREG || a->sym != S)
-			snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
-		break;
-
-	case D_CONST:
-		snprint(str, sizeof str, "$%N", a);
-		if(a->reg != NREG)
-			snprint(str, sizeof str, "%N(R%d)(CONST)", a, a->reg);
-		break;
-
-	case D_OREG:
-		if(a->reg != NREG)
-			snprint(str, sizeof str, "%N(R%d)", a, a->reg);
-		else
-			snprint(str, sizeof str, "%N", a);
-		break;
-
-	case D_REG:
-		snprint(str, sizeof str, "R%d", a->reg);
-		if(a->name != D_NONE || a->sym != S)
-			snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
-		break;
-
-	case D_PREG:
-		snprint(str, sizeof str, "P%d", a->reg & 255);
-		if(a->name != D_NONE || a->sym != S)
-			snprint(str, sizeof str, "%N(R%d)(PREG)", a, a->reg);
-		break;
-
-	case D_FREG:
-		snprint(str, sizeof str, "F%d", a->reg);
-		if(a->name != D_NONE || a->sym != S)
-			snprint(str, sizeof str, "%N(R%d)(FREG)", a, a->reg);
-		break;
-
-	case D_FCREG:
-		snprint(str, sizeof str, "FPCR");
-		if(a->name != D_NONE || a->sym != S)
-			snprint(str, sizeof str, "%N(R%d)(FCREG)", a, a->reg);
-		break;
-
-	case D_BRANCH:	/* botch */
-		if(curp->cond != P) {
-			v = curp->cond->pc;
-			if(v >= INITTEXT)
-				v -= INITTEXT-HEADR;
-			if(a->sym != S)
-				snprint(str, sizeof str, "%s+%.5lux(BRANCH)", a->sym->name, v);
-			else
-				snprint(str, sizeof str, "%.5lux(BRANCH)", v);
-		} else
-			if(a->sym != S)
-				snprint(str, sizeof str, "%s+%lld(APC)", a->sym->name, a->offset);
-			else
-				snprint(str, sizeof str, "%lld(APC)", a->offset);
-		break;
-
-	case D_FCONST:
-		snprint(str, sizeof str, "$%e", ieeedtod(a->ieee));
-		break;
-
-	case D_SCONST:
-		snprint(str, sizeof str, "$\"%S\"", a->sval);
-		break;
-	}
-	return fmtstrcpy(fp, str);
-}
-
-int
-Nconv(Fmt *fp)
-{
-	char str[STRINGSZ];
-	Adr *a;
-	Sym *s;
-
-	a = va_arg(fp->args, Adr*);
-	s = a->sym;
-	if(s == S) {
-		snprint(str, sizeof str, "%lld", a->offset);
-		goto out;
-	}
-	switch(a->name) {
-	default:
-		snprint(str, sizeof str, "GOK-name(%d)", a->name);
-		break;
-
-	case D_NONE:
-		snprint(str, sizeof str, "%lld", a->offset);
-		break;
-
-	case D_EXTERN:
-		snprint(str, sizeof str, "%s+%lld(SB)", s->name, a->offset);
-		break;
-
-	case D_STATIC:
-		snprint(str, sizeof str, "%s<>+%lld(SB)", s->name, a->offset);
-		break;
-
-	case D_AUTO:
-		snprint(str, sizeof str, "%s-%lld(SP)", s->name, -a->offset);
-		break;
-
-	case D_PARAM:
-		snprint(str, sizeof str, "%s+%lld(FP)", s->name, a->offset);
-		break;
-	}
-out:
-	return fmtstrcpy(fp, str);
-}
-
-int
-Sconv(Fmt *fp)
-{
-	int i, c;
-	char str[STRINGSZ], *p, *a;
-
-	a = va_arg(fp->args, char*);
-	p = str;
-	for(i=0; i<sizeof(long); i++) {
-		c = a[i] & 0xff;
-		if(c >= 'a' && c <= 'z' ||
-		   c >= 'A' && c <= 'Z' ||
-		   c >= '0' && c <= '9' ||
-		   c == ' ' || c == '%') {
-			*p++ = c;
-			continue;
-		}
-		*p++ = '\\';
-		switch(c) {
-		case 0:
-			*p++ = 'z';
-			continue;
-		case '\\':
-		case '"':
-			*p++ = c;
-			continue;
-		case '\n':
-			*p++ = 'n';
-			continue;
-		case '\t':
-			*p++ = 't';
-			continue;
-		}
-		*p++ = (c>>6) + '0';
-		*p++ = ((c>>3) & 7) + '0';
-		*p++ = (c & 7) + '0';
-	}
-	*p = 0;
-	return fmtstrcpy(fp, str);
-}
-
-void
-diag(char *fmt, ...)
-{
-	char buf[STRINGSZ], *tn;
-	va_list arg;
-
-	tn = "??none??";
-	if(curtext != P && curtext->from.sym != S)
-		tn = curtext->from.sym->name;
-	va_start(arg, fmt);
-	vseprint(buf, buf+sizeof(buf), fmt, arg);
-	va_end(arg);
-	print("%s: %s\n", tn, buf);
-
-	nerrors++;
-	if(nerrors > 10) {
-		print("too many errors\n");
-		errorexit();
-	}
-}
diff --git a/sys/src/cmd/7l/mkfile b/sys/src/cmd/7l/mkfile
deleted file mode 100644
index a8e6d210c..000000000
--- a/sys/src/cmd/7l/mkfile
+++ /dev/null
@@ -1,33 +0,0 @@
-</$objtype/mkfile
-
-TARG=7l
-OFILES=\
-	asm.$O\
-	list.$O\
-	noop.$O\
-	obj.$O\
-	optab.$O\
-	pass.$O\
-	sched.$O\
-	span.$O\
-	enam.$O\
-	compat.$O\
-
-HFILES=\
-	l.h\
-	../7c/7.out.h\
-
-BIN=/$objtype/bin
-</sys/src/cmd/mkone
-
-enam.$O:	../7c/enam.c
-	$CC $CFLAGS ../7c/enam.c
-
-x:V:	$O.out
-	$O.out -la -o/dev/null x.7
-
-test:V:	$O.out
-	rm -f xxx
-	mv $O.out xxx
-	./xxx $OFILES
-	cmp $O.out xxx
diff --git a/sys/src/cmd/7l/noop.c b/sys/src/cmd/7l/noop.c
deleted file mode 100644
index e7f9b655b..000000000
--- a/sys/src/cmd/7l/noop.c
+++ /dev/null
@@ -1,947 +0,0 @@
-#include	"l.h"
-
-Prog	*divuconst(Prog *, uvlong, int, int, int);
-Prog	*divconst(Prog *, vlong, int, int, int);
-Prog	*modconst(Prog *, vlong, int, int, int);
-void	excise(Prog *);
-
-void
-noops(void)
-{
-	Prog *p, *p1, *q, *q1, *q2;
-	int o, curframe, curbecome, maxbecome, shift;
-
-	/*
-	 * find leaf subroutines
-	 * become sizes
-	 * frame sizes
-	 * strip NOPs
-	 * expand RET and other macros
-	 * expand BECOME pseudo
-	 * use conditional moves where appropriate
-	 */
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f noops\n", cputime());
-	Bflush(&bso);
-
-	curframe = 0;
-	curbecome = 0;
-	maxbecome = 0;
-	curtext = 0;
-
-	q = P;
-	for(p = firstp; p != P; p = p->link) {
-
-		/* find out how much arg space is used in this TEXT */
-		if(p->to.type == D_OREG && p->to.reg == REGSP)
-			if(p->to.offset > curframe)
-				curframe = p->to.offset;
-
-		switch(p->as) {
-		case ATEXT:
-			if(curtext && curtext->from.sym) {
-				curtext->from.sym->frame = curframe;
-				curtext->from.sym->become = curbecome;
-				if(curbecome > maxbecome)
-					maxbecome = curbecome;
-			}
-			curframe = 0;
-			curbecome = 0;
-
-			p->mark |= LABEL|LEAF|SYNC;
-			if(p->link)
-				p->link->mark |= LABEL;
-			curtext = p;
-			break;
-
-		/* don't mess with what we don't understand */
-		case AWORD:
-		case ACALL_PAL:
-		/* etc. */
-			p->mark |= LABEL;
-			for(q1=p->link; q1 != P; q1 = q1->link) {
-				q1->mark |= LABEL;
-				if(q1->as != AXORNOT)		/* used as NOP in PALcode */
-					break;
-			}
-			break;
-
-		case ARET:
-			/* special form of RET is BECOME */
-			if(p->from.type == D_CONST)
-				if(p->from.offset > curbecome)
-					curbecome = p->from.offset;
-
-			if(p->link != P)
-				p->link->mark |= LABEL;
-			break;
-
-		case ANOP:
-			q1 = p->link;
-			q->link = q1;		/* q is non-nop */
-			q1->mark |= p->mark;
-			continue;
-
-		case AJSR:
-			if(curtext != P)
-				curtext->mark &= ~LEAF;
-		case ABEQ:
-		case ABNE:
-		case ABGE:
-		case ABGT:
-		case ABLE:
-		case ABLT:
-		case ABLBC:
-		case ABLBS:
-		case AFBEQ:
-		case AFBNE:
-		case AFBGE:
-		case AFBGT:
-		case AFBLE:
-		case AFBLT:
-		case AJMP:
-			p->mark |= BRANCH;
-			q1 = p->cond;
-			if(q1 != P) {
-				while(q1->as == ANOP) {
-					q1 = q1->link;
-					p->cond = q1;
-				}
-				if(!(q1->mark & LEAF)) {
-					if (q1->mark & LABEL)
-						q1->mark |= LABEL2;
-					else
-						q1->mark |= LABEL;
-				}
-			} else
-				p->mark |= LABEL;
-			q1 = p->link;
-			if(q1 != P) {
-				if (q1->mark & LABEL)
-					q1->mark |= LABEL2;
-				else
-					q1->mark |= LABEL;
-			}
-			else
-				p->mark |= LABEL;	/* ??? */
-			break;
-
-		case ADIVQ:
-		case ADIVQU:
-		case AMODQ:
-		case AMODQU:
-		case ADIVL:
-		case ADIVLU:
-		case AMODL:
-		case AMODLU:
-			if(p->from.type == D_CONST /*&& !debug['d']*/)
-				continue;
-			if(prog_divq == P)
-				initdiv();
-			if(curtext != P)
-				curtext->mark &= ~LEAF;
-			break;
-		}
-		q = p;
-	}
-
-	if(curtext && curtext->from.sym) {
-		curtext->from.sym->frame = curframe;
-		curtext->from.sym->become = curbecome;
-		if(curbecome > maxbecome)
-			maxbecome = curbecome;
-	}
-
-	if(debug['b'])
-		print("max become = %d\n", maxbecome);
-	xdefine("ALEFbecome", STEXT, maxbecome);
-
-	curtext = 0;
-	for(p = firstp; p != P; p = p->link) {
-		switch(p->as) {
-		case ATEXT:
-			curtext = p;
-			break;
-		case AJSR:
-			if(curtext != P && curtext->from.sym != S && curtext->to.offset >= 0) {
-				o = maxbecome - curtext->from.sym->frame;
-				if(o <= 0)
-					break;
-				/* calling a become or calling a variable */
-				if(p->to.sym == S || p->to.sym->become) {
-					curtext->to.offset += o;
-					if(debug['b']) {
-						curp = p;
-						print("%D calling %D increase %d\n",
-							&curtext->from, &p->to, o);
-					}
-				}
-			}
-			break;
-		}
-	}
-
-	for(p = firstp; p != P; p = p->link) {
-		o = p->as;
-		switch(o) {
-		case ATEXT:
-			curtext = p;
-			autosize = p->to.offset + 8;
-			if(autosize <= 8)
-			if(curtext->mark & LEAF) {
-				p->to.offset = -8;
-				autosize = 0;
-			}
-			if (autosize & 4)
-				autosize += 4;
-
-			q = p;
-			if(autosize)
-				q = genIRR(p, ASUBQ, autosize, NREG, REGSP);
-			else if(!(curtext->mark & LEAF)) {
-				if(debug['v'])
-					Bprint(&bso, "save suppressed in: %s\n",
-						curtext->from.sym->name);
-				Bflush(&bso);
-				curtext->mark |= LEAF;
-			}
-
-			if(curtext->mark & LEAF) {
-				if(curtext->from.sym)
-					curtext->from.sym->type = SLEAF;
-				break;
-			}
-
-			genstore(q, AMOVL, REGLINK, 0LL, REGSP);
-			break;
-
-		case ARET:
-			nocache(p);
-			if(p->from.type == D_CONST)
-				goto become;
-			if(curtext->mark & LEAF) {
-				if(!autosize) {
-					p->as = AJMP;
-					p->from = zprg.from;
-					p->to.type = D_OREG;
-					p->to.offset = 0;
-					p->to.reg = REGLINK;
-					break;
-				}
-
-				p->as = AADDQ;
-				p->from.type = D_CONST;
-				p->from.offset = autosize;
-				p->to.type = D_REG;
-				p->to.reg = REGSP;
-
-				q = prg();
-				q->as = AJMP;
-				q->line = p->line;
-				q->to.type = D_OREG;
-				q->to.offset = 0;
-				q->to.reg = REGLINK;
-				q->mark |= BRANCH;
-
-				q->link = p->link;
-				p->link = q;
-				break;
-			}
-			p->as = AMOVL;
-			p->from.type = D_OREG;
-			p->from.offset = 0;
-			p->from.reg = REGSP;
-			p->to.type = D_REG;
-			p->to.reg = REGLINK;
-
-			q = p;
-			if(autosize)
-				q = genIRR(p, AADDQ, autosize, NREG, REGSP);
-
-			q1 = prg();
-			q1->as = AJMP;
-			q1->line = p->line;
-			q1->to.type = D_OREG;
-			q1->to.offset = 0;
-			q1->to.reg = REGLINK;
-			q1->mark |= BRANCH;
-
-			q1->link = q->link;
-			q->link = q1;
-			break;
-
-		become:
-			if(curtext->mark & LEAF) {
-
-				q = prg();
-				q->line = p->line;
-				q->as = AJMP;
-				q->from = zprg.from;
-				q->to = p->to;
-				q->cond = p->cond;
-				q->link = p->link;
-				q->mark |= BRANCH;
-				p->link = q;
-
-				p->as = AADDQ;
-				p->from = zprg.from;
-				p->from.type = D_CONST;
-				p->from.offset = autosize;
-				p->to = zprg.to;
-				p->to.type = D_REG;
-				p->to.reg = REGSP;
-
-				break;
-			}
-			q = prg();
-			q->line = p->line;
-			q->as = AJMP;
-			q->from = zprg.from;
-			q->to = p->to;
-			q->cond = p->cond;
-			q->link = p->link;
-			q->mark |= BRANCH;
-			p->link = q;
-
-			q = genIRR(p, AADDQ, autosize, NREG, REGSP);
-
-			p->as = AMOVL;
-			p->from = zprg.from;
-			p->from.type = D_OREG;
-			p->from.offset = 0;
-			p->from.reg = REGSP;
-			p->to = zprg.to;
-			p->to.type = D_REG;
-			p->to.reg = REGLINK;
-
-			break;
-			
-
-		/* All I wanted was a MOVB... */
-		case AMOVB:
-		case AMOVW:
-			/* rewrite sign extend; could use v3 extension in asmout case 1 */
-			if (p->to.type == D_REG) {
-				nocache(p);
-				shift = (p->as == AMOVB) ? (64-8) : (64-16);
-				if (p->from.type == D_REG) {
-					p->as = ASLLQ;
-					p->reg = p->from.reg;
-					p->from.type = D_CONST;
-					p->from.offset = shift;
-					q = genIRR(p, ASRAQ, shift, p->to.reg, p->to.reg);
-					break;
-				}
-				else {
-					p->as = (p->as == AMOVB) ? AMOVBU : AMOVWU;
-					q = genIRR(p, ASLLQ, shift, p->to.reg, p->to.reg);
-					q = genIRR(q, ASRAQ, shift, p->to.reg, p->to.reg);
-				}
-			}
-			/* fall through... */
-		case AMOVBU:
-		case AMOVWU:
-			if(!debug['x'])
-				break;		/* use BWX extension */
-			o = p->as;
-			nocache(p);
-			if (p->from.type == D_OREG) {
-				if (p->to.type != D_REG)
-					break;
-				p->as = AMOVQU;
-				q = genXXX(p, AEXTBL, &p->to, REGTMP2, &p->to);
-				if (o == AMOVW || o == AMOVWU)
-					q->as = AEXTWL;
-				p->to.reg = REGTMP2;
-				if ((p->from.offset & 7) != 0 || aclass(&p->from) != C_SOREG) {
-					q1 = genXXX(p, AMOVA, &p->from, NREG, &q->to);
-					q1->from.offset &= 7;
-					q->from = q->to;
-				}
-				else
-					q->from.reg = p->from.reg;
-				if (o == AMOVB || o == AMOVW)
-					genXXX(q, o, &q->to, NREG, &q->to);
-			}
-			else if (p->to.type == D_OREG) {
-				if (aclass(&p->from) == C_ZCON) {
-					p->from.type = D_REG;
-					p->from.reg = REGZERO;
-				}
-				else if (p->from.type != D_REG)
-					break;
-				p->as = AMOVQU;
-				q = genRRR(p, AMSKBL, p->to.reg, REGTMP2, REGTMP2);
-				q1 = genRRR(q, AINSBL, p->to.reg, p->from.reg, REGTMP);
-				if (o == AMOVW || o == AMOVWU) {
-					q->as = AMSKWL;
-					q1->as = AINSWL;
-				}
-				q2 = genXXX(q1, AOR, &q->to, REGTMP, &q->to);
-				genXXX(q2, AMOVQU, &q->to, NREG, &p->to);
-				p->from = p->to;
-				p->to = q->to;
-				if ((p->from.offset & 7) != 0 || aclass(&p->from) != C_SOREG) {
-					q->from.reg = REGTMP;
-					q1->from.reg = REGTMP;
-					q = genXXX(p, AMOVA, &p->from, NREG, &q->from);
-					q->from.offset &= 7;
-				}
-			}
-			break;
-
-		case ASLLL:
-			p->as = ASLLQ;
-			p = genXXX(p, AADDL, &p->to, REGZERO, &p->to);
-			break;
-
-		case ASRLL:
-			if (p->to.type != D_REG) {
-				diag("illegal dest type in %P", p);
-				break;
-			}
-			if (p->reg == NREG)
-				p->reg = p->to.reg;
-
-			q = genXXX(p, ASRLQ, &p->from, REGTMP, &p->to);
-
-			p->as = AZAP;
-			p->from.type = D_CONST;
-			p->from.offset = 0xf0;
-			p->to.reg = REGTMP;
-			p = q;
-
-			p = genXXX(p, AADDL, &p->to, REGZERO, &p->to);
-			break;
-
-		case ASRAL:
-			p->as = ASRAQ;
-			break;
-
-		case ADIVQ:
-		case ADIVQU:
-		case AMODQ:
-		case AMODQU:
-		case ADIVL:
-		case ADIVLU:
-		case AMODL:
-		case AMODLU:
-			/* if (debug['d'])
-				print("%P\n", p); */
-			if(p->to.type != D_REG)
-				break;
-			/*if(debug['d'] && p->from.type == D_CONST) {
-				q = genRRR(p, p->as, REGTMP, p->reg, p->to.reg);
-				p->as = AMOVQ;
-				p->reg = NREG;
-				p->to.reg = REGTMP;
-				p = q;
-			}*/
-			if(p->from.type == D_CONST) {
-				if (p->reg == NREG)
-					p->reg = p->to.reg;
-				switch (p->as) {
-				case ADIVQ:
-					q = divconst(p, p->from.offset, p->reg, p->to.reg, 64);
-					break;
-				case ADIVQU:
-					q = divuconst(p, p->from.offset, p->reg, p->to.reg, 64);
-					break;
-				case AMODQ:
-					q = modconst(p, p->from.offset, p->reg, p->to.reg, 64);
-					break;
-				case AMODQU:
-					q = divuconst(p, p->from.offset, p->reg, REGTMP2, 64);
-					q = genIRR(q, AMULQ, p->from.offset, REGTMP2, REGTMP2);
-					q = genRRR(q, ASUBQ, REGTMP2, p->reg, p->to.reg);
-					break;
-				case ADIVL:
-					q = divconst(p, p->from.offset, p->reg, p->to.reg, 32);
-					break;
-				case ADIVLU:
-					q = divuconst(p, p->from.offset, p->reg, p->to.reg, 32);
-					break;
-				case AMODL:
-					q = modconst(p, p->from.offset, p->reg, p->to.reg, 32);
-					break;
-				case AMODLU:
-					q = divuconst(p, p->from.offset, p->reg, REGTMP2, 32);
-					q = genIRR(q, AMULQ, p->from.offset, REGTMP2, REGTMP2);
-					q = genRRR(q, ASUBQ, REGTMP2, p->reg, p->to.reg);
-					break;
-				}
-				excise(p);
-				p = q;
-				break;
-			}
-			if(p->from.type != D_REG){
-				diag("bad instruction %P", p);
-				break;
-			}
-			o = p->as;
-			q = genIRR(p, ASUBQ, 16LL, NREG, REGSP);
-			q = genstore(q, AMOVQ, p->from.reg, 8LL, REGSP);
-			if (o == ADIVL || o == ADIVL || o == AMODL || o == AMODLU)
-				q->as = AMOVL;
-
-			q = genRRR(q, AMOVQ, p->reg, NREG, REGTMP);
-			if (p->reg == NREG)
-				q->from.reg = p->to.reg;
-
-			/* CALL appropriate */
-			q1 = prg();
-			q1->link = q->link;
-			q->link = q1;
-
-			q1->as = AJSR;
-			q1->line = p->line;
-			q1->to.type = D_BRANCH;
-			q1->cond = divsubr(o);
-			q1->mark |= BRANCH;
-			q = q1;
-
-			q = genRRR(q, AMOVQ, REGTMP, NREG, p->to.reg);
-			q = genIRR(q, AADDQ, 16LL, NREG, REGSP);
-			excise(p);
-			p = q;
-			break;
-
-		/* Attempt to replace {cond. branch, mov} with a cmov */
-		/* XXX warning: this is all a bit experimental */
-		case ABEQ:
-		case ABNE:
-		case ABGE:
-		case ABGT:
-		case ABLE:
-		case ABLT:
-		case ABLBC:
-		case ABLBS:
-			q = p->link;
-			if (q == P)
-				break;
-			q1 = q->link;
-			if (q1 != p->cond || q1 == P)
-				break;
-/*print("%P\n", q); /* */
-			if (q->to.type != D_REG)
-				break;
-			if (q->from.type != D_REG && (q->from.type != D_CONST || q->from.name != D_NONE))
-				break;
-			if (q->mark&LABEL2)
-				break;
-/* print("%P\n", q); /* */
-			if (q->as != AMOVQ)		/* XXX can handle more than this! */
-				break;
-			q->as = (p->as^1) + ACMOVEQ-ABEQ;	/* sleazy hack */
-			q->reg = p->from.reg;		/* XXX check CMOVx operand order! */
-			excise(p);		/* XXX p's LABEL? */
-			if (!(q1->mark&LABEL2))
-				q1->mark &= ~LABEL;
-			break;
-		case AFBEQ:
-		case AFBNE:
-		case AFBGE:
-		case AFBGT:
-		case AFBLE:
-		case AFBLT:
-			q = p->link;
-			if (q == P)
-				break;
-			q1 = q->link;
-			if (q1 != p->cond || q1 == P)
-				break;
-			if (q->from.type != D_FREG || q->to.type != D_FREG)
-				break;
-/* print("%P\n", q); /* */
-			if (q->mark&LABEL2)
-				break;
-			if (q->as != AMOVT)		/* XXX can handle more than this! */
-				break;
-			q->as = (p->as^1) + AFCMOVEQ-AFBEQ;	/* sleazy hack */
-			q->reg = p->from.reg;		/* XXX check CMOVx operand order! */
-			excise(p);		/* XXX p's LABEL? */
-			if (!(q1->mark&LABEL2))
-				q1->mark &= ~LABEL;
-			break;
-		}
-	}
-
-	curtext = P;
-	q = P;		/* p - 1 */
-	q1 = firstp;	/* top of block */
-	o = 0;		/* count of instructions */
-	for(p = firstp; p != P; p = p1) {
-		p1 = p->link;
-		o++;
-		if(p->mark & NOSCHED){
-			if(q1 != p){
-				sched(q1, q);
-			}
-			for(; p != P; p = p->link){
-				if(!(p->mark & NOSCHED))
-					break;
-				q = p;
-			}
-			p1 = p;
-			q1 = p;
-			o = 0;
-			continue;
-		}
-		if(p->mark & (LABEL|SYNC)) {
-			if(q1 != p)
-				sched(q1, q);
-			q1 = p;
-			o = 1;
-		}
-		if(p->mark & (BRANCH|SYNC)) {
-			sched(q1, p);
-			q1 = p1;
-			o = 0;
-		}
-		if(o >= NSCHED) {
-			sched(q1, p);
-			q1 = p1;
-			o = 0;
-		}
-		q = p;
-	}
-}
-
-void
-nocache(Prog *p)
-{
-	p->optab = 0;
-	p->from.class = 0;
-	p->to.class = 0;
-}
-
-/* XXX use of this may lose important LABEL flags, check that this isn't happening (or fix) */
-void
-excise(Prog *p)
-{
-	Prog *q;
-
-	q = p->link;
-	*p = *q;
-}
-
-void
-initdiv(void)
-{
-	Sym *s1, *s2, *s3, *s4, *s5, *s6, *s7, *s8;
-	Prog *p;
-
-	s1 = lookup("_divq", 0);
-	s2 = lookup("_divqu", 0);
-	s3 = lookup("_modq", 0);
-	s4 = lookup("_modqu", 0);
-	s5 = lookup("_divl", 0);
-	s6 = lookup("_divlu", 0);
-	s7 = lookup("_modl", 0);
-	s8 = lookup("_modlu", 0);
-	for(p = firstp; p != P; p = p->link)
-		if(p->as == ATEXT) {
-			if(p->from.sym == s1)
-				prog_divq = p;
-			if(p->from.sym == s2)
-				prog_divqu = p;
-			if(p->from.sym == s3)
-				prog_modq = p;
-			if(p->from.sym == s4)
-				prog_modqu = p;
-			if(p->from.sym == s5)
-				prog_divl = p;
-			if(p->from.sym == s6)
-				prog_divlu = p;
-			if(p->from.sym == s7)
-				prog_modl = p;
-			if(p->from.sym == s8)
-				prog_modlu = p;
-		}
-	if(prog_divq == P) {
-		diag("undefined: %s", s1->name);
-		prog_divq = curtext;
-	}
-	if(prog_divqu == P) {
-		diag("undefined: %s", s2->name);
-		prog_divqu = curtext;
-	}
-	if(prog_modq == P) {
-		diag("undefined: %s", s3->name);
-		prog_modq = curtext;
-	}
-	if(prog_modqu == P) {
-		diag("undefined: %s", s4->name);
-		prog_modqu = curtext;
-	}
-	if(prog_divl == P) {
-		diag("undefined: %s", s5->name);
-		prog_divl = curtext;
-	}
-	if(prog_divlu == P) {
-		diag("undefined: %s", s6->name);
-		prog_divlu = curtext;
-	}
-	if(prog_modl == P) {
-		diag("undefined: %s", s7->name);
-		prog_modl = curtext;
-	}
-	if(prog_modlu == P) {
-		diag("undefined: %s", s8->name);
-		prog_modlu = curtext;
-	}
-}
-
-Prog *
-divsubr(int o)
-{
-	switch(o) {
-	case ADIVQ:
-		return prog_divq;
-	case ADIVQU:
-		return prog_divqu;
-	case AMODQ:
-		return prog_modq;
-	case AMODQU:
-		return prog_modqu;
-	case ADIVL:
-		return prog_divl;
-	case ADIVLU:
-		return prog_divlu;
-	case AMODL:
-		return prog_modl;
-	case AMODLU:
-		return prog_modlu;
-	default:
-		diag("bad op %A in divsubr", o);
-		return prog_modlu;
-	}
-}
-
-Prog*
-divuconst(Prog *p, uvlong y, int num, int quot, int bits)
-{
-	int logy, i, shift;
-	uvlong k, m, n, mult, tmp, msb;
-
-	if(num == NREG)
-		num = quot;
-	if(y == 0) {
-		diag("division by zero");
-		return p;
-	}
-	if(y == 1)
-		return genRRR(p, AMOVQ, num, NREG, quot);
-
-	if(num == REGTMP || quot == REGTMP)
-		diag("bad register in divuconst");
-
-	tmp = y;
-	for(logy = -1; tmp != 0; logy++)
-		tmp >>= 1;
-
-	msb = (1LL << (bits-1));
-	if((y & (y-1)) == 0)		/* power of 2 */
-		return genIRR(p, ASRLQ, logy, num, quot);
-	if(y > msb)
-		return genIRR(p, ACMPUGE, y, num, quot);
-
-	/* k = (-2^(bits+logy)) % y */
-	m = msb/y;
-	n = msb%y;
-	if(debug['d'])
-		Bprint(&bso, "divuconst: y=%lld msb=%lld m=%lld n=%lld\n",
-			y, msb, m, n);
-	for(i = 0; i <= logy; i++) {
-		m *= 2LL;
-		n *= 2LL;
-		if(n > y) {
-			m += 1LL;
-			n -= y;
-		}
-	}
-	if(debug['d'])
-		Bprint(&bso, "divuconst: y=%lld msb=%lld m=%lld n=%lld\n",
-			y, msb, m, n);
-	k = y - n;
-	if(k > (1LL << logy)) {
-		mult = 2LL*m + 1LL;
-		bits++;
-	} else
-		mult = m + 1LL;
-
-	shift = bits + logy;
-	if(debug['d'])
-		Bprint(&bso, "divuconst: y=%lld mult=%lld shift=%d bits=%d k=%lld\n",
-			y, mult, shift, bits, k);
-	if(bits <= 32) {
-		p = genIRR(p, AMOVQ, mult, NREG, REGTMP);
-		p = genRRR(p, AEXTLL, REGZERO, num, quot);
-		p = genRRR(p, AMULQ, REGTMP, quot, quot);
-		p = genIRR(p, ASRLQ, shift, quot, quot);
-		p = genRRR(p, AADDL, quot, REGZERO, quot);
-		return p;
-	}
-	if(bits == 33) {
-		if(shift < 64) {
-			mult <<= (64-shift);
-			shift = 64;
-		}
-		p = genIRR(p, AMOVQ, mult, NREG, REGTMP);
-		p = genRRR(p, AEXTLL, REGZERO, num, quot);
-		p = genRRR(p, AUMULH, REGTMP, quot, quot);
-		if(shift != 64)
-			p = genIRR(p, ASRLQ, shift-64, quot, quot);
-		p = genRRR(p, AADDL, quot, REGZERO, quot);
-		return p;
-	}
-	if(bits <= 64) {
-		if(shift < 64) {
-			mult <<= (64-shift);
-			shift = 64;
-		}
-		p = genIRR(p, AMOVQ, mult, NREG, REGTMP);
-		p = genRRR(p, AUMULH, REGTMP, num, quot);
-		if(shift != 64)
-			p = genIRR(p, ASRLQ, shift-64, quot, quot);
-		return p;
-	}
-
-	p = genIRR(p, AMOVQ, mult, NREG, REGTMP);
-	p = genRRR(p, AUMULH, REGTMP, num, REGTMP);
-	p = genRRR(p, AADDQ, num, REGTMP, quot);
-	p = genRRR(p, ACMPUGT, REGTMP, quot, REGTMP);
-	p = genIRR(p, ASLLQ, 128-shift, REGTMP, REGTMP);
-	p = genIRR(p, ASRLQ, shift-64, quot, quot);
-	p = genRRR(p, AADDQ, REGTMP, quot, quot);
-	return p;
-}
-
-Prog *
-divconst(Prog *p, vlong y, int num, int quot, int bits)
-{
-	vlong yabs;
-	Prog *q;
-
-	yabs = y;
-	if (y < 0)
-		yabs = -y;
-	q = genRRR(p, ASUBQ, num, REGZERO, REGTMP2);
-	if (num != quot)
-		q = genRRR(q, AMOVQ, num, NREG, quot);
-	q = genRRR(q, ACMOVGT, REGTMP2, REGTMP2, quot);
-	q = divuconst(q, yabs, quot, quot, bits-1);
-	q = genRRR(q, ASUBQ, quot, REGZERO, REGTMP);
-	q = genRRR(q, (y < 0)? ACMOVLT: ACMOVGT, REGTMP, REGTMP2, quot);
-	return q;
-}
-
-Prog *
-modconst(Prog *p, vlong y, int num, int quot, int bits)
-{
-	vlong yabs;
-	Prog *q;
-
-	yabs = y;
-	if (y < 0)
-		yabs = -y;
-	q = genRRR(p, ASUBQ, num, REGZERO, REGTMP2);
-	q = genRRR(q, ACMOVLT, num, REGTMP2, REGTMP2);
-	q = divuconst(q, yabs, REGTMP2, REGTMP2, bits-1);
-	q = genRRR(q, ASUBQ, REGTMP2, REGZERO, REGTMP);
-	q = genRRR(q, ACMOVLT, REGTMP, num, REGTMP2);
-	q = genIRR(q, AMULQ, yabs, REGTMP2, REGTMP2);
-	q = genRRR(q, ASUBQ, REGTMP2, num, quot);
-	return q;
-}
-
-Prog *
-genXXX(Prog *q, int op, Adr *from, int reg, Adr *to)
-{
-	Prog *p;
-
-	p = prg();
-	p->as = op;
-	p->line = q->line;
-	p->from = *from;
-	p->to = *to;
-	p->reg = reg;
-	p->link = q->link;
-	q->link = p;
-	return p;
-}
-
-Prog *
-genRRR(Prog *q, int op, int from, int reg, int to)
-{
-	Prog *p;
-
-	p = prg();
-	p->as = op;
-	p->line = q->line;
-	p->from.type = D_REG;
-	p->from.reg = from;
-	p->to.type = D_REG;
-	p->to.reg = to;
-	p->reg = reg;
-	p->link = q->link;
-	q->link = p;
-	return p;
-}
-
-Prog *
-genIRR(Prog *q, int op, vlong v, int reg, int to)
-{
-	Prog *p;
-
-	p = prg();
-	p->as = op;
-	p->line = q->line;
-	p->from.type = D_CONST;
-	p->from.offset = v;
-	p->to.type = D_REG;
-	p->to.reg = to;
-	p->reg = reg;
-	p->link = q->link;
-	q->link = p;
-	return p;
-}
-
-Prog *
-genstore(Prog *q, int op, int from, vlong offset, int to)
-{
-	Prog *p;
-
-	p = prg();
-	p->as = op;
-	p->line = q->line;
-	p->from.type = D_REG;
-	p->from.reg = from;
-	p->to.type = D_OREG;
-	p->to.reg = to;
-	p->to.offset = offset;
-	p->reg = NREG;
-	p->link = q->link;
-	q->link = p;
-	return p;
-}
-
-Prog *
-genload(Prog *q, int op, vlong offset, int from, int to)
-{
-	Prog *p;
-
-	p = prg();
-	p->as = op;
-	p->line = q->line;
-	p->from.type = D_OREG;
-	p->from.offset = offset;
-	p->from.reg = from;
-	p->to.type = D_REG;
-	p->to.reg = to;
-	p->reg = NREG;
-	p->link = q->link;
-	q->link = p;
-	return p;
-}
diff --git a/sys/src/cmd/7l/obj.c b/sys/src/cmd/7l/obj.c
deleted file mode 100644
index 793e5825e..000000000
--- a/sys/src/cmd/7l/obj.c
+++ /dev/null
@@ -1,1350 +0,0 @@
-#include	"l.h"
-#include	<ar.h>
-
-#ifndef	DEFAULT
-#define	DEFAULT	'9'
-#endif
-
-char	*noname		= "<none>";
-char	symname[]	= SYMDEF;
-char	thechar		= '7';
-char	*thestring 	= "alpha";
-
-/*
- *	-H0 -T0x12000004C -D0x140000000	is abbrev unix
- *	-H1 -T0x20000000 -R4		is bootp() format
- *	-H2 -T8224 -R8192		is plan9 format
- */
-
-void
-main(int argc, char *argv[])
-{
-	int c;
-	char *a;
-
-	Binit(&bso, 1, OWRITE);
-	cout = -1;
-	listinit();
-	outfile = 0;
-	nerrors = 0;
-	curtext = P;
-	HEADTYPE = -1;
-	INITTEXT = -1;
-	INITDAT = -1;
-	INITRND = -1;
-	INITENTRY = 0;
-
-	ARGBEGIN {
-	default:
-		c = ARGC();
-		if(c >= 0 && c < sizeof(debug))
-			debug[c]++;
-		break;
-	case 'o':
-		outfile = ARGF();
-		break;
-	case 'E':
-		a = ARGF();
-		if(a)
-			INITENTRY = a;
-		break;
-	case 'T':
-		a = ARGF();
-		if(a)
-			INITTEXT = atolwhex(a);
-		break;
-	case 'D':
-		a = ARGF();
-		if(a)
-			INITDAT = atolwhex(a);
-		break;
-	case 'R':
-		a = ARGF();
-		if(a)
-			INITRND = atolwhex(a);
-		break;
-	case 'H':
-		a = ARGF();
-		if(a)
-			HEADTYPE = atolwhex(a);
-		/* do something about setting INITTEXT */
-		break;
-	} ARGEND
-
-	USED(argc);
-
-	if(*argv == 0) {
-		diag("usage: 7l [-options] objects");
-		errorexit();
-	}
-	if(!debug['9'] && !debug['B'] && !debug['U'])
-		debug[DEFAULT] = 1;
-	if(HEADTYPE == -1) {
-		if(debug['U'])
-			HEADTYPE = 0;
-		if(debug['B'])
-			HEADTYPE = 1;
-		if(debug['9'])
-			HEADTYPE = 2;
-	}
-	switch(HEADTYPE) {
-	default:
-		diag("unknown -H option");
-		errorexit();
-
-	case 0:	/* unix simple */
-		HEADR = 32L+80L;
-		if(INITTEXT == -1)
-			INITTEXT = 0x120000070LL;		/* BUG */
-		if(INITDAT == -1)
-			INITDAT = 0x140000000LL;		/* BUG */
-		if(INITRND == -1)
-			INITRND = 0;
-		break;
-
-	case 1:	/* boot */
-		HEADR = 32L+84L;
-		if(INITTEXT == -1)
-			INITTEXT = 0x20000074L;
-		if(INITDAT == -1)
-			INITDAT = 0;
-		if(INITRND == -1)
-			INITRND = 8;
-		break;
-	case 2:	/* plan 9 */
-		HEADR = 32L;
-		if(INITTEXT == -1)
-			INITTEXT = 8224;
-		if(INITDAT == -1)
-			INITDAT = 0;
-		if(INITRND == -1)
-			INITRND = 8192;
-		break;
-	case 3:	/* ``headerless'' tftp boot -- uses branch as magic */
-		HEADR = 32L;
-		if(INITTEXT == -1)
-			INITTEXT = 0x20000020L;
-		if(INITDAT == -1)
-			INITDAT = 0;
-		if(INITRND == -1)
-			INITRND = 8;
-		break;
-	}
-	if(INITDAT != 0 && INITRND != 0)
-		print("warning: -D0x%lux is ignored because of -R0x%lux\n",
-			INITDAT, INITRND);
-	if(debug['v'])
-		Bprint(&bso, "HEADER = -H0x%d -T0x%lux -D0x%lux -R0x%lux\n",
-			HEADTYPE, INITTEXT, INITDAT, INITRND);
-	Bflush(&bso);
-	zprg.as = AGOK;
-	zprg.reg = NREG;
-	zprg.from.name = D_NONE;
-	zprg.from.type = D_NONE;
-	zprg.from.reg = NREG;
-	zprg.to = zprg.from;
-	buildop();
-	histgen = 0;
-	textp = P;
-	datap = P;
-	pc = 0;
-	dtype = 4;
-	if(outfile == 0)
-		outfile = "7.out";
-	cout = create(outfile, 1, 0775);
-	if(cout < 0) {
-		diag("%s: cannot create", outfile);
-		errorexit();
-	}
-	nuxiinit();
-
-	version = 0;
-	cbp = buf.cbuf;
-	cbc = sizeof(buf.cbuf);
-	firstp = prg();
-	lastp = firstp;
-
-	if(INITENTRY == 0) {
-		INITENTRY = "_main";
-		if(debug['p'])
-			INITENTRY = "_mainp";
-		if(!debug['l'])
-			lookup(INITENTRY, 0)->type = SXREF;
-	} else
-		lookup(INITENTRY, 0)->type = SXREF;
-
-	while(*argv)
-		objfile(*argv++);
-	if(!debug['l'])
-		loadlib();
-	firstp = firstp->link;
-	if(firstp == P)
-		goto out;
-	patch();
-	if(debug['p'])
-		if(debug['1'])
-			doprof1();
-		else
-			doprof2();
-	follow();
-	if(firstp == P)
-		goto out;
-	noops();
-	dodata();		/* is before follow() on other arch */
-	span();
-	asmb();
-	undef();
-
-out:
-	if(debug['v']) {
-		Bprint(&bso, "%5.2f cpu time\n", cputime());
-		Bprint(&bso, "%ld memory used\n", thunk);
-		Bprint(&bso, "%d sizeof adr\n", sizeof(Adr));
-		Bprint(&bso, "%d sizeof prog\n", sizeof(Prog));
-	}
-	Bflush(&bso);
-	errorexit();
-}
-
-void
-loadlib(void)
-{
-	int i;
-	long h;
-	Sym *s;
-
-loop:
-	xrefresolv = 0;
-	for(i=0; i<libraryp; i++) {
-		if(debug['v'])
-			Bprint(&bso, "%5.2f autolib: %s\n", cputime(), library[i]);
-		objfile(library[i]);
-	}
-	if(xrefresolv)
-	for(h=0; h<nelem(hash); h++)
-	for(s = hash[h]; s != S; s = s->link)
-		if(s->type == SXREF)
-			goto loop;
-}
-
-void
-errorexit(void)
-{
-
-	Bflush(&bso);
-	if(nerrors) {
-		if(cout >= 0)
-			remove(outfile);
-		exits("error");
-	}
-	exits(0);
-}
-
-void
-objfile(char *file)
-{
-	long off, esym, cnt, l;
-	int f, work;
-	Sym *s;
-	char magbuf[SARMAG];
-	char name[100], pname[150];
-	struct ar_hdr arhdr;
-	char *e, *start, *stop;
-
-	if(file[0] == '-' && file[1] == 'l') {
-		if(debug['9'])
-			snprint(name, sizeof name, "/%s/lib/lib%s.a", thestring, file+2);
-		else
-			snprint(name, sizeof name, "/usr/%clib/lib%s.a", thechar, file+2);
-		file = name;
-	}
-	if(debug['v'])
-		Bprint(&bso, "%5.2f ldobj: %s\n", cputime(), file);
-	Bflush(&bso);
-	f = open(file, 0);
-	if(f < 0) {
-		diag("cannot open file: %s", file);
-		errorexit();
-	}
-	l = read(f, magbuf, SARMAG);
-	if(l != SARMAG || strncmp(magbuf, ARMAG, SARMAG)){
-		/* load it as a regular file */
-		l = seek(f, 0L, 2);
-		seek(f, 0L, 0);
-		ldobj(f, l, file);
-		close(f);
-		return;
-	}
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f ldlib: %s\n", cputime(), file);
-	l = read(f, &arhdr, SAR_HDR);
-	if(l != SAR_HDR) {
-		diag("%s: short read on archive file symbol header", file);
-		goto out;
-	}
-	if(strncmp(arhdr.name, symname, strlen(symname))) {
-		diag("%s: first entry not symbol header", file);
-		goto out;
-	}
-
-	esym = SARMAG + SAR_HDR + atolwhex(arhdr.size);
-	off = SARMAG + SAR_HDR;
-
-	/*
-	 * just bang the whole symbol file into memory
-	 */
-	seek(f, off, 0);
-	cnt = esym - off;
-	start = malloc(cnt + 10);
-	cnt = read(f, start, cnt);
-	if(cnt <= 0){
-		close(f);
-		return;
-	}
-	stop = &start[cnt];
-	memset(stop, 0, 10);
-
-	work = 1;
-	while(work){
-		if(debug['v'])
-			Bprint(&bso, "%5.2f library pass: %s\n", cputime(), file);
-		Bflush(&bso);
-		work = 0;
-		for(e = start; e < stop; e = strchr(e+5, 0) + 1) {
-			s = lookup(e+5, 0);
-			if(s->type != SXREF)
-				continue;
-			snprint(pname, sizeof pname, "%s(%s)", file, s->name);
-			if(debug['v'])
-				Bprint(&bso, "%5.2f library: %s\n", cputime(), pname);
-			Bflush(&bso);
-			l = e[1] & 0xff;
-			l |= (e[2] & 0xff) << 8;
-			l |= (e[3] & 0xff) << 16;
-			l |= (e[4] & 0xff) << 24;
-			seek(f, l, 0);
-			l = read(f, &arhdr, SAR_HDR);
-			if(l != SAR_HDR)
-				goto bad;
-			if(strncmp(arhdr.fmag, ARFMAG, sizeof(arhdr.fmag)))
-				goto bad;
-			l = atolwhex(arhdr.size);
-			ldobj(f, l, pname);
-			if(s->type == SXREF) {
-				diag("%s: failed to load: %s", file, s->name);
-				errorexit();
-			}
-			work = 1;
-			xrefresolv = 1;
-		}
-	}
-	return;
-
-bad:
-	diag("%s: bad or out of date archive", file);
-out:
-	close(f);
-}
-
-int
-zaddr(uchar *p, Adr *a, Sym *h[])
-{
-	int i, c;
-	vlong l;
-	Sym *s;
-	Auto *u;
-
-	c = p[2];
-	if(c < 0 || c > NSYM){
-		print("sym out of range: %d\n", c);
-		p[0] = ALAST+1;
-		return 0;
-	}
-	a->type = p[0];
-	a->reg = p[1];
-	a->sym = h[p[2]];
-	a->name = p[3];
-	c = 4;
-
-	if(a->reg < 0 || a->reg > NREG) {
-		print("register out of range %d\n", a->reg);
-		p[0] = ALAST+1;
-		return 0;	/*  force real diagnostic */
-	}
-
-	switch(a->type) {
-	default:
-		print("unknown type %d\n", a->type);
-		p[0] = ALAST+1;
-		return 0;	/*  force real diagnostic */
-
-	case D_NONE:
-	case D_REG:
-	case D_FREG:
-	case D_PREG:
-	case D_FCREG:
-	case D_PCC:
-		break;
-
-	case D_BRANCH:
-	case D_OREG:
-	case D_CONST:
-		a->offset = (uvlong)p[4] | ((uvlong)p[5]<<8L) |
-			((uvlong) p[6]<<16L) | ((uvlong) p[7]<<24L) |
-			((uvlong) p[8]<<32L) | ((uvlong) p[9]<<40L) |
-			((uvlong) p[10]<<48L) | ((uvlong) p[11]<<56L);
-		c += 8;
-		break;
-
-	case D_SCONST:
-		while(nhunk < NSNAME)
-			gethunk();
-		a->sval = (char*)hunk;
-		nhunk -= NSNAME;
-		hunk += NSNAME;
-
-		memmove(a->sval, p+4, NSNAME);
-		c += NSNAME;
-		break;
-
-	case D_FCONST:
-		while(nhunk < sizeof(Ieee))
-			gethunk();
-		a->ieee = (Ieee*)hunk;
-		nhunk -= sizeof(Ieee);
-		hunk += sizeof(Ieee);
-
-		a->ieee->l = p[4] | (p[5]<<8) |
-			(p[6]<<16) | (p[7]<<24);
-		a->ieee->h = p[8] | (p[9]<<8) |
-			(p[10]<<16) | (p[11]<<24);
-		c += 8;
-		break;
-	}
-	s = a->sym;
-	if(s == S)
-		return c;
-	i = a->name;
-	if(i != D_AUTO && i != D_PARAM)
-		return c;
-
-	l = a->offset;
-	for(u=curauto; u; u=u->link)
-		if(u->sym == s)
-		if(u->type == i) {
-			if(u->offset > l)
-				u->offset = l;
-			return c;
-		}
-
-	while(nhunk < sizeof(Auto))
-		gethunk();
-	u = (Auto*)hunk;
-	nhunk -= sizeof(Auto);
-	hunk += sizeof(Auto);
-
-	u->link = curauto;
-	curauto = u;
-	u->sym = s;
-	u->offset = l;
-	u->type = i;
-	return c;
-}
-
-void
-addlib(char *obj)
-{
-	char name[1024], comp[256], *p;
-	int i;
-
-	if(histfrogp <= 0)
-		return;
-
-	if(histfrog[0]->name[1] == '/') {
-		name[0] = 0;
-		i = 1;
-	} else
-	if(histfrog[0]->name[1] == '.') {
-		snprint(name, sizeof name, ".");
-		i = 0;
-	} else {
-		if(debug['9'])
-			snprint(name, sizeof name, "/%s/lib", thestring);
-		else
-			snprint(name, sizeof name, "/usr/%clib", thechar);
-		i = 0;
-	}
-
-	for(; i<histfrogp; i++) {
-		snprint(comp, sizeof comp, histfrog[i]->name+1);
-		for(;;) {
-			p = strstr(comp, "$O");
-			if(p == 0)
-				break;
-			memmove(p+1, p+2, strlen(p+2)+1);
-			p[0] = thechar;
-		}
-		for(;;) {
-			p = strstr(comp, "$M");
-			if(p == 0)
-				break;
-			if(strlen(comp)+strlen(thestring)-2+1 >= sizeof comp) {
-				diag("library component too long");
-				return;
-			}
-			memmove(p+strlen(thestring), p+2, strlen(p+2)+1);
-			memmove(p, thestring, strlen(thestring));
-		}
-		if(strlen(name) + strlen(comp) + 3 >= sizeof(name)) {
-			diag("library component too long");
-			return;
-		}
-		strcat(name, "/");
-		strcat(name, comp);
-	}
-	for(i=0; i<libraryp; i++)
-		if(strcmp(name, library[i]) == 0)
-			return;
-	if(libraryp == nelem(library)){
-		diag("too many autolibs; skipping %s", name);
-		return;
-	}
-
-	p = malloc(strlen(name) + 1);
-	strcpy(p, name);
-	library[libraryp] = p;
-	p = malloc(strlen(obj) + 1);
-	strcpy(p, obj);
-	libraryobj[libraryp] = p;
-	libraryp++;
-}
-
-void
-addhist(long line, int type)
-{
-	Auto *u;
-	Sym *s;
-	int i, j, k;
-
-	u = malloc(sizeof(Auto));
-	s = malloc(sizeof(Sym));
-	s->name = malloc(2*(histfrogp+1) + 1);
-
-	u->sym = s;
-	u->type = type;
-	u->offset = line;
-	u->link = curhist;
-	curhist = u;
-
-	j = 1;
-	for(i=0; i<histfrogp; i++) {
-		k = histfrog[i]->value;
-		s->name[j+0] = k>>8;
-		s->name[j+1] = k;
-		j += 2;
-	}
-}
-
-void
-histtoauto(void)
-{
-	Auto *l;
-
-	while(l = curhist) {
-		curhist = l->link;
-		l->link = curauto;
-		curauto = l;
-	}
-}
-
-void
-collapsefrog(Sym *s)
-{
-	int i;
-
-	/*
-	 * bad encoding of path components only allows
-	 * MAXHIST components. if there is an overflow,
-	 * first try to collapse xxx/..
-	 */
-	for(i=1; i<histfrogp; i++)
-		if(strcmp(histfrog[i]->name+1, "..") == 0) {
-			memmove(histfrog+i-1, histfrog+i+1,
-				(histfrogp-i-1)*sizeof(histfrog[0]));
-			histfrogp--;
-			goto out;
-		}
-
-	/*
-	 * next try to collapse .
-	 */
-	for(i=0; i<histfrogp; i++)
-		if(strcmp(histfrog[i]->name+1, ".") == 0) {
-			memmove(histfrog+i, histfrog+i+1,
-				(histfrogp-i-1)*sizeof(histfrog[0]));
-			goto out;
-		}
-
-	/*
-	 * last chance, just truncate from front
-	 */
-	memmove(histfrog+0, histfrog+1,
-		(histfrogp-1)*sizeof(histfrog[0]));
-
-out:
-	histfrog[histfrogp-1] = s;
-}
-
-void
-nopout(Prog *p)
-{
-	p->as = ANOP;
-	p->from.type = D_NONE;
-	p->to.type = D_NONE;
-}
-
-uchar*
-readsome(int f, uchar *buf, uchar *good, uchar *stop, int max)
-{
-	int n;
-
-	n = stop - good;
-	memmove(buf, good, stop - good);
-	stop = buf + n;
-	n = MAXIO - n;
-	if(n > max)
-		n = max;
-	n = read(f, stop, n);
-	if(n <= 0)
-		return 0;
-	return stop + n;
-}
-
-void
-ldobj(int f, long c, char *pn)
-{
-	long ipc;
-	Prog *p, *t;
-	uchar *bloc, *bsize, *stop;
-	Sym *h[NSYM], *s, *di;
-	int v, o, r, skip;
-
-	bsize = buf.xbuf;
-	bloc = buf.xbuf;
-	di = S;
-
-newloop:
-	memset(h, 0, sizeof(h));
-	version++;
-	histfrogp = 0;
-	ipc = pc;
-	skip = 0;
-
-loop:
-	if(c <= 0)
-		goto eof;
-	r = bsize - bloc;
-	if(r < 100 && r < c) {		/* enough for largest prog */
-		bsize = readsome(f, buf.xbuf, bloc, bsize, c);
-		if(bsize == 0)
-			goto eof;
-		bloc = buf.xbuf;
-		goto loop;
-	}
-	o = bloc[0];		/* as */
-	if(o <= AXXX || o >= ALAST) {
-		diag("%s: line %ld: opcode out of range %d", pn, pc-ipc, o);
-		print("	probably not a .7 file\n");
-		errorexit();
-	}
-	if(o == ANAME) {
-		stop = memchr(&bloc[3], 0, bsize-&bloc[3]);
-		if(stop == 0){
-			bsize = readsome(f, buf.xbuf, bloc, bsize, c);
-			if(bsize == 0)
-				goto eof;
-			bloc = buf.xbuf;
-			stop = memchr(&bloc[3], 0, bsize-&bloc[3]);
-			if(stop == 0){
-				fprint(2, "%s: name too long\n", pn);
-				errorexit();
-			}
-		}
-		v = bloc[1];	/* type */
-		o = bloc[2];	/* sym */
-		bloc += 3;
-		c -= 3;
-
-		r = 0;
-		if(v == D_STATIC)
-			r = version;
-		s = lookup((char*)bloc, r);
-		c -= &stop[1] - bloc;
-		bloc = stop + 1;
-
-		if(debug['W'])
-			print("	ANAME	%s\n", s->name);
-		h[o] = s;
-		if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
-			s->type = SXREF;
-		if(v == D_FILE) {
-			if(s->type != SFILE) {
-				histgen++;
-				s->type = SFILE;
-				s->value = histgen;
-			}
-			if(histfrogp < MAXHIST) {
-				histfrog[histfrogp] = s;
-				histfrogp++;
-			} else
-				collapsefrog(s);
-		}
-		goto loop;
-	}
-
-	if(nhunk < sizeof(Prog))
-		gethunk();
-	p = (Prog*)hunk;
-	nhunk -= sizeof(Prog);
-	hunk += sizeof(Prog);
-
-	p->as = o;
-	p->reg = bloc[1] & 0x7f;
-	if(bloc[1] & 0x80)
-		p->mark = NOSCHED;
-	p->line = bloc[2] | (bloc[3]<<8) | (bloc[4]<<16) | (bloc[5]<<24);
-
-	r = zaddr(bloc+6, &p->from, h) + 6;
-	r += zaddr(bloc+r, &p->to, h);
-	bloc += r;
-	c -= r;
-
-	if(p->reg < 0 || p->reg > NREG)
-		diag("register out of range %d", p->reg);
-
-	p->link = P;
-	p->cond = P;
-
-	if(debug['W'])
-		print("%P\n", p);
-
-	switch(o) {
-	case AHISTORY:
-		if(p->to.offset == -1) {
-			addlib(pn);
-			histfrogp = 0;
-			goto loop;
-		}
-		addhist(p->line, D_FILE);		/* 'z' */
-		if(p->to.offset)
-			addhist(p->to.offset, D_PREG);	/* 'Z' */
-		histfrogp = 0;
-		goto loop;
-
-	case AEND:
-		histtoauto();
-		if(curtext != P)
-			curtext->to.autom = curauto;
-		curauto = 0;
-		curtext = P;
-		if(c)
-			goto newloop;
-		return;
-
-	case AGLOBL:
-		s = p->from.sym;
-		if(s == S) {
-			diag("GLOBL must have a name\n%P", p);
-			errorexit();
-		}
-		if(s->type == 0 || s->type == SXREF) {
-			s->type = SBSS;
-			s->value = 0;
-		}
-		if(s->type != SBSS) {
-			diag("redefinition: %s\n%P", s->name, p);
-			s->type = SBSS;
-			s->value = 0;
-		}
-		if(p->to.offset > s->value)
-			s->value = p->to.offset;
-		break;
-
-	case ADYNT:
-		if(p->to.sym == S) {
-			diag("DYNT without a sym\n%P", p);
-			break;
-		}
-		di = p->to.sym;
-		p->reg = 4;
-		if(di->type == SXREF) {
-			if(debug['z'])
-				Bprint(&bso, "%P set to %d\n", p, dtype);
-			di->type = SCONST;
-			di->value = dtype;
-			dtype += 4;
-		}
-		if(p->from.sym == S)
-			break;
-
-		p->from.offset = di->value;
-		p->from.sym->type = SDATA;
-		if(curtext == P) {
-			diag("DYNT not in text: %P", p);
-			break;
-		}
-		p->to.sym = curtext->from.sym;
-		p->to.type = D_CONST;
-		p->link = datap;
-		datap = p;
-		break;
-
-	case AINIT:
-		if(p->from.sym == S) {
-			diag("INIT without a sym\n%P", p);
-			break;
-		}
-		if(di == S) {
-			diag("INIT without previous DYNT\n%P", p);
-			break;
-		}
-		p->from.offset = di->value;
-		p->from.sym->type = SDATA;
-		p->link = datap;
-		datap = p;
-		break;
-	
-	case ADATA:
-		if(p->from.sym == S) {
-			diag("DATA without a sym\n%P", p);
-			break;
-		}
-		p->link = datap;
-		datap = p;
-		break;
-
-	case AGOK:
-		diag("unknown opcode\n%P", p);
-		p->pc = pc;
-		pc++;
-		break;
-
-	case ATEXT:
-		if(curtext != P) {
-			histtoauto();
-			curtext->to.autom = curauto;
-			curauto = 0;
-		}
-		skip = 0;
-		curtext = p;
-		autosize = (p->to.offset+3L) & ~3L;
-		if (autosize & 4)
-			autosize += 4;
-		p->to.offset = autosize;
-		autosize += 8;
-		s = p->from.sym;
-		if(s == S) {
-			diag("TEXT must have a name\n%P", p);
-			errorexit();
-		}
-		if(s->type != 0 && s->type != SXREF) {
-			if(p->reg & DUPOK) {
-				skip = 1;
-				goto casedef;
-			}
-			diag("redefinition: %s\n%P", s->name, p);
-		}
-		s->type = STEXT;
-		s->value = pc;
-		lastp->link = p;
-		lastp = p;
-		p->pc = pc;
-		pc++;
-		if(textp == P) {
-			textp = p;
-			etextp = p;
-			goto loop;
-		}
-		etextp->cond = p;
-		etextp = p;
-		break;
-
-	case AMOVS:
-		if(skip)
-			goto casedef;
-
-		if(p->from.type == D_FCONST) {
-			/* size sb 9 max */
-			snprint(literal, sizeof literal, "$%lux", ieeedtof(p->from.ieee));
-			s = lookup(literal, 0);
-			if(s->type == 0) {
-				s->type = SBSS;
-				s->value = 4;
-				t = prg();
-				t->as = ADATA;
-				t->line = p->line;
-				t->from.type = D_OREG;
-				t->from.sym = s;
-				t->from.name = D_EXTERN;
-				t->reg = 4;
-				t->to = p->from;
-				t->link = datap;
-				datap = t;
-			}
-			p->from.type = D_OREG;
-			p->from.sym = s;
-			p->from.name = D_EXTERN;
-			p->from.offset = 0;
-		}
-		goto casedef;
-
-	case AMOVT:
-		if(skip)
-			goto casedef;
-
-		if(p->from.type == D_FCONST) {
-			/* size sb 18 max */
-			snprint(literal, sizeof literal, "$%lux.%lux",
-				p->from.ieee->l, p->from.ieee->h);
-			s = lookup(literal, 0);
-			if(s->type == 0) {
-				s->type = SBSS;
-				s->value = 8;
-				t = prg();
-				t->as = ADATA;
-				t->line = p->line;
-				t->from.type = D_OREG;
-				t->from.sym = s;
-				t->from.name = D_EXTERN;
-				t->reg = 8;
-				t->to = p->from;
-				t->link = datap;
-				datap = t;
-			}
-			p->from.type = D_OREG;
-			p->from.sym = s;
-			p->from.name = D_EXTERN;
-			p->from.offset = 0;
-		}
-		goto casedef;
-
-	case AMOVQ:
-		if(skip)
-			goto casedef;
-
-		if (p->from.type == D_FREG || p->to.type == D_FREG)
-			p->as = AMOVT;		/* stupid compiler optimiser kkludge */
-
-	case AMOVL:
-	case AMOVW:
-	case AMOVB:
-		/* BOTCH */
-		if (p->from.type == D_CONST)
-		if (p->from.offset == 0LL && p->from.name == D_NONE) {
-			p->from.type = D_REG;
-			p->from.reg = REGZERO;
-		}
-		goto casedef;
-
-	default:
-	casedef:
-		if(skip)
-			nopout(p);
-
-		if(p->to.type == D_BRANCH)
-			p->to.offset += ipc;
-		lastp->link = p;
-		lastp = p;
-		p->pc = pc;
-		pc++;
-		break;
-	}
-	goto loop;
-
-eof:
-	diag("truncated object file: %s", pn);
-}
-
-Sym*
-lookup(char *symb, int v)
-{
-	Sym *s;
-	char *p;
-	long h;
-	int c0, l;
-
-	h = v;
-	for(p=symb; c0 = *p; p++)
-		h = h+h+h + c0;
-	l = (p - symb) + 1;
-	if(h < 0)
-		h = ~h;
-	h %= NHASH;
-	for(s = hash[h]; s != S; s = s->link)
-		if(s->version == v)
-		if(memcmp(s->name, symb, l) == 0)
-			return s;
-
-	while(nhunk < sizeof(Sym))
-		gethunk();
-	s = (Sym*)hunk;
-	nhunk -= sizeof(Sym);
-	hunk += sizeof(Sym);
-
-	s->name = malloc(l);
-	memmove(s->name, symb, l);
-
-	s->link = hash[h];
-	s->type = 0;
-	s->version = v;
-	s->value = 0;
-	hash[h] = s;
-	return s;
-}
-
-Prog*
-prg(void)
-{
-	Prog *p;
-
-	while(nhunk < sizeof(Prog))
-		gethunk();
-	p = (Prog*)hunk;
-	nhunk -= sizeof(Prog);
-	hunk += sizeof(Prog);
-
-	*p = zprg;
-	return p;
-}
-
-void
-gethunk(void)
-{
-	char *h;
-	long nh;
-
-	nh = NHUNK;
-	if(thunk >= 5L*NHUNK) {
-		nh = 5L*NHUNK;
-		if(thunk >= 25L*NHUNK)
-			nh = 25L*NHUNK;
-	}
-	h = mysbrk(nh);
-	if(h == (char*)-1) {
-		diag("out of memory");
-		errorexit();
-	}
-	hunk = h;
-	nhunk = nh;
-	thunk += nh;
-}
-
-void
-doprof1(void)
-{
-	Sym *s;
-	long n;
-	Prog *p, *q;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f profile 1\n", cputime());
-	Bflush(&bso);
-	s = lookup("__mcount", 0);
-	n = 1;
-	for(p = firstp->link; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			q = prg();
-			q->line = p->line;
-			q->link = datap;
-			datap = q;
-			q->as = ADATA;
-			q->from.type = D_OREG;
-			q->from.name = D_EXTERN;
-			q->from.offset = n*4;
-			q->from.sym = s;
-			q->reg = 4;
-			q->to = p->from;
-			q->to.type = D_CONST;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AMOVL;
-			p->from.type = D_OREG;
-			p->from.name = D_EXTERN;
-			p->from.sym = s;
-			p->from.offset = n*4 + 4;
-			p->to.type = D_REG;
-			p->to.reg = REGTMP;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AADDQ;
-			p->from.type = D_CONST;
-			p->from.offset = 1;
-			p->to.type = D_REG;
-			p->to.reg = REGTMP;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AMOVL;
-			p->from.type = D_REG;
-			p->from.reg = REGTMP;
-			p->to.type = D_OREG;
-			p->to.name = D_EXTERN;
-			p->to.sym = s;
-			p->to.offset = n*4 + 4;
-
-			n += 2;
-			continue;
-		}
-	}
-	q = prg();
-	q->line = 0;
-	q->link = datap;
-	datap = q;
-
-	q->as = ADATA;
-	q->from.type = D_OREG;
-	q->from.name = D_EXTERN;
-	q->from.sym = s;
-	q->reg = 4;
-	q->to.type = D_CONST;
-	q->to.offset = n;
-
-	s->type = SBSS;
-	s->value = n*4;
-}
-
-void
-doprof2(void)
-{
-	Sym *s2, *s4;
-	Prog *p, *q, *q2, *ps2, *ps4;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f profile 2\n", cputime());
-	Bflush(&bso);
-
-	if(debug['e']){
-		s2 = lookup("_tracein", 0);
-		s4 = lookup("_traceout", 0);
-	}else{
-		s2 = lookup("_profin", 0);
-		s4 = lookup("_profout", 0);
-	}
-	if(s2->type != STEXT || s4->type != STEXT) {
-		if(debug['e'])
-			diag("_tracein/_traceout not defined %d %d", s2->type, s4->type);
-		else
-			diag("_profin/_profout not defined");
-		return;
-	}
-
-	ps2 = P;
-	ps4 = P;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			if(p->from.sym == s2) {
-				ps2 = p;
-				p->reg = 1;
-			}
-			if(p->from.sym == s4) {
-				ps4 = p;
-				p->reg = 1;
-			}
-		}
-	}
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			if(p->reg != NREG) {
-				for(;;) {
-					q = p->link;
-					if(q == P)
-						break;
-					if(q->as == ATEXT)
-						break;
-					p = q;
-				}
-				continue;
-			}
-
-			/*
-			 * JSR	profin, R2
-			 */
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			if(debug['e']){		/* embedded tracing */
-				q2 = prg();
-				p->link = q2;
-				q2->link = q;
-
-				q2->line = p->line;
-				q2->pc = p->pc;
-
-				q2->as = AJMP;
-				q2->to.type = D_BRANCH;
-				q2->to.sym = p->to.sym;
-				q2->cond = q->link;
-			}else
-				p->link = q;
-			p = q;
-			p->as = AJSR;
-			p->to.type = D_BRANCH;
-			p->cond = ps2;
-			p->to.sym = s2;
-
-			continue;
-		}
-		if(p->as == ARET) {
-			/*
-			 * JSR (default)
-			 */
-			if(debug['e']){		/* embedded tracing */
-				q = prg();
-				q->line = p->line;
-				q->pc = p->pc;
-				q->link = p->link;
-				p->link = q;
-				p = q;
-			}
-			/*
-			 * JSR	profout
-			 */
-			p->as = AJSR;
-			p->to.type = D_BRANCH;
-			p->cond = ps4;
-			p->to.sym = s4;
-
-			
-			/*
-			 * RET
-			 */
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = ARET;
-
-			continue;
-		}
-	}
-}
-
-void
-nuxiinit(void)
-{
-	int i, c;
-
-	for(i=0; i<4; i++) {
-		c = find1(0x04030201L, i+1);
-		if(i <= 4)
-			inuxi4[i] = c;
-		if(i <= 2)
-			inuxi2[i] = c;
-		if(i <= 1)
-			inuxi1[i] = c;
-	}
-	for (i = 0; i < 4; i++) {
-		c = find1(0x04030201L, i+1);
-		fnuxi8[i] = c;
-		fnuxi8[i+4] = c + sizeof(long);
-	}
-
-	if(debug['v']) {
-		Bprint(&bso, "inuxi = ");
-		for(i=0; i<1; i++)
-			Bprint(&bso, "%d", inuxi1[i]);
-		Bprint(&bso, " ");
-		for(i=0; i<2; i++)
-			Bprint(&bso, "%d", inuxi2[i]);
-		Bprint(&bso, " ");
-		for(i=0; i<4; i++)
-			Bprint(&bso, "%d", inuxi4[i]);
-		Bprint(&bso, " ");
-		Bprint(&bso, "\nfnuxi = ");
-		for(i=0; i<8; i++)
-			Bprint(&bso, "%d", fnuxi8[i]);
-		Bprint(&bso, "\n");
-	}
-	Bflush(&bso);
-}
-
-find1(long l, int c)
-{
-	char *p;
-	int i;
-
-	p = (char*)&l;
-	for(i=0; i<4; i++)
-		if(*p++ == c)
-			return i;
-	return 0;
-}
-
-long
-ieeedtof(Ieee *ieee)
-{
-	int exp;
-	long v;
-
-	if(ieee->h == 0)
-		return 0;
-	exp = (ieee->h>>20) & ((1L<<11)-1L);
-	exp -= (1L<<10) - 2L;
-	v = (ieee->h & 0xfffffL) << 3;
-	v |= (ieee->l >> 29) & 0x7L;
-	if((ieee->l >> 28) & 1) {
-		v++;
-		if(v & 0x800000L) {
-			v = (v & 0x7fffffL) >> 1;
-			exp++;
-		}
-	}
-	if(exp <= -126 || exp >= 130)
-		diag("double fp to single fp overflow");
-	v |= ((exp + 126) & 0xffL) << 23;
-	v |= ieee->h & 0x80000000L;
-	return v;
-}
-
-double
-ieeedtod(Ieee *ieee)
-{
-	Ieee e;
-	double fr;
-	int exp;
-
-	if(ieee->h & (1L<<31)) {
-		e.h = ieee->h & ~(1L<<31);
-		e.l = ieee->l;
-		return -ieeedtod(&e);
-	}
-	if(ieee->l == 0 && ieee->h == 0)
-		return 0;
-	fr = ieee->l & ((1L<<16)-1L);
-	fr /= 1L<<16;
-	fr += (ieee->l>>16) & ((1L<<16)-1L);
-	fr /= 1L<<16;
-	fr += (ieee->h & (1L<<20)-1L) | (1L<<20);
-	fr /= 1L<<21;
-	exp = (ieee->h>>20) & ((1L<<11)-1L);
-	exp -= (1L<<10) - 2L;
-	return ldexp(fr, exp);
-}
diff --git a/sys/src/cmd/7l/optab.c b/sys/src/cmd/7l/optab.c
deleted file mode 100644
index 0f2852e80..000000000
--- a/sys/src/cmd/7l/optab.c
+++ /dev/null
@@ -1,141 +0,0 @@
-#include	"l.h"
-
-#define	X	99
-
-Optab	optab[] =
-{
-	{ ATEXT,	C_LEXT,	C_NONE,	C_LCON, 	 0, 0, 0 },
-	{ ATEXT,	C_LEXT,	C_REG,	C_LCON, 	 0, 0, 0 },
-
-	{ AMOVQ,	C_REG,	C_NONE,	C_REG,		 1, 4, 0 },
-	{ AMOVQ,	C_SCON,	C_NONE,	C_REG,		 6, 4, REGZERO },
-	{ AMOVQ,	C_SECON,C_NONE,	C_REG,		 6, 4, REGSB },
-	{ AMOVQ,	C_SACON,C_NONE,	C_REG,		 6, 4, REGSP },
-
-	{ AMOVQ,	C_LCON,	C_NONE,	C_REG,		15, 8, REGZERO },
-	{ AMOVQ,	C_LECON,C_NONE,	C_REG,		15, 8, REGSB },
-	{ AMOVQ,	C_LACON,C_NONE,	C_REG,		15, 8, REGSP },
-
-	{ AMOVQ,	C_QCON,	C_NONE,	C_REG,		16,20, REGZERO },
-
-	{ AMOVQ,	C_REG,	C_NONE,	C_SOREG,	 8, 4, REGZERO },
-	{ AMOVQ,	C_REG,	C_NONE,	C_SEXT,		 8, 4, REGSB },
-	{ AMOVQ,	C_REG,	C_NONE,	C_SAUTO,	 8, 4, REGSP },
-
-	{ AMOVQ,	C_SOREG,C_NONE,	C_REG,		 9, 4, REGZERO },
-	{ AMOVQ,	C_SEXT,	C_NONE,	C_REG,		 9, 4, REGSB },
-	{ AMOVQ,	C_SAUTO,C_NONE,	C_REG,		 9, 4, REGSP },
-
-	{ AMOVQ,	C_REG,	C_NONE,	C_LOREG,	19, 8, REGZERO },
-	{ AMOVQ,	C_REG,	C_NONE,	C_LEXT,		19, 8, REGSB },
-	{ AMOVQ,	C_REG,	C_NONE,	C_LAUTO,	19, 8, REGSP },
-
-	{ AMOVQ,	C_LOREG,C_NONE,	C_REG,		20, 8, REGZERO },
-	{ AMOVQ,	C_LEXT,	C_NONE,	C_REG,		20, 8, REGSB },
-	{ AMOVQ,	C_LAUTO,C_NONE,	C_REG,		20, 8, REGSP },
-/*
-	{ AMOVBU,	C_REG,	C_NONE,	C_REG,		 7, 4, 0 },
-	{ AMOVB,	C_REG,	C_NONE,	C_REG,		10, 8, 0 },
-*/
-	{ AMOVT,	C_FREG,	C_NONE,	C_FREG,		17, 4, 0 },
-
-	{ AMOVT,	C_FREG,	C_NONE,	C_SOREG,	 8, 4, REGZERO },
-	{ AMOVT,	C_FREG,	C_NONE,	C_SEXT,		 8, 4, REGSB },
-	{ AMOVT,	C_FREG,	C_NONE,	C_SAUTO,	 8, 4, REGSP },
-
-	{ AMOVT,	C_SOREG,C_NONE,	C_FREG,		 9, 4, REGZERO },
-	{ AMOVT,	C_SEXT,	C_NONE,	C_FREG,		 9, 4, REGSB },
-	{ AMOVT,	C_SAUTO,C_NONE,	C_FREG,		 9, 4, REGSP },
-
-	{ AMOVT,	C_FREG,	C_NONE,	C_LOREG,	19, 8, REGZERO },
-	{ AMOVT,	C_FREG,	C_NONE,	C_LEXT,		19, 8, REGSB },
-	{ AMOVT,	C_FREG,	C_NONE,	C_LAUTO,	19, 8, REGSP },
-
-	{ AMOVT,	C_LOREG,C_NONE,	C_FREG,		20, 8, REGZERO },
-	{ AMOVT,	C_LEXT,	C_NONE,	C_FREG,		20, 8, REGSB },
-	{ AMOVT,	C_LAUTO,C_NONE,	C_FREG,		20, 8, REGSP },
-
-	{ AADDQ,	C_REG,	C_REG,	C_REG,		 2, 4, 0 },
-	{ AADDL,	C_REG,	C_REG,	C_REG,		 2, 4, 0 },
-	{ AAND,		C_REG,	C_REG,	C_REG,		 2, 4, 0 },
-	{ AMULQ,	C_REG,	C_REG,	C_REG,		 2, 4, 0 },
-	{ AADDQ,	C_REG,	C_NONE,	C_REG,		 2, 4, 0 },
-	{ AADDL,	C_REG,	C_NONE,	C_REG,		 2, 4, 0 },
-	{ AAND,		C_REG,	C_NONE,	C_REG,		 2, 4, 0 },
-	{ AMULQ,	C_REG,	C_NONE,	C_REG,		 2, 4, 0 },
-
-	{ AADDQ,	C_SCON,	C_REG,	C_REG,		12, 4, 0 },
-	{ AADDQ,	C_SCON,	C_NONE,	C_REG,		12, 4, 0 },
-
-	{ AADDL,	C_BCON,	C_REG,	C_REG,		 3, 4, 0 },
-	{ AAND,		C_BCON,	C_REG,	C_REG,		 3, 4, 0 },
-	{ AMULQ,	C_BCON,	C_REG,	C_REG,		 3, 4, 0 },
-	{ AADDL,	C_BCON,	C_NONE,	C_REG,		 3, 4, 0 },
-	{ AAND,		C_BCON,	C_NONE,	C_REG,		 3, 4, 0 },
-	{ AMULQ,	C_BCON,	C_NONE,	C_REG,		 3, 4, 0 },
-
-/*	{ AADDL,	C_NCON,	C_REG,	C_REG,		34, 4, 0 }, */
-	{ AAND,		C_NCON,	C_REG,	C_REG,		34, 4, 0 },
-/*	{ AADDL,	C_NCON,	C_NONE,	C_REG,		34, 4, 0 }, */
-	{ AAND,		C_NCON,	C_NONE,	C_REG,		34, 4, 0 },
-
-	{ AADDL,	C_SCON,	C_REG,	C_REG,		13, 8, 0 },
-	{ AAND,		C_SCON,	C_REG,	C_REG,		13, 8, 0 },
-	{ AMULQ,	C_SCON,	C_REG,	C_REG,		13, 8, 0 },
-	{ AADDL,	C_SCON,	C_NONE,	C_REG,		13, 8, 0 },
-	{ AAND,		C_SCON,	C_NONE,	C_REG,		13, 8, 0 },
-	{ AMULQ,	C_SCON,	C_NONE,	C_REG,		13, 8, 0 },
-
-	{ AADDQ,	C_LCON,	C_REG,	C_REG,		14,12, 0 },
-	{ AADDQ,	C_LCON,	C_NONE,	C_REG,		14,12, 0 },
-	{ AADDL,	C_LCON,	C_REG,	C_REG,		14,12, 0 },
-	{ AAND,		C_LCON,	C_REG,	C_REG,		14,12, 0 },
-	{ AMULQ,	C_LCON,	C_REG,	C_REG,		14,12, 0 },
-	{ AADDL,	C_LCON,	C_NONE,	C_REG,		14,12, 0 },
-	{ AAND,		C_LCON,	C_NONE,	C_REG,		14,12, 0 },
-	{ AMULQ,	C_LCON,	C_NONE,	C_REG,		14,12, 0 },
-
-	{ AADDQ,	C_QCON,	C_REG,	C_REG,		23,24, 0 },
-	{ AADDQ,	C_QCON,	C_NONE,	C_REG,		23,24, 0 },
-	{ AADDL,	C_QCON,	C_REG,	C_REG,		23,24, 0 },
-	{ AAND,		C_QCON,	C_REG,	C_REG,		23,24, 0 },
-	{ AMULQ,	C_QCON,	C_REG,	C_REG,		23,24, 0 },
-	{ AADDL,	C_QCON,	C_NONE,	C_REG,		23,24, 0 },
-	{ AAND,		C_QCON,	C_NONE,	C_REG,		23,24, 0 },
-	{ AMULQ,	C_QCON,	C_NONE,	C_REG,		23,24, 0 },
-
-	{ AADDT,	C_FREG,	C_REG,	C_FREG,		 2, 4, 0 },
-	{ AADDT,	C_FREG,	C_NONE,	C_FREG,		 2, 4, 0 },
-	{ ACVTTQ,	C_FREG,	C_NONE,	C_FREG,		28, 4, 0 },
-
-	{ ABEQ,		C_REG,	C_NONE,	C_SBRA,		 4, 4, 0 },
-	{ AFBEQ,	C_FREG,	C_NONE,	C_SBRA,		 4, 4, 0 },
-
-	{ AJMP,		C_NONE,	C_NONE,	C_SBRA,		11, 4, 0 },
-	{ AJSR,		C_NONE,	C_NONE,	C_SBRA,		11, 4, 0 },
-
-	{ AJMP,		C_NONE,	C_NONE,	C_ZOREG,	 5, 4, REGZERO },
-	{ AJSR,		C_NONE,	C_NONE,	C_ZOREG,	 5, 4, REGLINK },
-	{ AJMP,		C_NONE,	C_REG,	C_ZOREG,	 5, 4, REGZERO },
-	{ AJSR,		C_NONE,	C_REG,	C_ZOREG,	 5, 4, REGLINK },
-	{ ACALL_PAL,	C_SCON, C_NONE, C_NONE,		18, 4, 0 },
-	{ AWORD,	C_NONE,	C_NONE,	C_LCON,		40, 4, 0 },
-
-	{ AMOVT,	C_FREG, C_NONE, C_FCREG,	24, 4, 0 },
-	{ AMOVT,	C_FCREG,C_NONE, C_FREG,		25, 4, 0 },
-
-	{ AMOVQ,	C_REG,  C_NONE, C_PREG,		26, 4, 0 },
-	{ AMOVQ,	C_PREG, C_NONE, C_REG,		27, 4, 0 },
-	{ AMOVQ,	C_PCC,  C_NONE, C_REG,		29, 4, 0 },
-
-	{ AREI,		C_NONE, C_NONE, C_NONE,		30, 4, 0 },
-	{ AFETCH,	C_ZOREG,C_NONE, C_NONE,		31, 4, REGZERO },
-
-	{ AMOVQL,	C_SOREG,C_NONE,	C_REG,		 9, 4, REGZERO },
-	{ AMOVQC,	C_REG,	C_NONE,	C_SOREG,	 8, 4, REGZERO },
-
-	{ AMOVQP,	C_SOREG,C_NONE,	C_REG,		33, 4, REGZERO },
-	{ AMOVQP,	C_REG,	C_NONE,	C_SOREG,	32, 4, REGZERO },
-
-	{ AXXX,		C_NONE,	C_NONE,	C_NONE,		 0, 4, 0 },
-};
diff --git a/sys/src/cmd/7l/pass.c b/sys/src/cmd/7l/pass.c
deleted file mode 100644
index e0451b532..000000000
--- a/sys/src/cmd/7l/pass.c
+++ /dev/null
@@ -1,495 +0,0 @@
-#include	"l.h"
-
-void
-dodata(void)
-{
-	int i, t, size;
-	Sym *s;
-	Prog *p, *p1;
-	long orig, orig1, v;
-	vlong vv;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f dodata\n", cputime());
-	Bflush(&bso);
-	for(p = datap; p != P; p = p->link) {
-		s = p->from.sym;
-		if(p->as == ADYNT || p->as == AINIT)
-			s->value = dtype;
-		if(s->type == SBSS)
-			s->type = SDATA;
-		if(s->type != SDATA)
-			diag("initialize non-data (%d): %s\n%P",
-				s->type, s->name, p);
-		v = p->from.offset + p->reg;
-		if(v > s->value)
-			diag("initialize bounds (%ld): %s\n%P",
-				s->value, s->name, p);
-	}
-
-	/*
-	 * pass 1
-	 *	assign 'small' variables to data segment
-	 *	(rational is that data segment is more easily
-	 *	 addressed through offset on REGSB)
-	 */
-	orig = 0;
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		t = s->type;
-		if(t != SDATA && t != SBSS)
-			continue;
-		v = s->value;
-		if(v == 0) {
-			diag("%s: no size", s->name);
-			v = 1;
-		}
-		while(v & 3)
-			v++;
-		
-		s->value = v;
-		if(v > MINSIZ)
-			continue;
-		if (v >= 8)
-			orig = rnd(orig, 8);
-		s->value = orig;
-		orig += v;
-		s->type = SDATA1;
-	}
-	orig = rnd(orig, 8);
-	orig1 = orig;
-
-	/*
-	 * pass 2
-	 *	assign 'data' variables to data segment
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		t = s->type;
-		if(t != SDATA) {
-			if(t == SDATA1)
-				s->type = SDATA;
-			continue;
-		}
-		v = s->value;
-		if (v >= 8)
-			orig = rnd(orig, 8);
-		s->value = orig;
-		orig += v;
-		s->type = SDATA1;
-	}
-
-	orig = rnd(orig, 8);
-	datsize = orig;
-
-	/*
-	 * pass 3
-	 *	everything else to bss segment
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		if(s->type != SBSS)
-			continue;
-		v = s->value;
-		if (v >= 8)
-			orig = rnd(orig, 8);
-		s->value = orig;
-		orig += v;
-	}
-	orig = rnd(orig, 8);
-	bsssize = orig-datsize;
-
-	/*
-	 * pass 4
-	 *	add literals to all large values.
-	 *	at this time:
-	 *		small data is allocated DATA
-	 *		large data is allocated DATA1
-	 *		large bss is allocated BSS
-	 *	the new literals are loaded between
-	 *	small data and large data.
-	 */
-	orig = 0;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as != AMOVQ)
-			continue;
-		if(p->from.type != D_CONST)
-			continue;
-		if(s = p->from.sym) {
-			t = s->type;
-			if(t != SDATA && t != SDATA1 && t != SBSS)
-				continue;
-			t = p->from.name;
-			if(t != D_EXTERN && t != D_STATIC)
-				continue;
-			v = s->value + p->from.offset;
-			size = 4;
-			if(v >= 0 && v <= 0xffff)
-				continue;
-			if(!strcmp(s->name, "setSB"))
-				continue;
-			/* size should be 19 max */
-			if(strlen(s->name) >= 10)	/* has loader address */ 
-				snprint(literal, sizeof literal, "$%p.%llux", s, p->from.offset);
-			else
-				snprint(literal, sizeof literal, "$%s.%d.%llux", s->name, s->version, p->from.offset);
-		} else {
-			if(p->from.name != D_NONE)
-				continue;
-			if(p->from.reg != NREG)
-				continue;
-			vv = p->from.offset;
-			if(vv >= -0x8000LL && vv <= 0x7fff)
-				continue;
-			if(!(vv & 0xffff))
-				continue;
-			size = 8;
-			if (vv <= 0x7FFFFFFFLL && vv >= -0x80000000LL)
-				size = 4;
-			/* size should be 17 max */
-			snprint(literal, sizeof literal, "$%llux", vv);
-		}
-		s = lookup(literal, 0);
-		if(s->type == 0) {
-			s->type = SDATA;
-			orig = rnd(orig, size);
-			s->value = orig1+orig;
-			orig += size;
-			p1 = prg();
-			p1->line = p->line;
-			p1->as = ADATA;
-			p1->from.type = D_OREG;
-			p1->from.sym = s;
-			p1->from.name = D_EXTERN;
-			p1->reg = size;
-			p1->to = p->from;
-			p1->link = datap;
-			datap = p1;
-			if(debug['C'])
-				Bprint(&bso, "literal %P for %P\n", p1, p);
-		}
-		if(s->type != SDATA)
-			diag("literal not data: %s", s->name);
-		if (size == 4)
-			p->as = AMOVL;
-		p->from.type = D_OREG;
-		p->from.sym = s;
-		p->from.name = D_EXTERN;
-		p->from.offset = 0;
-		continue;
-	}
-	orig = rnd(orig, 8);
-
-	/*
-	 * pass 5
-	 *	re-adjust offsets
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		t = s->type;
-		if(t == SBSS) {
-			s->value += orig;
-			continue;
-		}
-		if(t == SDATA1) {
-			s->type = SDATA;
-			s->value += orig;
-			continue;
-		}
-	}
-	datsize += orig;
-	if (debug['v'] || debug['z'])
-		Bprint(&bso, "datsize = %lux, bsssize = %lux\n", datsize, bsssize);
-	xdefine("setSB", SDATA, 0L+BIG);
-	xdefine("bdata", SDATA, 0L);
-	xdefine("edata", SDATA, datsize);
-	xdefine("end", SBSS, datsize+bsssize);
-	xdefine("etext", STEXT, 0L);
-}
-
-void
-undef(void)
-{
-	int i;
-	Sym *s;
-
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link)
-		if(s->type == SXREF)
-			diag("%s: not defined", s->name);
-}
-
-void
-follow(void)
-{
-	if(debug['v'])
-		Bprint(&bso, "%5.2f follow\n", cputime());
-	Bflush(&bso);
-
-	firstp = prg();
-	lastp = firstp;
-	xfol(textp);
-
-	firstp = firstp->link;
-	lastp->link = P;
-}
-
-void
-xfol(Prog *p)
-{
-	Prog *q, *r;
-	int a, i;
-
-loop:
-	if(p == P)
-		return;
-	a = p->as;
-	if(a == ATEXT)
-		curtext = p;
-	if(a == AJMP) {
-		q = p->cond;
-		if(q != P) {
-			p->mark = FOLL;
-			p = q;
-			if(!(p->mark & FOLL))
-				goto loop;
-		}
-	}
-	if(p->mark & FOLL) {
-		for(i=0,q=p; i<4; i++,q=q->link) {
-			if(q == lastp)
-				break;
-			a = q->as;
-			if(a == ANOP) {
-				i--;
-				continue;
-			}
-			if(a == AJMP || a == ARET || a == AREI)
-				goto copy;
-			if(!q->cond || (q->cond->mark&FOLL))
-				continue;
-			if(a != ABEQ && a != ABNE)
-				continue;
-		copy:
-			for(;;) {
-				r = prg();
-				*r = *p;
-				if(!(r->mark&FOLL))
-					print("cant happen 1\n");
-				r->mark = FOLL;
-				if(p != q) {
-					p = p->link;
-					lastp->link = r;
-					lastp = r;
-					continue;
-				}
-				lastp->link = r;
-				lastp = r;
-				if(a == AJMP || a == ARET || a == AREI)
-					return;
-				r->as = ABNE;
-				if(a == ABNE)
-					r->as = ABEQ;
-				r->cond = p->link;
-				r->link = p->cond;
-				if(!(r->link->mark&FOLL))
-					xfol(r->link);
-				if(!(r->cond->mark&FOLL))
-					print("cant happen 2\n");
-				return;
-			}
-		}
-		a = AJMP;
-		q = prg();
-		q->as = a;
-		q->line = p->line;
-		q->to.type = D_BRANCH;
-		q->to.offset = p->pc;
-		q->cond = p;
-		p = q;
-	}
-	p->mark = FOLL;
-	lastp->link = p;
-	lastp = p;
-	if(a == AJMP || a == ARET || a == AREI)
-		return;
-	if(p->cond != P)
-	if(a != AJSR && p->link != P) {
-		xfol(p->link);
-		p = p->cond;
-		if(p == P || (p->mark&FOLL))
-			return;
-		goto loop;
-	}
-	p = p->link;
-	goto loop;
-}
-
-void
-patch(void)
-{
-	long c, vexit;
-	Prog *p, *q;
-	Sym *s;
-	int a;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f patch\n", cputime());
-	Bflush(&bso);
-	mkfwd();
-	s = lookup("exit", 0);
-	vexit = s->value;
-	for(p = firstp; p != P; p = p->link) {
-		a = p->as;
-		if(a == ATEXT)
-			curtext = p;
-		if((a == AJSR || a == AJMP || a == ARET) &&
-		   p->to.type != D_BRANCH && p->to.sym != S) {
-			s = p->to.sym;
-			if(s->type != STEXT) {
-				diag("undefined: %s\n%P", s->name, p);
-				s->type = STEXT;
-				s->value = vexit;
-			}
-			p->to.offset = s->value;
-			p->to.type = D_BRANCH;
-		}
-		if(p->to.type != D_BRANCH)
-			continue;
-		c = p->to.offset;
-		for(q = firstp; q != P;) {
-			if(q->forwd != P)
-			if(c >= q->forwd->pc) {
-				q = q->forwd;
-				continue;
-			}
-			if(c == q->pc)
-				break;
-			q = q->link;
-		}
-		if(q == P) {
-			diag("branch out of range %ld\n%P", c, p);
-			p->to.type = D_NONE;
-		}
-		p->cond = q;
-	}
-
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT)
-			curtext = p;
-		if(p->cond != P) {
-			p->cond = brloop(p->cond);
-			if(p->cond != P)
-			if(p->to.type == D_BRANCH)
-				p->to.offset = p->cond->pc;
-		}
-	}
-}
-
-#define	LOG	5
-void
-mkfwd(void)
-{
-	Prog *p;
-	long dwn[LOG], cnt[LOG], i;
-	Prog *lst[LOG];
-
-	for(i=0; i<LOG; i++) {
-		if(i == 0)
-			cnt[i] = 1; else
-			cnt[i] = LOG * cnt[i-1];
-		dwn[i] = 1;
-		lst[i] = P;
-	}
-	i = 0;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT)
-			curtext = p;
-		i--;
-		if(i < 0)
-			i = LOG-1;
-		p->forwd = P;
-		dwn[i]--;
-		if(dwn[i] <= 0) {
-			dwn[i] = cnt[i];
-			if(lst[i] != P)
-				lst[i]->forwd = p;
-			lst[i] = p;
-		}
-	}
-}
-
-Prog*
-brloop(Prog *p)
-{
-	Prog *q;
-	int c;
-
-	for(c=0; p!=P;) {
-		if(p->as != AJMP)
-			return p;
-		q = p->cond;
-		if(q <= p) {
-			c++;
-			if(q == p || c > 50)
-				break;
-		}
-		p = q;
-	}
-	return P;
-}
-
-long
-atolwhex(char *s)
-{
-	long n;
-	int f;
-
-	n = 0;
-	f = 0;
-	while(*s == ' ' || *s == '\t')
-		s++;
-	if(*s == '-' || *s == '+') {
-		if(*s++ == '-')
-			f = 1;
-		while(*s == ' ' || *s == '\t')
-			s++;
-	}
-	if(s[0]=='0' && s[1]){
-		if(s[1]=='x' || s[1]=='X'){
-			s += 2;
-			for(;;){
-				if(*s >= '0' && *s <= '9')
-					n = n*16 + *s++ - '0';
-				else if(*s >= 'a' && *s <= 'f')
-					n = n*16 + *s++ - 'a' + 10;
-				else if(*s >= 'A' && *s <= 'F')
-					n = n*16 + *s++ - 'A' + 10;
-				else
-					break;
-			}
-		} else
-			while(*s >= '0' && *s <= '7')
-				n = n*8 + *s++ - '0';
-	} else
-		while(*s >= '0' && *s <= '9')
-			n = n*10 + *s++ - '0';
-	if(f)
-		n = -n;
-	return n;
-}
-
-long
-rnd(long v, long r)
-{
-	long c;
-
-	if(r <= 0)
-		return v;
-	v += r - 1;
-	c = v % r;
-	if(c < 0)
-		c += r;
-	v -= c;
-	return v;
-}
diff --git a/sys/src/cmd/7l/sched.c b/sys/src/cmd/7l/sched.c
deleted file mode 100644
index b7339b1e1..000000000
--- a/sys/src/cmd/7l/sched.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include	"l.h"
-
-void
-sched(Prog *p0, Prog *p1)
-{
-#ifdef	CODSCHED
-	Prog *p, *q, *t;
-	int r, a;
-
-	if(debug['X'])
-		Bprint(&bso, "\n");
-#endif
-	if (p0 == P || p0 == p1)
-		return;
-	if(debug['X'])
-		Bprint(&bso, "sched from %P to %P\n", p0, p1);
-}
-
diff --git a/sys/src/cmd/7l/span.c b/sys/src/cmd/7l/span.c
deleted file mode 100644
index 65ba2df56..000000000
--- a/sys/src/cmd/7l/span.c
+++ /dev/null
@@ -1,584 +0,0 @@
-#include	"l.h"
-
-void
-span(void)
-{
-	Prog *p;
-	Sym *setext;
-	Optab *o;
-	int m;
-	long c;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f span\n", cputime());
-	Bflush(&bso);
-	c = INITTEXT;
-	for(p = firstp; p != P; p = p->link) {
-		p->pc = c;
-		o = oplook(p);
-		m = o->size;
-		if(m == 0) {
-			if(p->as == ATEXT) {
-				curtext = p;
-				autosize = p->to.offset + 8;
-				if(p->from.sym != S)
-					p->from.sym->value = c;
-				continue;
-			}
-			diag("zero-width instruction\n%P", p);
-			continue;
-		}
-		c += m;
-	}
-	c = rnd(c, 8);
-
-	setext = lookup("etext", 0);
-	if(setext != S) {
-		setext->value = c;
-		textsize = c - INITTEXT;
-	}
-	if(INITRND)
-		INITDAT = rnd(c, INITRND);
-	if(debug['v'])
-		Bprint(&bso, "tsize = %lux\n", textsize);
-	Bflush(&bso);
-}
-		
-void
-xdefine(char *p, int t, long v)
-{
-	Sym *s;
-
-	s = lookup(p, 0);
-	if(s->type == 0 || s->type == SXREF) {
-		s->type = t;
-		s->value = v;
-	}
-}
-
-vlong		/* BUG? */
-regoff(Adr *a)
-{
-
-	offset = 0;
-	aclass(a);
-	return offset;
-}
-
-/*
- * note that we can't generate every 32 bit constant with MOVQA+MOVQAH, hence the
- * comparison with 0x7fff8000.  offset >= this value gets incorrectly sign extended in
- * the 64 bit register.
- */
-aclass(Adr *a)
-{
-	Sym *s;
-	int t;
-
-	switch(a->type) {
-	case D_NONE:
-		return C_NONE;
-
-	case D_REG:
-		return C_REG;
-
-	case D_FREG:
-		return C_FREG;
-
-	case D_FCREG:
-		return C_FCREG;
-
-	case D_PREG:
-		return C_PREG;
-
-	case D_PCC:
-		return C_PCC;
-
-	case D_OREG:
-		switch(a->name) {
-		case D_EXTERN:
-		case D_STATIC:
-			if(a->sym == 0) {
-				print("null sym external\n");
-				print("%D\n", a);
-				return C_GOK;
-			}
-			t = a->sym->type;
-			if(t == 0 || t == SXREF) {
-				diag("undefined external: %s in %s",
-					a->sym->name, TNAME);
-				a->sym->type = SDATA;
-			}
-			offset = a->sym->value + a->offset - BIG;
-			if(offset >= -BIG && offset < BIG)
-				return C_SEXT;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LEXT;
-		badoff:
-			diag("offset out of range: %#llux", offset);
-			return C_GOK;
-		case D_AUTO:
-			offset = autosize + a->offset;
-			if(offset >= -BIG && offset < BIG)
-				return C_SAUTO;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LAUTO;
-			goto badoff;
-		case D_PARAM:
-			offset = autosize + a->offset + 8L;
-			if(offset >= -BIG && offset < BIG)
-				return C_SAUTO;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LAUTO;
-			goto badoff;
-		case D_NONE:
-			offset = a->offset;
-			if(offset == 0)
-				return C_ZOREG;
-			if(offset >= -BIG && offset < BIG)
-				return C_SOREG;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LOREG;
-			goto badoff;
-		}
-		return C_GOK;
-
-	case D_CONST:
-		switch(a->name) {
-
-		case D_NONE:
-			offset = a->offset;
-			if(offset > 0) {
-				if(offset <= 0xffLL)
-					return C_BCON;
-				if(offset <= 0x7fffLL)
-					return C_SCON;
-				if((offset & 0xffffLL) == 0 && offset <= 0x7fff0000LL)
-					return C_UCON;
-				if (offset < 0x7fff8000LL)
-					return C_LCON;
-				return C_QCON;
-			}
-			if(offset == 0)
-				return C_ZCON;
-			if(offset >= -0x100LL)
-				return C_NCON;
-			if(offset >= -0x8000LL)
-				return C_SCON;
-			if((offset & 0xffffLL) == 0 && offset >= -0x80000000LL)
-				return C_UCON;
-			if (offset >= -0x80000000LL)
-				return C_LCON;
-			return C_QCON;
-
-		case D_EXTERN:
-		case D_STATIC:
-			s = a->sym;
-			if(s == 0) {
-				print("null sym const\n");
-				print("%D\n", a);
-				return C_GOK;
-			}
-			t = s->type;
-			if(t == 0 || t == SXREF) {
-				diag("undefined external: %s in %s",
-					s->name, TNAME);
-				s->type = SDATA;
-			}
-			if(s->type == STEXT || s->type == SLEAF) {
-				offset = s->value + a->offset;
-				return C_LCON;
-			}
-			offset = s->value + a->offset - BIG;
-			if (offset == 0L) {
-				offset = s->value + a->offset + INITDAT;
-				return C_LCON;		/* botch */
-			}
-			if(offset >= -BIG && offset < BIG && offset != 0L)
-				return C_SECON;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000L && offset != 0LL /*&& offset >= -INITDAT*/)
-				return C_LECON;
-			/*offset = s->value + a->offset + INITDAT;*/
-/*			if (offset >= -BIG && offset < BIG)
-				return C_SCON;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LCON; */
-			goto badoff;
-			/*return C_QCON;*/
-
-		case D_AUTO:
-			offset = autosize + a->offset;
-			if(offset >= -BIG && offset < BIG)
-				return C_SACON;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LACON;
-			goto badoff;
-
-		case D_PARAM:
-			offset = autosize + a->offset + 8L;
-			if(offset >= -BIG && offset < BIG)
-				return C_SACON;
-			if (offset >= -0x80000000LL && offset < 0x7fff8000LL)
-				return C_LACON;
-			goto badoff;
-		}
-		return C_GOK;
-
-	case D_BRANCH:
-		return C_SBRA;
-	}
-	return C_GOK;
-}
-
-Optab*
-oplook(Prog *p)
-{
-	int a1, a2, a3, r;
-	char *c1, *c3;
-	Optab *o, *e;
-
-	a1 = p->optab;
-	if(a1)
-		return optab+(a1-1);
-	a1 = p->from.class;
-	if(a1 == 0) {
-		a1 = aclass(&p->from) + 1;
-		p->from.class = a1;
-	}
-	a1--;
-	a3 = p->to.class;
-	if(a3 == 0) {
-		a3 = aclass(&p->to) + 1;
-		p->to.class = a3;
-	}
-	a3--;
-	a2 = C_NONE;
-	if(p->reg != NREG)
-		a2 = C_REG;
-	r = p->as;
-	o = oprange[r].start;
-	if(o == 0) {
-		a1 = opcross[repop[r]][a1][a2][a3];
-		if(a1) {
-			p->optab = a1+1;
-			return optab+a1;
-		}
-		o = oprange[r].stop; /* just generate an error */
-	}
-	e = oprange[r].stop;
-	c1 = xcmp[a1];
-	c3 = xcmp[a3];
-	for(; o<e; o++)
-		if(o->a2 == a2)
-		if(c1[o->a1])
-		if(c3[o->a3]) {
-			p->optab = (o-optab)+1;
-			return o;
-		}
-	diag("illegal combination %A %d %d %d (opcross %d)",
-		p->as, p->from.class-1, a2, a3, a1);
-	if(!debug['a'])
-		prasm(p);
-	o = optab;
-	p->optab = (o-optab)+1;
-	return o;
-}
-
-int
-cmp(int a, int b)
-{
-
-	if(a == b)
-		return 1;
-	switch(a) {
-	case C_QCON:
-		if(b == C_ZCON || b == C_BCON || b == C_NCON || b == C_SCON || b == C_UCON || b == C_LCON)
-			return 1;
-		break;
-	case C_LCON:
-		if(b == C_ZCON || b == C_BCON || b == C_NCON || b == C_SCON || b == C_UCON)
-			return 1;
-		break;
-	case C_UCON:
-		if(b == C_ZCON)
-			return 1;
-		break;
-	case C_SCON:
-		if(b == C_ZCON || b == C_BCON || b == C_NCON)
-			return 1;
-		break;
-	case C_BCON:
-		if(b == C_ZCON)
-			return 1;
-		break;
-	case C_LACON:
-		if(b == C_SACON)
-			return 1;
-		break;
-	case C_LBRA:
-		if(b == C_SBRA)
-			return 1;
-		break;
-	case C_LEXT:
-		if(b == C_SEXT)
-			return 1;
-		break;
-	case C_LAUTO:
-		if(b == C_SAUTO)
-			return 1;
-		break;
-	case C_REG:
-/*		if(b == C_ZCON)
-			return 1; */
-		break;
-	case C_LOREG:
-		if(b == C_ZOREG || b == C_SOREG)
-			return 1;
-		break;
-	case C_SOREG:
-		if(b == C_ZOREG)
-			return 1;
-		break;
-	}
-	return 0;
-}
-
-int
-ocmp(void *a1, void *a2)
-{
-	Optab *p1, *p2;
-	int n;
-
-	p1 = a1;
-	p2 = a2;
-	n = p1->as - p2->as;
-	if(n)
-		return n;
-	n = p1->a1 - p2->a1;
-	if(n)
-		return n;
-	n = p1->a2 - p2->a2;
-	if(n)
-		return n;
-	n = p1->a3 - p2->a3;
-	if(n)
-		return n;
-	return 0;
-}
-
-void
-buildop(void)
-{
-	int i, n, r;
-
-	for(i=0; i<32; i++)
-		for(n=0; n<32; n++)
-			xcmp[i][n] = cmp(n, i);
-	for(n=0; optab[n].as != AXXX; n++)
-		;
-	qsort(optab, n, sizeof(optab[0]), ocmp);
-	for(i=0; i<n; i++) {
-		r = optab[i].as;
-		oprange[r].start = optab+i;
-		while(optab[i].as == r)
-			i++;
-		oprange[r].stop = optab+i;
-		i--;
-		
-		switch(r)
-		{
-		default:
-			diag("unknown op in build: %A", r);
-			errorexit();
-		case AADDQ:
-			oprange[AS4ADDQ] = oprange[r];
-			oprange[AS8ADDQ] = oprange[r];
-			oprange[ASUBQ] = oprange[r];
-			oprange[AS4SUBQ] = oprange[r];
-			oprange[AS8SUBQ] = oprange[r];
-			break;
-		case AADDL:
-			oprange[AADDLV] = oprange[r];
-			oprange[AS4ADDL] = oprange[r];
-			oprange[AS8ADDL] = oprange[r];
-			oprange[AADDQV] = oprange[r];
-			oprange[ASUBQV] = oprange[r];
-			oprange[ASUBL] = oprange[r];
-			oprange[ASUBLV] = oprange[r];
-			oprange[AS4SUBL] = oprange[r];
-			oprange[AS8SUBL] = oprange[r];
-			break;
-		case AAND:
-			oprange[AANDNOT] = oprange[r];
-			oprange[AOR] = oprange[r];
-			oprange[AORNOT] = oprange[r];
-			oprange[AXOR] = oprange[r];
-			oprange[AXORNOT] = oprange[r];
-			break;
-		case AMULQ:
-			oprange[ACMPEQ] = oprange[r];
-			oprange[ACMPGT] = oprange[r];
-			oprange[ACMPGE] = oprange[r];
-			oprange[ACMPUGT] = oprange[r];
-			oprange[ACMPUGE] = oprange[r];
-			oprange[ACMPBLE] = oprange[r];
-			oprange[ACMOVEQ] = oprange[r];
-			oprange[ACMOVNE] = oprange[r];
-			oprange[ACMOVLT] = oprange[r];
-			oprange[ACMOVGE] = oprange[r];
-			oprange[ACMOVLE] = oprange[r];
-			oprange[ACMOVGT] = oprange[r];
-			oprange[ACMOVLBS] = oprange[r];
-			oprange[ACMOVLBC] = oprange[r];
-			oprange[AMULL] = oprange[r];
-			oprange[AMULLV] = oprange[r];
-			oprange[AMULQV] = oprange[r];
-			oprange[AUMULH] = oprange[r];
-			oprange[ASLLQ] = oprange[r];
-			oprange[ASRLQ] = oprange[r];
-			oprange[ASRAQ] = oprange[r];
-			oprange[AEXTBL] = oprange[r];
-			oprange[AEXTWL] = oprange[r];
-			oprange[AEXTLL] = oprange[r];
-			oprange[AEXTQL] = oprange[r];
-			oprange[AEXTWH] = oprange[r];
-			oprange[AEXTLH] = oprange[r];
-			oprange[AEXTQH] = oprange[r];
-			oprange[AINSBL] = oprange[r];
-			oprange[AINSWL] = oprange[r];
-			oprange[AINSLL] = oprange[r];
-			oprange[AINSQL] = oprange[r];
-			oprange[AINSWH] = oprange[r];
-			oprange[AINSLH] = oprange[r];
-			oprange[AINSQH] = oprange[r];
-			oprange[AMSKBL] = oprange[r];
-			oprange[AMSKWL] = oprange[r];
-			oprange[AMSKLL] = oprange[r];
-			oprange[AMSKQL] = oprange[r];
-			oprange[AMSKWH] = oprange[r];
-			oprange[AMSKLH] = oprange[r];
-			oprange[AMSKQH] = oprange[r];
-			oprange[AZAP] = oprange[r];
-			oprange[AZAPNOT] = oprange[r];
-			break;
-		case ABEQ:
-			oprange[ABNE] = oprange[r];
-			oprange[ABGE] = oprange[r];
-			oprange[ABLE] = oprange[r];
-			oprange[ABGT] = oprange[r];
-			oprange[ABLT] = oprange[r];
-			break;
-		case AFBEQ:
-			oprange[AFBNE] = oprange[r];
-			oprange[AFBGE] = oprange[r];
-			oprange[AFBLE] = oprange[r];
-			oprange[AFBGT] = oprange[r];
-			oprange[AFBLT] = oprange[r];
-			break;
-		case AMOVQ:
-			oprange[AMOVL] = oprange[r];
-			oprange[AMOVLU] = oprange[r];
-			oprange[AMOVQU] = oprange[r];
-			oprange[AMOVA] = oprange[r];
-			oprange[AMOVAH] = oprange[r];
-
-			oprange[AMOVBU] = oprange[r];
-			oprange[AMOVWU] = oprange[r];
-			oprange[AMOVB] = oprange[r];
-			oprange[AMOVW] = oprange[r];
-			break;
-		case AMOVT:
-			oprange[AMOVS] = oprange[r];
-			break;
-		case AADDT:
-			oprange[AADDS] = oprange[r];
-			oprange[ACMPTEQ] = oprange[r];
-			oprange[ACMPTGT] = oprange[r];
-			oprange[ACMPTGE] = oprange[r];
-			oprange[ACMPTUN] = oprange[r];
-			oprange[ADIVS] = oprange[r];
-			oprange[ADIVT] = oprange[r];
-			oprange[AMULS] = oprange[r];
-			oprange[AMULT] = oprange[r];
-			oprange[ASUBS] = oprange[r];
-			oprange[ASUBT] = oprange[r];
-			oprange[ACPYS] = oprange[r];
-			oprange[ACPYSN] = oprange[r];
-			oprange[ACPYSE] = oprange[r];
-			oprange[ACVTLQ] = oprange[r];
-			oprange[ACVTQL] = oprange[r];
-			oprange[AFCMOVEQ] = oprange[r];
-			oprange[AFCMOVNE] = oprange[r];
-			oprange[AFCMOVLT] = oprange[r];
-			oprange[AFCMOVGE] = oprange[r];
-			oprange[AFCMOVLE] = oprange[r];
-			oprange[AFCMOVGT] = oprange[r];
-			break;
-		case ACVTTQ:
-			oprange[ACVTQT] = oprange[r];
-			oprange[ACVTTS] = oprange[r];
-			oprange[ACVTQS] = oprange[r];
-			break;
-		case AJMP:
-		case AJSR:
-			break;
-		case ACALL_PAL:
-			break;
-		case AMOVQL:
-			oprange[AMOVLL] = oprange[r];
-			break;
-		case AMOVQC:
-			oprange[AMOVLC] = oprange[r];
-			break;
-		case AMOVQP:
-			oprange[AMOVLP] = oprange[r];
-			break;
-		case AREI:
-			oprange[AMB] = oprange[r];
-			oprange[ATRAPB] = oprange[r];
-			break;
-		case AFETCH:
-			oprange[AFETCHM] = oprange[r];
-			break;
-		case AWORD:
-		case ATEXT:
-			break;
-		}
-	}
-}
-
-void
-buildrep(int x, int as)
-{
-	Opcross *p;
-	Optab *e, *s, *o;
-	int a1, a2, a3, n;
-
-	if(C_NONE != 0 || C_REG != 1 || C_GOK >= 32 || x >= nelem(opcross)) {
-		diag("assumptions fail in buildrep");
-		errorexit();
-	}
-	repop[as] = x;
-	p = (opcross + x);
-	s = oprange[as].start;
-	e = oprange[as].stop;
-	for(o=e-1; o>=s; o--) {
-		n = o-optab;
-		for(a2=0; a2<2; a2++) {
-			if(a2) {
-				if(o->a2 == C_NONE)
-					continue;
-			} else
-				if(o->a2 != C_NONE)
-					continue;
-			for(a1=0; a1<32; a1++) {
-				if(!xcmp[a1][o->a1])
-					continue;
-				for(a3=0; a3<32; a3++)
-					if(xcmp[a3][o->a3])
-						(*p)[a1][a2][a3] = n;
-			}
-		}
-	}
-	oprange[as].start = 0;
-}