shithub: purgatorio

ref: a411870ee4640241e3c494367d922847da84f972
dir: /limbo/gen.c/

#include "limbo.h"

static	int	addrmode[Rend] =
{
	/* Rreg */	Afp,
	/* Rmreg */	Amp,
	/* Roff */	Aoff,
	/* Rnoff */	Anoff,
	/* Rdesc */	Adesc,
	/* Rdescp */	Adesc,
	/* Rconst */	Aimm,
	/* Ralways */	Aerr,
	/* Radr */	Afpind,
	/* Rmadr */	Ampind,
	/* Rcant */	Aerr,
	/* Rpc */	Apc,
	/* Rmpc */	Aerr,
	/* Rareg */	Aerr,
	/* Ramreg */	Aerr,
	/* Raadr */	Aerr,
	/* Ramadr */	Aerr,
	/* Rldt */	Aldt,
};

static	Decl	*wtemp;
static	Decl	*bigtemp;
static	int	ntemp;
static	Node	retnode;
static	Inst	zinst;

	int	*blockstack;
	int	blockdep;
	int	nblocks;
static	int	lenblockstack;
static	Node	*ntoz;

static Inst* genfixop(Src *src, int op, Node *s, Node *m, Node *d);

void
genstart(void)
{
	Decl *d;

	d = mkdecl(&nosrc, Dlocal, tint);
	d->sym = enter(".ret", 0);
	d->offset = IBY2WD * REGRET;

	retnode = znode;
	retnode.op = Oname;
	retnode.addable = Rreg;
	retnode.decl = d;
	retnode.ty = tint;

	zinst.op = INOP;
	zinst.sm = Anone;
	zinst.dm = Anone;
	zinst.mm = Anone;

	firstinst = allocmem(sizeof *firstinst);
	*firstinst = zinst;
	lastinst = firstinst;

	blocks = -1;
	blockdep = 0;
	nblocks = 0;
}

/*
 * manage nested control flow blocks
 */
int
pushblock(void)
{
	if(blockdep >= lenblockstack){
		lenblockstack = blockdep + 32;
		blockstack = reallocmem(blockstack, lenblockstack * sizeof *blockstack);
	}
	blockstack[blockdep++] = blocks;
	return blocks = nblocks++;
}

void
repushblock(int b)
{
	blockstack[blockdep++] = blocks;
	blocks = b;
}

void
popblock(void)
{
	blocks = blockstack[blockdep -= 1];
}

void
tinit(void)
{
	wtemp = nil;
	bigtemp = nil;
}

Decl*
tdecls(void)
{
	Decl *d;

	for(d = wtemp; d != nil; d = d->next){
		if(d->tref != 1)
			fatal("temporary %s has %d references", d->sym->name, d->tref-1);
	}

	for(d = bigtemp; d != nil; d = d->next){
		if(d->tref != 1)
			fatal("temporary %s has %d references", d->sym->name, d->tref-1);
	}

	return appdecls(wtemp, bigtemp);
}

