#include	"l.h"

short	opa[20];
short	*op;

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)
		diag("entry not text: %s", s->name);
	return s->value;
}

void
asmb(void)
{
	Prog *p;
	long v;
	int a;
	short *op1;

	if(debug['v'])
		Bprint(&bso, "%5.2f asmb\n", cputime());
	Bflush(&bso);

	seek(cout, HEADR, 0);
	pc = INITTEXT;
	curp = firstp;
	for(p = firstp; p != P; p = p->link) {
		if(p->as == ATEXT)
			curtext = p;
		if(p->pc != pc) {
			if(!debug['a'])
				print("%P\n", curp);
			diag("phase error %lux sb %lux in %s\n", p->pc, pc, TNAME);
			pc = p->pc;
		}
		curp = p;
		if(debug['a'])
			Bprint(&bso, "%lux:%P\n", pc, curp);
		asmins(p);
		if(cbc < sizeof(opa))
			cflush();
		for(op1 = opa; op1 < op; op1++) {
			a = *op1;
			*cbp++ = a >> 8;
			*cbp++ = a;
		}
		a = 2*(op - opa);
		pc += a;
		cbc -= a;
		if(debug['a']) {
			for(op1 = opa; op1 < op; op1++)
				if(op1 == opa)
					Bprint(&bso, "\t\t%4ux", *op1 & 0xffff);
				else
					Bprint(&bso, " %4ux", *op1 & 0xffff);
			if(op != opa)
				Bprint(&bso, "\n");
		}
	}
	cflush();
	switch(HEADTYPE) {
	default:
		diag("unknown header type %d\n", HEADTYPE);
	case 0:
		seek(cout, rnd(HEADR+textsize, 8192), 0);
		break;
	case 1:
		seek(cout, rnd(HEADR+textsize, INITRND), 0);
		break;
	case 2:
		seek(cout, HEADR+textsize, 0);
		break;
	case 3:
	case 4:
		seek(cout, HEADR+rnd(textsize, INITRND), 0);
		break;
	}

	if(debug['v'])
		Bprint(&bso, "%5.2f datblk\n", cputime());
	Bflush(&bso);

	for(v = 0; v < datsize; v += sizeof(buf)-100) {
		if(datsize-v > sizeof(buf)-100)
			datblk(v, sizeof(buf)-100);
		else
			datblk(v, datsize-v);
	}

	symsize = 0;
	spsize = 0;
	lcsize = 0;
	if(!debug['s']) {
		if(debug['v'])
			Bprint(&bso, "%5.2f sym\n", cputime());
		Bflush(&bso);

		switch(HEADTYPE) {
		default:
		case 0:
			seek(cout, rnd(HEADR+textsize, 8192)+datsize, 0);
			break;
		case 1:
			seek(cout, rnd(HEADR+textsize, INITRND)+datsize, 0);
			break;
		case 2:
			seek(cout, HEADR+textsize+datsize, 0);
			break;
		case 3:
			seek(cout, HEADR+rnd(textsize, INITRND)+datsize, 0);
			break;
		}
		if(!debug['s'])
			asmsym();
		if(debug['v'])
			Bprint(&bso, "%5.2f sp\n", cputime());
		Bflush(&bso);
		if(!debug['s'])
			asmsp();
		if(debug['v'])
			Bprint(&bso, "%5.2f pc\n", cputime());
		Bflush(&bso);
		if(!debug['s'])
			asmlc();
		cflush();
	}

	if(debug['v'])
		Bprint(&bso, "%5.2f headr\n", cputime());
	Bflush(&bso);
	seek(cout, 0L, 0);
	switch(HEADTYPE) {
	default:
	case 0:	/* garbage */
		lput(0x160L<<16);		/* magic and sections */
		lput(0L);			/* time and date */
		lput(rnd(HEADR+textsize, 4096)+datsize);
		lput(symsize);			/* nsyms */
		lput((0x38L<<16)|7L);		/* size of optional hdr and flags */
		lput((0413<<16)|0437L);		/* magic and version */
		lput(rnd(HEADR+textsize, 4096));	/* sizes */
		lput(datsize);
		lput(bsssize);
		lput(entryvalue());		/* va of entry */
		lput(INITTEXT-HEADR);		/* va of base of text */
		lput(INITDAT);			/* va of base of data */
		lput(INITDAT+datsize);		/* va of base of bss */
		lput(~0L);			/* gp reg mask */
		lput(0L);
		lput(0L);
		lput(0L);
		lput(0L);
		lput(~0L);			/* gp value ?? */
		break;
	case 1:	/* boot */
		lput(0407);			/* magic */
		lput(rnd(HEADR+textsize, INITRND)-HEADR+datsize);		/* sizes */
		lput(0);
		lput(bsssize);
		lput(symsize);			/* nsyms */
		lput(entryvalue());		/* va of entry */
		lput(spsize);			/* sp offsets */
		lput(lcsize);			/* line offsets */
		break;
	case 2:
		lput(0407);			/* magic */
		lput(textsize);			/* sizes */
		lput(datsize);
		lput(bsssize);
		lput(symsize);			/* nsyms */
		lput(entryvalue());		/* va of entry */
		lput(spsize);			/* sp offsets */
		lput(lcsize);			/* line offsets */
		break;
	case 3:
	case 4:
		/* header */
		lput(0xfeedfaceL);			/* magic */
		lput(6);				/* 68040 */
		lput(1);				/* more 68040 */
		lput(5);				/* file type 'boot' */
		lput(HEADTYPE);				/* number commands */
		lput(HEADR-7*4);			/* sizeof commands */
		lput(1);				/* no undefineds */
		/* command 1 text */
		lput(1);				/* command = 'segment' */
		lput(124);				/* command size */
		s16put("__TEXT");
/* botch?? entryvalue() */
		lput(INITTEXT);				/* va of start */
		lput(rnd(textsize, 8192));		/* va size */
		lput(HEADR);				/* file offset */
		lput(rnd(textsize, 8192));		/* file size */
		lput(7);				/* max prot */
		lput(7);				/* init prot */
		lput(1);				/* number of sections */
		lput(0);				/* flags */
		/* text section */
		s16put("__text");
		s16put("__TEXT");
/* botch?? entryvalue() */
		lput(INITTEXT);				/* va of start */
		lput(textsize);				/* va size */
		lput(HEADR);				/* file offset */
		lput(2);				/* align */
		lput(0);				/* reloff */
		lput(0);				/* nreloc */
		lput(0);				/* flags */
		lput(0);				/* reserved1 */
		lput(0);				/* reserved2 */
		/* command 1 data */
		lput(1);				/* command = 'segment' */
		lput(192);				/* command size */
		s16put("__DATA");
		lput(INITDAT);				/* va of start */
		lput(rnd(datsize, 8192));		/* va size */
		lput(HEADR+rnd(textsize, 8192));	/* file offset */
		lput(rnd(datsize, 8192));		/* file size */
		lput(7);				/* max prot */
		lput(7);				/* init prot */
		lput(2);				/* number of sections */
		lput(0);				/* flags */
		/* data section */
		s16put("__data");
		s16put("__DATA");
		lput(INITDAT);				/* va of start */
		lput(datsize);				/* va size */
		lput(HEADR+rnd(textsize, 8192));	/* file offset */
		lput(2);				/* align */
		lput(0);				/* reloff */
		lput(0);				/* nreloc */
		lput(0);				/* flags */
		lput(0);				/* reserved1 */
		lput(0);				/* reserved2 */
		/* bss section */
		s16put("__bss");
		s16put("__DATA");
		lput(INITDAT+datsize);			/* va of start */
		lput(bsssize);				/* va size */
		lput(0);				/* file offset */
		lput(2);				/* align */
		lput(0);				/* reloff */
		lput(0);				/* nreloc */
		lput(1);				/* flags = zero fill */
		lput(0);				/* reserved1 */
		lput(0);				/* reserved2 */
		/* command 2 symbol */
		lput(2);				/* command = 'symbol' */
		lput(24);				/* command size */
		lput(HEADR+rnd(textsize, INITRND)
			+datsize);			/* symoff */
		lput(symsize);				/* nsyms */
		lput(spsize);				/* sp offsets */
		lput(lcsize);				/* line offsets */
		break;
	}
	cflush();
}