Node*
talloc(Node *n, Type *t, Node *nok)
{
	Decl *d, *ok;
	Desc *desc;
	char buf[StrSize];

	ok = nil;
	if(nok != nil)
		ok = nok->decl;
	if(ok == nil || ok->tref == 0 || tattr[ok->ty->kind].big != tattr[t->kind].big || ok->ty->align != t->align)
		ok = nil;
	*n = znode;
	n->op = Oname;
	n->addable = Rreg;
	n->ty = t;
	if(tattr[t->kind].big){
		desc = mktdesc(t);
		if(ok != nil && ok->desc == desc){
			ok->tref++;
			ok->refs++;
			n->decl = ok;
			return n;
		}
		for(d = bigtemp; d != nil; d = d->next){
			if(d->tref == 1 && d->desc == desc && d->ty->align == t->align){
				d->tref++;
				d->refs++;
				n->decl = d;
				return n;
			}
		}
		d = mkdecl(&nosrc, Dlocal, t);
		d->desc = desc;
		d->tref = 2;
		d->refs = 1;
		n->decl = d;
		seprint(buf, buf+sizeof(buf), ".b%d", ntemp++);
		d->sym = enter(buf, 0);
		d->next = bigtemp;
		bigtemp = d;
		return n;
	}
	if(ok != nil
	&& tattr[ok->ty->kind].isptr == tattr[t->kind].isptr
	&& ok->ty->size == t->size){
		ok->tref++;
		n->decl = ok;
		return n;
	}
	for(d = wtemp; d != nil; d = d->next){
		if(d->tref == 1
		&& tattr[d->ty->kind].isptr == tattr[t->kind].isptr
		&& d->ty->size == t->size
		&& d->ty->align == t->align){
			d->tref++;
			n->decl = d;
			return n;
		}
	}
	d = mkdecl(&nosrc, Dlocal, t);
	d->tref = 2;
	d->refs = 1;
	n->decl = d;
	seprint(buf, buf+sizeof(buf), ".t%d", ntemp++);
	d->sym = enter(buf, 0);
	d->next = wtemp;
	wtemp = d;
	return n;
}

void
tfree(Node *n)
{
	if(n == nil || n->decl == nil || n->decl->tref == 0)
		return;
	if(n->decl->tref == 1)
		fatal("double free of temporary %s", n->decl->sym->name);
	if (--n->decl->tref == 1)
		zcom1(n, nil);
}

void
tfreelater(Node *n)
{
	if(n == nil || n->decl == nil || n->decl->tref == 0)
		return;
	if(n->decl->tref == 1)
		fatal("double free of temporary %s", n->decl->sym->name);
	if(--n->decl->tref == 1){
		Node *nn = mkn(Oname, nil, nil);

		*nn = *n;
		nn->left = ntoz;
		ntoz = nn;
		n->decl->tref++;
	}
}

void
tfreenow()
{
	Node *n, *nn;

	for(n = ntoz; n != nil; n = nn){
		nn = n->left;
		n->left = nil;
		if(n->decl->tref != 2)
			fatal("bad free of temporary %s", n->decl->sym->name);
		--n->decl->tref;
		zcom1(n, nil);
	}
	ntoz = nil;
}

/*
 * realloc a temporary after it's been freed
 */
Node*
tacquire(Node *n)
{
	if(n == nil || n->decl == nil || n->decl->tref == 0)
		return n;
/*
	if(n->decl->tref != 1)
		fatal("tacquire ref != 1: %d", n->decl->tref);
*/
	n->decl->tref++;
	return n;
}

void
trelease(Node *n)
{
	if(n == nil || n->decl == nil || n->decl->tref == 0)
		return;
	if(n->decl->tref == 1)
		fatal("double release of temporary %s", n->decl->sym->name);
	n->decl->tref--;
}

Inst*
mkinst(void)
{
	Inst *in;

	in = lastinst->next;
	if(in == nil){
		in = allocmem(sizeof *in);
		*in = zinst;
		lastinst->next = in;
	}
	lastinst = in;
	in->block = blocks;
	if(blocks < 0)
		fatal("mkinst no block");
	return in;
}

Inst*
nextinst(void)
{
	Inst *in;

	in = lastinst->next;
	if(in != nil)
		return in;
	in = allocmem(sizeof(*in));
	*in = zinst;
	lastinst->next = in;
	return in;
}

/*
 * allocate a node for returning
 */
Node*
retalloc(Node *n, Node *nn)
{
	if(nn->ty == tnone)
		return nil;
	*n = znode;
	n->op = Oind;
	n->addable = Radr;
	n->left = dupn(1, &n->src, &retnode);
	n->ty = nn->ty;
	return n;
}

Inst*
genrawop(Src *src, int op, Node *s, Node *m, Node *d)
{
	Inst *in;

	in = mkinst();
	in->op = op;
	in->src = *src;
if(in->sm != Anone || in->mm != Anone || in->dm != Anone)
fatal("bogus mkinst in genrawop: %I\n", in);
	if(s != nil){
		in->s = genaddr(s);
		in->sm = addrmode[s->addable];
	}
	if(m != nil){
		in->m = genaddr(m);
		in->mm = addrmode[m->addable];
		if(in->mm == Ampind || in->mm == Afpind)
			fatal("illegal addressing mode in register %n", m);
	}
	if(d != nil){
		in->d = genaddr(d);
		in->dm = addrmode[d->addable];
	}
	return in;
}

Inst*
genop(Src *src, int op, Node *s, Node *m, Node *d)
{
	Inst *in;
	int iop;

	iop = disoptab[op][opind[d->ty->kind]];
	if(iop == 0)
		fatal("can't deal with op %s on %n %n %n in genop", opname[op], s, m, d);
	if(iop == IMULX || iop == IDIVX)
		return genfixop(src, iop, s, m, d);
	in = mkinst();
	in->op = iop;
	in->src = *src;
	if(s != nil){
		in->s = genaddr(s);
		in->sm = addrmode[s->addable];
	}
	if(m != nil){
		in->m = genaddr(m);
		in->mm = addrmode[m->addable];
		if(in->mm == Ampind || in->mm == Afpind)
			fatal("illegal addressing mode in register %n", m);
	}
	if(d != nil){
		in->d = genaddr(d);
		in->dm = addrmode[d->addable];
	}
	return in;
}

Inst*
genbra(Src *src, int op, Node *s, Node *m)
{
	Type *t;
	Inst *in;
	int iop;

	t = s->ty;
	if(t == tany)
		t = m->ty;
	iop = disoptab[op][opind[t->kind]];
	if(iop == 0)
		fatal("can't deal with op %s on %n %n in genbra", opname[op], s, m);
	in = mkinst();
	in->op = iop;
	in->src = *src;
	if(s != nil){
		in->s = genaddr(s);
		in->sm = addrmode[s->addable];
	}
	if(m != nil){
		in->m = genaddr(m);
		in->mm = addrmode[m->addable];
		if(in->mm == Ampind || in->mm == Afpind)
			fatal("illegal addressing mode in register %n", m);
	}
	return in;
}

Inst*
genchan(Src *src, Node *sz, Type *mt, Node *d)
{
	Inst *in;
	Desc *td;
	Addr reg;
	int op, regm;

	regm = Anone;
	reg.decl = nil;
	reg.reg = 0;
	reg.offset = 0;
	op = chantab[mt->kind];
	if(op == 0)
		fatal("can't deal with op %d in genchan", mt->kind);

	switch(mt->kind){
	case Tadt:
	case Tadtpick:
	case Ttuple:
		td = mktdesc(mt);
		if(td->nmap != 0){
			op++;		/* sleazy */
			usedesc(td);
			regm = Adesc;
			reg.decl = mt->decl;
		}else{
			regm = Aimm;
			reg.offset = mt->size;
		}
		break;
	}
	in = mkinst();
	in->op = op;
	in->src = *src;
	in->s = reg;
	in->sm = regm;
	if(sz != nil){
		in->m = genaddr(sz);
		in->mm = addrmode[sz->addable];
	}
	if(d != nil){
		in->d = genaddr(d);
		in->dm = addrmode[d->addable];
	}
	return in;
}