void
asmins(Prog *p)
{
	Optab *o;
	int t, a, b;
	long v;
	Prog *q;

	op = opa + 1;
	if(special[p->from.type])
	switch(p->from.type) {

	case D_CCR:
		if(p->as != AMOVW)
			goto bad;
		a = asmea(p, &p->to);
		if((a & 0170) == 010)
			goto bad;
		opa[0] = 0x42c0 | a;		/* mov from ccr */
		return;

	case D_SR:
		if(p->as != AMOVW)
			goto bad;
		a = asmea(p, &p->to);
		if((a & 0170) == 010)
			goto bad;
		opa[0] = 0x40c0 | a;		/* mov from sr */
		return;

	case D_USP:
		if(p->as != AMOVL)
			goto bad;
		a = asmea(p, &p->to);
		if((a & 0170) == 010) {
			opa[0] = 0x4e68|(a&7);	/* mov usp An */
			return;
		}
		t = 0x800;
		goto movec1;

	case D_SFC:
		t = 0x000;
		goto movec1;

	case D_DFC:
		t = 0x001;
		goto movec1;

	case D_CACR:
		t = 0x002;
		goto movec1;

	case D_TC:
		t = 0x003;
		goto movec1;

	case D_ITT0:
		t = 0x004;
		goto movec1;

	case D_ITT1:
		t = 0x005;
		goto movec1;

	case D_DTT0:
		t = 0x006;
		goto movec1;

	case D_DTT1:
		t = 0x007;
		goto movec1;

	case D_VBR:
		t = 0x801;
		goto movec1;

	case D_CAAR:
		t = 0x802;
		goto movec1;

	case D_MSP:
		t = 0x803;
		goto movec1;

	case D_ISP:
		t = 0x804;
		goto movec1;

	case D_MMUSR:
		t = 0x805;
		goto movec1;

	case D_URP:
		t = 0x806;
		goto movec1;

	case D_SRP:
		t = 0x807;
		goto movec1;

	movec1:
		if(p->as != AMOVL)
			goto bad;
		opa[0] = 0x4e7a;			/* mov spc Dn */
		a = asmea(p, &p->to);
		b = a & 0170;
		if(b == 0 || b == 010) {
			*op++ = (a<<12) | t;
			return;
		}
		goto bad;

	case D_FPCR:
		t = 0xb000;
		goto movec3;

	case D_FPSR:
		t = 0xa800;
		goto movec3;

	case D_FPIAR:
		t = 0xa400;

	movec3:
		if(p->as != AMOVL)
			goto bad;
		op++;
		a = asmea(p, &p->to);
		opa[0] = optab[AFMOVEL].opcode0 | a;
		opa[1] = t;
		return;
	}
	if(special[p->to.type])
	switch(p->to.type) {

	case D_CCR:
		if(p->as != AMOVW)		/* botch, needs and, eor etc. */
			goto bad;
		a = asmea(p, &p->from);
		if((a & 0170) == 010)
			goto bad;
		opa[0] = 0x44c0 | a;		/* mov to ccr */
		return;

	case D_SR:
		if(p->as != AMOVW)		/* botch, needs and, eor etc. */
			goto bad;
		a = asmea(p, &p->from);
		if((a & 0170) == 010)
			goto bad;
		opa[0] = 0x46c0 | a;		/* mov to sr */
		return;

	case D_USP:
		if(p->as != AMOVL)
			goto bad;
		a = asmea(p, &p->from);
		if((a & 0170) == 010) {
			opa[0] = 0x4e60|(a&7);	/* mov An usp */
			return;
		}
		t = 0x800;
		goto movec2;

	case D_SFC:
		t = 0x000;
		goto movec2;

	case D_DFC:
		t = 0x001;
		goto movec2;

	case D_CACR:
		t = 0x002;
		goto movec2;

	case D_TC:
		t = 0x003;
		goto movec2;

	case D_ITT0:
		t = 0x004;
		goto movec2;

	case D_ITT1:
		t = 0x005;
		goto movec2;

	case D_DTT0:
		t = 0x006;
		goto movec2;

	case D_DTT1:
		t = 0x007;
		goto movec2;

	case D_VBR:
		t = 0x801;
		goto movec2;

	case D_CAAR:
		t = 0x802;
		goto movec2;

	case D_MSP:
		t = 0x803;
		goto movec2;

	case D_ISP:
		t = 0x804;
		goto movec2;

	case D_MMUSR:
		t = 0x805;
		goto movec2;

	case D_URP:
		t = 0x806;
		goto movec2;

	case D_SRP:
		t = 0x807;
		goto movec2;

	movec2:
		if(p->as != AMOVL)
			goto bad;
		opa[0] = 0x4e7b;			/* mov Dn spc */
		a = asmea(p, &p->from);
		b = a & 0170;
		if(b == 0 || b == 010) {
			*op++ = (a<<12) | t;
			return;
		}
		goto bad;

	case D_FPCR:
		t = 0x9000;
		goto movec4;

	case D_FPSR:
		t = 0x8800;
		goto movec4;

	case D_FPIAR:
		t = 0x8400;

	movec4:
		if(p->as != AMOVL)
			goto bad;
		op++;
		a = asmea(p, &p->from);
		opa[0] = optab[AFMOVEL].opcode0 | a;
		opa[1] = t;
		return;
	}

	o = &optab[p->as];
	t = o->opcode0;
	switch(o->optype) {
	case 0:		/* pseudo ops */
		if(p->as != ATEXT && p->as != ANOP) {
			if(!debug['a'])
				print("%P\n", p);
			diag("unimplemented instruction in %s\n", TNAME);
			return;
		}
		op = opa;
		return;

	case 1:		/* branches */
		if(p->to.type != D_BRANCH)
			goto bad;
		a = asmea(p, &p->to);
		/* hack to turn 3-word bsr into 2-word jsr */
		if(a == 0xff && p->as == ABSR &&
		   p->cond->pc < 32768L && p->cond->pc >= 0) {
			op = opa + 1;
			t = o->opcode1;
			*op++ = p->cond->pc;
			break;
		}
		t |= a;
		break;

	case 2:		/* move */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) == 0110) { /* src quick */
			t = o->opcode1;
			if((b & 0170) != 0)
				goto bad;
			t |= a >> 7;
			t |= b << 9;
			break;
		}
		t |= a;
		t |= (b&7) << 9;
		t |= (b&070) << 3;
		break;

	case 3:		/* add */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) == 0110) { /* src quick */
			t = o->opcode1;
			t |= (a&01600) << 2;
			t |= b;
			break;
		}
		if((b & 0170) == 0) { /* dst Dn */
			t |= a;
			t |= (b & 7) << 9;
			break;
		}
		if((b & 0170) == 010) { /* dst An */
			if((t & 0xc0) == 0)
				goto bad;
			t = o->opcode2;
			t |= a;						
			t |= (b & 7) << 9;
			break;
		}
		if((a & 0170) == 0) { /* src Dn */
			t |= 0x100;
			t |= (a & 7) << 9;
			t |= b;
			break;
		}
		if((a & 0177) == 074) { /* src immed */
			t = o->opcode3;
			t |= b;
			break;
		}
		goto bad;

	case 4:		/* no operands */
		break;

	case 5:		/* tst */
		t |= asmea(p, &p->to);
		if((t&0170) == 010)
			goto bad;
		break;

	case 6:		/* lea */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((b & 0170) != 010)
			goto bad;
		t |= a;
		t |= (b & 7) << 9;
		break;

	case 7:		/* cmp */
		b = asmea(p, &p->to);
		a = asmea(p, &p->from);
		if((a & 0170) == 010) {	/* dst An */
			t = o->opcode1;
			if(t == 0)	/* cmpb illegal */
				goto bad;
			t |= 0xc0;
			t |= b;						
			t |= (a & 7) << 9;
			break;
		}
		if((b & 0177) == 074) { /* src immed */
			t = o->opcode2;
			t |= a;
			break;
		}
		if((a & 0170) == 0) {	/* dst Dn */
			t |= b;
			t |= (a&7) << 9;
			break;
		}
		if((b&0170) == 030 && (a&0170) == 030) { /* (A)+,(A)+ */
			t = o->opcode3;
			t |= b & 7;
			t |= (a & 7) << 9;
			break;
		}
		goto bad;

	case 8:		/* svc */
		*op++ = optab[ARTS].opcode0;
		break;

	case 9:		/* and */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) == 010)
			goto bad;
		if((b & 0170) == 0) { /* dst Dn */
			t |= a;
			t |= (b&7) << 9;
			break;
		}
		if((a & 0170) == 0) { /* src Dn */
			t = o->opcode1;
			t |= b;
			t |= (a&7) << 9;
			break;
		}
		if((a & 0177) == 074) { /* src immed */
			t = o->opcode2;
			t |= b;
			break;
		}
		goto bad;

	case 10:	/* eor */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) == 010)
			goto bad;
		if((a & 0170) == 0) { /* src Dn */
			t |= b;
			t |= (a&7) << 9;
			break;
		}
		if((a & 0177) == 074) { /* src immed */
			t = o->opcode1;
			t |= b;
			break;
		}
		goto bad;

	case 11:	/* ext */
		b = asmea(p, &p->to);
		if((b & 0170) == 0) { /* dst Dn */
			t |= b;
			break;
		}
		goto bad;

	case 12:	/* shift */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((b & 0170) == 0) { /* dst Dn */
			if((a & 0177) == 0110) { /* src quick */
				t |= (a & 01600) << 2;
				t |= b;
				break;
			}
			if((a & 0170) == 0) { /* src Dn */
				t |= 0x20;
				t |= a << 9;
				t |= b;
				break;
			}
			goto bad;
		}
		goto bad;

	case 13:	/* mul, div short */
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((b & 0170) == 0) { /* dst Dn */
			if((a & 0170) == 010)
				goto bad;	
			t |= a;
			t |= b << 9;
			break;
		}
		goto bad;

	case 14:	/* mul, div long */
		*op++ = o->opcode1;
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((b & 0170) == 0) { /* dst Dn */
			if((a & 0170) == 010)
				goto bad;	
			t |= a;
			opa[1] |= b << 12;
			opa[1] |= b+1;
			break;
		}
		goto bad;

	case 15:	/* dec and branch */
		if(p->to.type != D_BRANCH)
			goto bad;
		v = p->cond->pc - p->pc - 2;
		if(v < -32768L || v >= 32768L)
			goto bad;
		*op++ = v;
		a = asmea(p, &p->from);
		if((a & 0170) != 0)
			goto bad;
		t |= a;
		break;

	case 16:	/* fmove */
		*op++ = o->opcode1;
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) == 0100) { /* src Fn */
			if((b & 0170) == 0100) { /* both Fn */
				opa[1] |= (a&7) << 10;
				opa[1] |= (b&7) << 7;
				break;
			}
			t |= b;
			opa[1] = o->opcode2;
			opa[1] |= (a&7) << 7;
			break;
		}
		if((b & 0170) != 0100) /* dst Fn */
			goto bad;
		t |= a;
		opa[1] = o->opcode3;
		opa[1] |= (b&7) << 7;
		break;

	case 17:	/* floating ea,Fn */
		*op++ = o->opcode1;
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((b & 0170) != 0100) /* dst Fn */
			goto bad;
		if((a & 0170) == 0100) { /* both Fn */
			opa[1] |= (a&7) << 10;
			opa[1] |= (b&7) << 7;
			break;
		}
		t |= a;
		opa[1] = o->opcode2;
		opa[1] |= (b&7) << 7;
		break;

	case 18:	/* floating branchs */
		if(p->to.type != D_BRANCH)
			goto bad;
		v = p->cond->pc - p->pc - 2;
		if(v < -32768L || v >= 32768L)
			goto bad;
		*op++ = v;
		break;

	case 19:	/* floating dec and branch */
		if(p->to.type != D_BRANCH)
			goto bad;
		*op++ = o->opcode1;
		v = p->cond->pc - p->pc - 2;
		if(v < -32768L || v >= 32768L)
			goto bad;
		*op++ = v;
		a = asmea(p, &p->from);
		if((a & 0170) != 0)
			goto bad;
		t |= a;
		break;

	case 20:	/* ftst ea */
		*op++ = o->opcode1;
		if(p->from.type != D_NONE)
			goto bad;
		a = asmea(p, &p->to);
		if((a & 0170) == 0100) { /* Fn */
			opa[1] |= (a&7) << 10;
			break;
		}
		t |= a;
		opa[1] = o->opcode2;
		break;

	case 21:	/* fneg */
		*op++ = o->opcode1;
		if(p->from.type == D_NONE) {
			b = asmea(p, &p->to);
			a = b;
		} else {
			a = asmea(p, &p->from);
			b = asmea(p, &p->to);
		}
		if((b & 0170) != 0100) /* dst Fn */
			goto bad;
		if((a & 0170) == 0100) { /* both Fn */
			opa[1] |= (a&7) << 10;
			opa[1] |= (b&7) << 7;
			break;
		}
		t |= a;
		opa[1] = o->opcode2;
		opa[1] |= (b&7) << 7;
		break;

	case 22:	/* floating cmp Fn,ea */
		*op++ = o->opcode1;
		a = asmea(p, &p->from);
		b = asmea(p, &p->to);
		if((a & 0170) != 0100) /* dst Fn */
			goto bad;
		if((b & 0170) == 0100) { /* both Fn */
			opa[1] |= (b&7) << 10;
			opa[1] |= (a&7) << 7;
			break;
		}
		t |= b;
		opa[1] = o->opcode2;
		opa[1] |= (a&7) << 7;
		break;

	case 23:	/* word, long */
		op = opa;
		a = asmea(p, &p->to);
		if(a == (7<<3)|4)
			return;
		if(a == (7<<3)|1) {
			if(p->as == AWORD) {
				op = opa;
				*op++ = opa[1];
			}
			return;
		}
		if(a == (7<<3)|0) {
			if(p->as == ALONG) {
				*op++ = opa[0];
				opa[0] = 0;
			}
			return;
		}
		goto bad;

	case 24:	/* bit field */
		a = ((p->to.field&31)<<6) | (p->from.field&31);
		if(p->as == ABFINS) {
			b = asmea(p, &p->from);
			if((b&0170) != 0)
				goto bad;
			a |= b<<12;
			*op++ = a;
			a = asmea(p, &p->to);
		} else {
			if(p->to.type != D_NONE) {
				b = asmea(p, &p->to);
				if((b&0170) != 0)
					goto bad;
				a |= b<<12;
			}
			*op++ = a;
			a = asmea(p, &p->from);
		}
		t |= a;
		a &= 0170;
		if(a == 010 || a == 030 || a == 040 || a == 074)
			goto bad;
		break;

	case 25:	/* movem */
		if(p->from.type == D_CONST) { /* registers -> memory */
			asmea(p, &p->from);
			a = asmea(p, &p->to);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 030)
				goto bad;
			t |= a;
			break;
		}
		if(p->to.type == D_CONST) { /* memory -> registers */
			t |= 0x400;
			asmea(p, &p->to);
			a = asmea(p, &p->from);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 040)
				goto bad;
			t |= a;
			break;
		}
		goto bad;

	case 26:	/* chk */
		a = asmea(p, &p->from);
		if((a&0170) == 010)
			goto bad;
		b = asmea(p, &p->to);
		if((b&0170) != 0)
			goto bad;
		t |= a;
		t |= b<<9;
		break;

	case 27:	/* btst */
		a = asmea(p, &p->from);
		if(a == 074) {
			t = o->opcode1;
		} else
		if((a&0170) != 0)
			goto bad;
		b = asmea(p, &p->to);
		if(b == 074 || (b&0170) == 010)
			goto bad;
		t |= b;
		break;

	case 28:	/* fmovem */
		if(p->from.type == D_CONST) { /* registers -> memory */
			b = p->from.u0.s0.offset & 0xff;
			b |= 0xf000;		/* control or postinc */
			*op++ = b;
			a = asmea(p, &p->to);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 030)
				goto bad;
			if(b == 040)
				op[-1] &= ~0x1000;	/* predec */
			t |= a;
			break;
		}
		if(p->to.type == D_CONST) { /* memory -> registers */
			b = p->to.u0.s0.offset & 0xff;
			b |= 0xd000;		/* control or postinc */
			*op++ = b;
			a = asmea(p, &p->from);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 040)
				goto bad;
			t |= a;
			break;
		}
		goto bad;

	case 29:	/* fmovemc */
		if(p->from.type == D_CONST) { /* registers -> memory */
			b = (p->from.u0.s0.offset & 0x7) << 10;
			b |= 0xa000;
			*op++ = b;
			a = asmea(p, &p->to);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 030)
				goto bad;
			t |= a;
			break;
		}
		if(p->to.type == D_CONST) { /* memory -> registers */
			b = (p->to.u0.s0.offset & 0x7) << 10;
			b |= 0x8000;
			*op++ = b;
			a = asmea(p, &p->from);
			if(a == 074)
				goto bad;
			b = a & 0170;
			if(b == 000 || b == 010 || b == 040)
				goto bad;
			t |= a;
			break;
		}
		goto bad;

	case 30:	/* trap */
		if(p->to.type == D_CONST) {
			t |= p->to.u0.s0.offset & 0xf;
			break;
		}
		goto bad;

	case 31:	/* chk2, cmp2 */
		b = asmea(p, &p->to);
		a = b & 0170;
		if(a == 000 || a == 010) {
			*op++ = o->opcode1 | (b << 12);
			t |= asmea(p, &p->from);
			break;
		}
		goto bad;

	case 32:	/* casew */
		/* jmp (0,pc,r0.w*1) */
		casepc = p->pc;
		*op++ = o->opcode1;
		break;

	case 33:	/* bcase */
		q = copyp(p);
		q->as = ADATA;
		q->to.type = D_CONST;
		q->to.u0.s0.offset = p->cond->pc - casepc - 2;
		q->from.u0.s0.displace = 2;
		q->link = datap;
		datap = q;
		if(debug['a'])
			Bprint(&bso, "%P\n", q);
		op = opa;
		return;

	case 34:	/* moves */
		op++;
		a = asmea(p, &p->from);
		b = a & 0170;
		if(b == 0 || b == 010) {
			opa[1] = (a << 12) | 0x800;
			b = asmea(p, &p->to);
			a = b & 0170;
			if(a == 0 || a == 010)
				goto bad;
			t |= b;
			break;
		}
		t |= a;
		b = asmea(p, &p->to);
		a = b & 0170;
		if(a != 0 && a != 010)
			goto bad;
		opa[1] = (b << 12);
		break;

	case 35:	/* swap */
		a = asmea(p, &p->to);
		if((a & 0170) == 0) {
			t |= a;
			break;
		}
		goto bad;
	}
	opa[0] = t;
	return;