Inst*
genmove(Src *src, int how, Type *mt, Node *s, Node *d)
{
	Inst *in;
	Desc *td;
	Addr reg;
	int op, regm;

	regm = Anone;
	reg.decl = nil;
	reg.reg = 0;
	reg.offset = 0;
	op = movetab[how][mt->kind];
	if(op == 0)
		fatal("can't deal with op %d on %n %n in genmove", how, s, d);

	switch(mt->kind){
	case Tadt:
	case Tadtpick:
	case Ttuple:
	case Texception:
		if(mt->size == 0 && how == Mas)
			return nil;
		td = mktdesc(mt);
		if(td->nmap != 0){
			op++;		/* sleazy */
			usedesc(td);
			regm = Adesc;
			reg.decl = mt->decl;
		}else{
			regm = Aimm;
			reg.offset = mt->size;
		}
		break;
	}
	in = mkinst();
	in->op = op;
	in->src = *src;
	if(s != nil){
		in->s = genaddr(s);
		in->sm = addrmode[s->addable];
	}
	in->m = reg;
	in->mm = regm;
	if(d != nil){
		in->d = genaddr(d);
		in->dm = addrmode[d->addable];
	}
	if(s->addable == Rpc)
		in->op = IMOVPC;
	return in;
}

void
patch(Inst *b, Inst *dst)
{
	Inst *n;

	for(; b != nil; b = n){
		n = b->branch;
		b->branch = dst;
	}
}

long
getpc(Inst *i)
{
	if(i->pc == 0 && i != firstinst && (firstinst->op != INOOP || i != firstinst->next)){
		do
			i = i->next;
		while(i != nil && i->pc == 0);
		if(i == nil || i->pc == 0)
			fatal("bad instruction in getpc");
	}
	return i->pc;
}

/*
 * follow all possible paths from n,
 * marking reached code, compressing branches, and reclaiming unreached insts
 */
void
reach(Inst *in)
{
	Inst *last;

	foldbranch(in);
	last = in;
	for(in = in->next; in != nil; in = in->next){
		if(!in->reach)
			last->next = in->next;
		else
			last = in;
	}
	lastinst = last;
}

/*
 * follow all possible paths from n,
 * marking reached code, compressing branches, and eliminating tail recursion
 */
void
foldbranch(Inst *in)
{
	Inst *b, *next;
	Label *lab;
	int i, n;

	while(in != nil && !in->reach){
		in->reach = 1;
		if(in->branch != nil)
			while(in->branch->op == IJMP){
				if(in == in->branch || in->branch == in->branch->branch)
					break;
				in->branch = in->branch->branch;
			}
		switch(in->op){
		case IGOTO:
		case ICASE:
		case ICASEL:
		case ICASEC:
		case IEXC:
			foldbranch(in->d.decl->ty->cse->iwild);
			lab = in->d.decl->ty->cse->labs;
			n = in->d.decl->ty->cse->nlab;
			for(i = 0; i < n; i++)
				foldbranch(lab[i].inst);
			if(in->op == IEXC)
				in->op = INOOP;
			return;
		case IEXC0:
			foldbranch(in->branch);
			in->op = INOOP;
			break;
		case IRET:
		case IEXIT:
		case IRAISE:
			return;
		case IJMP:
			b = in->branch;
			switch(b->op){
			case ICASE:
			case ICASEL:
			case ICASEC:
			case IRET:
			case IEXIT:
				next = in->next;
				*in = *b;
				in->next = next;
				continue;
			}
			foldbranch(b);
			return;
		default:
			if(in->branch != nil)
				foldbranch(in->branch);
			break;
		}

		in = in->next;
	}
}

/*
 * convert the addressable node into an operand
 * see the comment for sumark
 */
Addr
genaddr(Node *n)
{
	Addr a;

	a.reg = 0;
	a.offset = 0;
	a.decl = nil;
	if(n == nil)
		return a;
	switch(n->addable){
	case Rreg:
		if(n->decl != nil)
			a.decl = n->decl;
		else
			a = genaddr(n->left);
		break;
	case Rmreg:
		if(n->decl != nil)
			a.decl = n->decl;
		else
			a = genaddr(n->left);
		break;
	case Rdesc:
		a.decl = n->ty->decl;
		break;
	case Roff:
	case Rnoff:
		a.decl = n->decl;
		break;
	case Rconst:
		a.offset = n->val;
		break;
	case Radr:
		a = genaddr(n->left);
		break;
	case Rmadr:
		a = genaddr(n->left);
		break;
	case Rareg:
	case Ramreg:
		a = genaddr(n->left);
		if(n->op == Oadd)
			a.reg += n->right->val;
		break;
	case Raadr:
	case Ramadr:
		a = genaddr(n->left);
		if(n->op == Oadd)
			a.offset += n->right->val;
		break;
	case Rldt:
		a.decl = n->decl;
		break;
	case Rdescp:
	case Rpc:
		a.decl = n->decl;
		break;
	default:
		fatal("can't deal with %n in genaddr", n);
		break;
	}
	return a;
}