bad:
	if(!debug['a'])
		print("%P\n", p);
	diag("bad combination of addressing in %s\n", TNAME);
	opa[0] = 0;
}

int
asmea(Prog *p, Adr *a)
{
	Optab *o;
	int f, t, r, i;
	short *top;
	long v;

	if(a->index != D_NONE)
		goto index;
	t = a->type;
	r = simple[t];
	v = a->u0.s0.offset;
	if(r != 0177) {
		if(v == 0)
			return r;
		if((r & 070) != 020)
			return r;
		if(v >= -32768L && v < 32768L) {
			*op++ = v;
			return t-D_A0-I_INDIR+050;	/* d(Ax) */
		}
		*op++ = 0x170;			/* is, no indirect */
		*op++ = v>>16;
		*op++ = v;
		return t-D_A0-I_INDIR+060;	/* (d,Ax) */
	}
	f = 0;
	if(a == &p->from)
		f++;
	o = &optab[p->as];
	switch(t) {
	case D_TOS:
		if(f) {
			if(o->srcsp)
				return (3<<3) | 7;	/* (A7)+ */
		} else
			if(o->dstsp)
				return (4<<3) | 7;	/* -(A7) */
		return (2<<3) | 7;			/* (A7) */
		
	case D_BRANCH:
		v = p->cond->pc - p->pc - 2;
		if(v < -32768L || v >= 32768L) {
			*op++ = v>>16;
			*op++ = v;
			return 0xff;
		}
		if(v < -128 || v >= 128 || p->mark == 4) {
			*op++ = v;
			return 0;
		}
		return v & 0xff;

	case I_ADDR|D_STATIC:
	case I_ADDR|D_EXTERN:
		t = a->u1.sym->type;
		if(t == 0 || t == SXREF) {
			diag("undefined external: %s in %s\n",
				a->u1.sym->name, TNAME);
			a->u1.sym->type = SDATA;
		}
		v = a->u1.sym->value + a->u0.s0.offset;
		if(t != STEXT)
			v += INITDAT;

	case D_CONST:
		switch(f? o->srcsp: o->dstsp) {
		case 4:
			*op++ = v>>16;

		case 2:
			*op++ = v;
			break;

		default:
			diag("unknown srcsp asmea in %s\n", TNAME);
		}
		return (7<<3) | 4;

	case D_FCONST:
		r = f? o->srcsp: o->dstsp;
		for(i=0; i<r; i++)
			((char*)op)[i] = gnuxi(&a->u0.ieee, i, r);
		op += r/2;
		return (7<<3) | 4;

	case D_QUICK:
		v = a->u0.s0.offset & 0xff;
		return 0110 | (v<<7);
			
	case D_STACK:
	case D_AUTO:
	case D_PARAM:
		if(v == 0)
			return (2<<3) | 7;	/* (A7) */
		if(v >= -32768L && v < 32768L) {
			*op++ = v;
			return (5<<3) | 7;	/* d(A7) */
		}
		*op++ = 0x170;			/* is, no indirect */
		*op++ = v>>16;
		*op++ = v;
		return (6<<3) | 7;		/* (d,A7) */

	case I_INDIR|D_CONST:
		goto adr;

	case D_STATIC:
	case D_EXTERN:
		t = a->u1.sym->type;
		if(t == 0 || t == SXREF) {
			diag("undefined external: %s in %s\n",
				a->u1.sym->name, TNAME);
			a->u1.sym->type = SDATA;
		}
		if(t == STEXT) {
			v = a->u1.sym->value + a->u0.s0.offset;
			*op++ = v>>16;
			*op++ = v;
			return (7<<3) | 1;
		}
		v = a->u1.sym->value + a->u0.s0.offset - A6OFFSET;
		if(debug['6']) {
			v += INITDAT + A6OFFSET;
			goto adr;
		}
		if(v == 0)
			return (2<<3) | 6;
		if(v >= -32768L && v < 32768L) {
			*op++ = v;
			return (5<<3) | 6;
		}
		v += INITDAT + A6OFFSET;

	adr:
		if(v >= -32768L && v < 32768L) {
			*op++ = v;
			return (7<<3) | 0;
		}
		*op++ = v>>16;
		*op++ = v;
		return (7<<3) | 1;
	}
	if(!debug['a'])
		print("%P\n", p);
	diag("unknown addressing mode: %d in %s\n", t, TNAME);
	return 0;

index:
	top = op++;
	t = a->index & D_MASK;
	f = (a->scale & 7) << 9;	/* w/l scale */
	f |= (t & 7) << 12;		/* register */
	if(t < D_R0 || t >= D_R0+8) {
		if(t >= D_A0 && t < D_A0+8) {
			f |= 0x8000;	/* d/a */
		} else
		if(t == D_NONE)
			f = 0x40;	/* is */
		else
			goto bad;
	}

	t = a->type;
	r = t & 7;
	v = a->u0.s0.offset;
	if(t < (I_INDIR|D_A0) || t >= (I_INDIR|(D_A0+8)))
	switch(t) {
	default:
		goto bad;

	case I_INDIR|D_NONE:
		f |= 0x80;		/* bs */
		r = 0;
		break;

	case D_AUTO:
	case D_PARAM:
	case D_STACK:
		r = 7;
		break;

	case D_STATIC:
	case D_EXTERN:
		t = a->u1.sym->type;
		if(t == 0 || t == SXREF) {
			diag("undefined external: %s in %s\n",
				a->u1.sym->name, TNAME);
			a->u1.sym->type = SDATA;
		}
		r = 6;
		v += a->u1.sym->value - A6OFFSET;
		if(t == STEXT) {
			f |= 0x80;	/* bs */
			r = 0;
			v += A6OFFSET;
			goto bdlong;
		}
		if(debug['6']) {
			f |= 0x80;	/* bs */
			r = 0;
			v += INITDAT + A6OFFSET;
		}
	}
	if(v == 0)
		f |= 0x10;		/* bd size = null */
	else
	if(v >= -32768L && v < 32768L) {
		f |= 0x20;		/* bd size = word */
		*op++ = v;
	} else {
	bdlong:
		f |= 0x30;		/* bd size = long */
		*op++ = v>>16;
		*op++ = v;
	}
	v = a->u0.s0.displace;
	t = a->index & I_MASK;
	if(t != I_INDEX1) {		/* non-memory index */
		if(t == I_INDEX2)
			f |= 5;		/* post indexing */
		else
		if(t == I_INDEX3)
			f |= 1;		/* pre indexing */
		else
			goto bad;
	}
	if(v != 0) {
		if(v >= -32768L && v < 32768L) {
			f++;		/* is size = word */
			*op++ = v;
		} else {
			f += 2;		/* is size = long */
			*op++ = v>>16;
			*op++ = v;
		}
	}
	*top = f | 0x100;
	return (6<<3) | r;

bad:
	if(!debug['a'])
		print("%P\n", p);
	diag("bad operand in %s\n", TNAME);
	return 0;
}