int
sameaddr(Node *n, Node *m)
{
	Addr a, b;

	if(n->addable != m->addable)
		return 0;
	a = genaddr(n);
	b = genaddr(m);
	return a.offset == b.offset && a.reg == b.reg && a.decl == b.decl;
}

long
resolvedesc(Decl *mod, long length, Decl *decls)
{
	Desc *g, *d, *last;
	int descid;

	g = gendesc(mod, length, decls);
	g->used = 0;
	last = nil;
	for(d = descriptors; d != nil; d = d->next){
		if(!d->used){
			if(last != nil)
				last->next = d->next;
			else
				descriptors = d->next;
			continue;
		}
		last = d;
	}

	g->next = descriptors;
	descriptors = g;

	descid = 0;
	for(d = descriptors; d != nil; d = d->next)
		d->id = descid++;
	if(g->id != 0)
		fatal("bad global descriptor id");

	return descid;
}

int
resolvemod(Decl *m)
{
	Decl *id, *d;

	for(id = m->ty->ids; id != nil; id = id->next){
		switch(id->store){
		case Dfn:
			id->iface->pc = id->pc;
			id->iface->desc = id->desc;
if(debug['v']) print("R1: %s %p %p %p\n", id->sym->name, id, id->iface, id->pc);
			break;
		case Dtype:
			if(id->ty->kind != Tadt)
				break;
			for(d = id->ty->ids; d != nil; d = d->next){
				if(d->store == Dfn){
					d->iface->pc = d->pc;
					d->iface->desc = d->desc;
if(debug['v']) print("R2: %s %p %p %p\n", d->sym->name, d, d->iface, d->pc);
				}
			}
			break;
		}
	}
	/* for addiface */
	for(id = m->ty->tof->ids; id != nil; id = id->next){
		if(id->store == Dfn){
			if(id->pc == nil)
				id->pc = id->iface->pc;
			if(id->desc == nil)
				id->desc = id->iface->desc;
if(debug['v']) print("R3: %s %p %p %p\n", id->sym->name, id, id->iface, id->pc);
		}
	}
	return m->ty->tof->decl->init->val;
}

/*
 * place the Tiface decs in another list
 */
Decl*
resolveldts(Decl *d, Decl **dd)
{
	Decl *d1, *ld1, *d2, *ld2, *n;

	d1 = d2 = nil;
	ld1 = ld2 = nil;
	for( ; d != nil; d = n){
		n = d->next;
		d->next = nil;
		if(d->ty->kind == Tiface){
			if(d2 == nil)
				d2 = d;
			else
				ld2->next = d;
			ld2 = d;
		}
		else{
			if(d1 == nil)
				d1 = d;
			else
				ld1->next = d;
			ld1 = d;
		}
	}
	*dd = d2;
	return d1;
}

/*
 * fix up all pc's
 * finalize all data offsets
 * fix up instructions with offsets too large
 */
long
resolvepcs(Inst *inst)
{
	Decl *d;
	Inst *in;
	int op;
	ulong r, off;
	long v, pc;

	pc = 0;
	for(in = inst; in != nil; in = in->next){
		if(!in->reach || in->op == INOP)
			fatal("unreachable pc: %I %ld", in, pc);
		if(in->op == INOOP){
			in->pc = pc;
			continue;
		}
		d = in->s.decl;
		if(d != nil){
			if(in->sm == Adesc){
				if(d->desc != nil)
					in->s.offset = d->desc->id;
			}else
				in->s.reg += d->offset;
		}
		r = in->s.reg;
		off = in->s.offset;
		if((in->sm == Afpind || in->sm == Ampind)
		&& (r >= MaxReg || off >= MaxReg))
			fatal("big offset in %I\n", in);

		d = in->m.decl;
		if(d != nil){
			if(in->mm == Adesc){
				if(d->desc != nil)
					in->m.offset = d->desc->id;
			}else
				in->m.reg += d->offset;
		}
		v = 0;
		switch(in->mm){
		case Anone:
			break;
		case Aimm:
		case Apc:
		case Adesc:
			v = in->m.offset;
			break;
		case Aoff:
		case Anoff:
			v = in->m.decl->iface->offset;
			break;
		case Afp:
		case Amp:
		case Aldt:
			v = in->m.reg;
			if(v < 0)
				v = 0x8000;
			break;

		default:
			fatal("can't deal with %I's m mode\n", in);
			break;
		}
		if(v > 0x7fff || v < -0x8000){
			switch(in->op){
			case IALT:
			case IINDX:
warn(in->src.start, "possible bug: temp m too big in %I: %ld %ld %d\n", in, in->m.reg, in->m.reg, MaxReg);
				rewritedestreg(in, IMOVW, RTemp);
				break;
			default:
				op = IMOVW;
				if(isbyteinst[in->op])
					op = IMOVB;
				in = rewritesrcreg(in, op, RTemp, pc++);
				break;
			}
		}

		d = in->d.decl;
		if(d != nil){
			if(in->dm == Apc)
				in->d.offset = d->pc->pc;
			else
				in->d.reg += d->offset;
		}
		r = in->d.reg;
		off = in->d.offset;
		if((in->dm == Afpind || in->dm == Ampind)
		&& (r >= MaxReg || off >= MaxReg))
			fatal("big offset in %I\n", in);

		in->pc = pc;
		pc++;
	}
	for(in = inst; in != nil; in = in->next){
		d = in->s.decl;
		if(d != nil && in->sm == Apc)
			in->s.offset = d->pc->pc;
		d = in->d.decl;
		if(d != nil && in->dm == Apc)
			in->d.offset = d->pc->pc;
		if(in->branch != nil){
			in->dm = Apc;
			in->d.offset = in->branch->pc;
		}
	}
	return pc;
}

/*
 * fixp up a big register constant uses as a source
 * ugly: smashes the instruction
 */
Inst*
rewritesrcreg(Inst *in, int op, int treg, int pc)
{
	Inst *new;
	Addr a;
	int am;

	a = in->m;
	am = in->mm;
	in->mm = Afp;
	in->m.reg = treg;
	in->m.decl = nil;

	new = allocmem(sizeof(*in));
	*new = *in;

	*in = zinst;
	in->src = new->src;
	in->next = new;
	in->op = op;
	in->s = a;
	in->sm = am;
	in->dm = Afp;
	in->d.reg = treg;
	in->pc = pc;
	in->reach = 1;
	in->block = new->block;
	return new;
}

/*
 * fix up a big register constant by moving to the destination
 * after the instruction completes
 */
Inst*
rewritedestreg(Inst *in, int op, int treg)
{
	Inst *n;

	n = allocmem(sizeof(*n));
	*n = zinst;
	n->next = in->next;
	in->next = n;
	n->src = in->src;
	n->op = op;
	n->sm = Afp;
	n->s.reg = treg;
	n->d = in->m;
	n->dm = in->mm;
	n->reach = 1;
	n->block = in->block;

	in->mm = Afp;
	in->m.reg = treg;
	in->m.decl = nil;

	return n;
}