void
lput(long l)
{

	CPUT(l>>24)
	CPUT(l>>16)
	CPUT(l>>8)
	CPUT(l)
}

void
s16put(char *n)
{
	char name[16];
	int i;

	strncpy(name, n, sizeof(name));
	for(i=0; i<sizeof(name); i++)
		CPUT(name[i])
}

void
cflush(void)
{
	int n;

	n = sizeof(buf.s0.cbuf) - cbc;
	if(n)
		write(cout, buf.s0.cbuf, n);
	cbp = buf.s0.cbuf;
	cbc = sizeof(buf.s0.cbuf);
}

void
datblk(long s, long n)
{
	Prog *p;
	char *cast;
	long l, fl, j;
	int i, c;

	memset(buf.dbuf, 0, n+100);
	for(p = datap; p != P; p = p->link) {
		curp = p;
		l = p->from.u1.sym->value + p->from.u0.s0.offset - s;
		c = p->from.u0.s0.displace;
		i = 0;
		if(l < 0) {
			if(l+c <= 0)
				continue;
			while(l < 0) {
				l++;
				i++;
			}
		}
		if(l >= n)
			continue;
		for(j=l+(c-i)-1; j>=l; j--)
			if(buf.dbuf[j]) {
				print("%P\n", p);
				diag("multiple initialization\n");
				break;
			}
		switch(p->to.type) {
		case D_FCONST:
			switch(c) {
			default:
			case 4:
				fl = ieeedtof(&p->to.u0.ieee);
				cast = (char*)&fl;
				if(debug['a'] && i == 0) {
					Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
					for(j=0; j<c; j++)
						Bprint(&bso, "%.2ux", cast[fnuxi8[j+4]] & 0xff);
					Bprint(&bso, "\n", curp);
				}
				for(; i<c; i++) {
					buf.dbuf[l] = cast[fnuxi8[i+4]];
					l++;
				}
				break;
			case 8:
				cast = (char*)&p->to.u0.ieee;
				if(debug['a'] && i == 0) {
					Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
					for(j=0; j<c; j++)
						Bprint(&bso, "%.2ux", cast[fnuxi8[j]] & 0xff);
					Bprint(&bso, "\n", curp);
				}
				for(; i<c; i++) {
					buf.dbuf[l] = cast[fnuxi8[i]];
					l++;
				}
				break;
			}
			break;

		case D_SCONST:
			if(debug['a'] && i == 0) {
				Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
				for(j=0; j<c; j++)
					Bprint(&bso, "%.2ux", p->to.u0.scon[j] & 0xff);
				Bprint(&bso, "\n", curp);
			}
			for(; i<c; i++) {
				buf.dbuf[l] = p->to.u0.scon[i];
				l++;
			}
			break;
		default:
			fl = p->to.u0.s0.offset;
			if(p->to.u1.sym) {
				if(p->to.u1.sym->type == STEXT)
					fl += p->to.u1.sym->value;
				if(p->to.u1.sym->type == SDATA)
					fl += p->to.u1.sym->value + INITDAT;
				if(p->to.u1.sym->type == SBSS)
					fl += p->to.u1.sym->value + INITDAT;
			}

			cast = (char*)&fl;
			switch(c) {
			default:
				diag("bad nuxi %d %d\n%P\n", c, i, curp);
				break;
			case 1:
				if(debug['a'] && i == 0) {
					Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
					for(j=0; j<c; j++)
						Bprint(&bso, "%.2ux",cast[inuxi1[j]] & 0xff);
					Bprint(&bso, "\n", curp);
				}
				for(; i<c; i++) {
					buf.dbuf[l] = cast[inuxi1[i]];
					l++;
				}
				break;
			case 2:
				if(debug['a'] && i == 0) {
					Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
					for(j=0; j<c; j++)
						Bprint(&bso, "%.2ux",cast[inuxi2[j]] & 0xff);
					Bprint(&bso, "\n", curp);
				}
				for(; i<c; i++) {
					buf.dbuf[l] = cast[inuxi2[i]];
					l++;
				}
				break;
			case 4:
				if(debug['a'] && i == 0) {
					Bprint(&bso, "%lux:%P\n\t\t", l+s+INITDAT, curp);
					for(j=0; j<c; j++)
						Bprint(&bso, "%.2ux",cast[inuxi4[j]] & 0xff);
					Bprint(&bso, "\n", curp);
				}
				for(; i<c; i++) {
					buf.dbuf[l] = cast[inuxi4[i]];
					l++;
				}
				break;
			}
			break;
		}
	}
	write(cout, buf.dbuf, n);
}

int
gnuxi(Ieee *d, int i, int c)
{
	char *p;
	long l;

	switch(c) {
	default:
		diag("bad nuxi %d %d\n%P\n", c, i, curp);
		return 0;
	
		/*
		 * 2301 vax
		 * 0123 68k
		 */
	case 4:
		l = ieeedtof(d);
		p = (char*)&l;
		i = gnuxi8[i+4];
		break;

		/*
		 * 67452301 vax
		 * 45670123 68k
		 */
	case 8:
		p = (char*)d;
		i = gnuxi8[i];
		break;
	}
	return p[i];
}

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;
}