int
instconv(Fmt *f)
{
	Inst *in;
	char buf[512], *p;
	char *op, *comma;

	in = va_arg(f->args, Inst*);
	op = nil;
	if(in->op < MAXDIS)
		op = instname[in->op];
	if(op == nil)
		op = "??";
	buf[0] = '\0';
	if(in->op == INOP)
		return fmtstrcpy(f, "\tnop");
	p = seprint(buf, buf + sizeof(buf), "\t%s\t", op);
	comma = "";
	if(in->sm != Anone){
		p = addrprint(p, buf + sizeof(buf), in->sm, &in->s);
		comma = ",";
	}
	if(in->mm != Anone){
		p = seprint(p, buf + sizeof(buf), "%s", comma);
		p = addrprint(p, buf + sizeof(buf), in->mm, &in->m);
		comma = ",";
	}
	if(in->dm != Anone){
		p = seprint(p, buf + sizeof(buf), "%s", comma);
		p = addrprint(p, buf + sizeof(buf), in->dm, &in->d);
	}
	
	if(asmsym && in->s.decl != nil && in->sm == Adesc)
		p = seprint(p, buf+sizeof(buf), "	#%D", in->s.decl);
	if(0 && asmsym && in->m.decl != nil)
		p = seprint(p, buf+sizeof(buf), "	#%D", in->m.decl);
	if(asmsym && in->d.decl != nil && in->dm == Apc)
		p = seprint(p, buf+sizeof(buf), "	#%D", in->d.decl);
	if(asmsym)
		p = seprint(p, buf+sizeof(buf), "	#%U", in->src);
	USED(p);
	return fmtstrcpy(f, buf);
}

char*
addrprint(char *buf, char *end, int am, Addr *a)
{
	switch(am){
	case Anone:
		return buf;
	case Aimm:
	case Apc:
	case Adesc:
		return seprint(buf, end, "$%ld", a->offset);
	case Aoff:
		return seprint(buf, end, "$%ld", a->decl->iface->offset);
	case Anoff:
		return seprint(buf, end, "-$%ld", a->decl->iface->offset);
	case Afp:
		return seprint(buf, end, "%ld(fp)", a->reg);
	case Afpind:
		return seprint(buf, end, "%ld(%ld(fp))", a->offset, a->reg);
	case Amp:
		return seprint(buf, end, "%ld(mp)", a->reg);
	case Ampind:
		return seprint(buf, end, "%ld(%ld(mp))", a->offset, a->reg);
	case Aldt:
		return seprint(buf, end, "$%ld", a->reg);
	case Aerr:
	default:
		return seprint(buf, end, "%ld(%ld(?%d?))", a->offset, a->reg, am);
	}
}

static void
genstore(Src *src, Node *n, int offset)
{
	Decl *de;
	Node d;

	de = mkdecl(&nosrc, Dlocal, tint);
	de->sym = nil;
	de->offset = offset;

	d = znode;
	d.op = Oname;
	d.addable = Rreg;
	d.decl = de;
	d.ty = tint;
	genrawop(src, IMOVW, n, nil, &d);
}

static Inst*
genfixop(Src *src, int op, Node *s, Node *m, Node *d)
{
	int p, a;
	Node *mm;
	Inst *i;

	mm = m ? m: d;
	op = fixop(op, mm->ty, s->ty, d->ty, &p, &a);
	if(op == IMOVW){	/* just zero d */
		s = sumark(mkconst(src, 0));
		return genrawop(src, op, s, nil, d);
	}
	if(op != IMULX && op != IDIVX)
		genstore(src, sumark(mkconst(src, a)), STemp);
	genstore(src, sumark(mkconst(src, p)), DTemp);
	i =  genrawop(src, op, s, m, d);
	return i;
}

Inst*
genfixcastop(Src *src, int op, Node *s, Node *d)
{
	int p, a;
	Node *m;

	op = fixop(op, s->ty, tint, d->ty, &p, &a);
	if(op == IMOVW){	/* just zero d */
		s = sumark(mkconst(src, 0));
		return genrawop(src, op, s, nil, d);
	}
	m = sumark(mkconst(src, p));
	if(op != ICVTXX)
		genstore(src, sumark(mkconst(src, a)), STemp);
	return genrawop(src, op, s, m, d);
}