#ifndef lint
static char sccsid[] = "@(#)c22.c	1.9 (Berkeley/CCI) 05/12/88";
#endif

/*
 * C object code improver-- third part
 */

#include "c2.h"
#include <stdio.h>
#include <ctype.h>

rmove()
{
	register struct node *p;
	register int r, r1;

	clearreg();
	for (p=first.forw; p!=0; p = p->forw) {
	if (debug) {
		printf("Regs: ");
		for (r=0; r<=NREG; r++)
			if (regs[r][0]) {
				r1=regs[r][0];
				printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1);
			}
		printf("-\n");
	}
	switch (p->op) {

	case CVT:
	case MOVZ:
		splitrand(p);
		repladdr(p);
		r = isreg(regs[RT1]);
		r1 = isreg(regs[RT2]);
		dest(regs[RT2],p->subop, p->op!=CVT || r<0);
		if (r>=0 && r1>=0) {
			p->op = MOV; p->subop = LONG;
			p->pop = 0;
			nchange++;
			goto case_mov;
		}
		if(p->op == CVT) {
			if (r1>=0) savereg(r1, regs[RT1], p->subop);
		} else
			ccloc[0] = 0;
		break;

	case MOV:
	case_mov:
		splitrand(p);
		if ((r = findrand(regs[RT1],p->subop)) >= 0) {
			if (r == isreg(regs[RT2]))
				if(p->forw->op!=CBR) {
					delnode(p); redunm++; nchange++; break;
				} else {
					p->op=TST; p->pop=0;
					while(*p->code++ != ',');
					redunm++; nchange++;
					goto case_tst;
				}
		}
		repladdr(p);
		r = isreg(regs[RT1]);
		r1 = isreg(regs[RT2]);
		dest(regs[RT2],p->subop, 1);
		if ((regs[ACC][0]) && equstr(regs[RT2],regs[ACC]+1))
			*(short *)(regs[ACC]) = 0;
		if (r>=0) {
			if (r1>=0) {
				if (r == r1 && p->forw->op!=CBR) {
					delnode(p); redunm++; nchange++;
					break;
				}
				if(regs[r][0])
					savereg(r1, regs[r]+1, p->subop);
			} else
				savereg(r, regs[RT2], p->subop);
		} else if (r1>=0)
			savereg(r1, regs[RT1], p->subop);
		else
			setcon(regs[RT1], regs[RT2], p->subop);
		break;

/* .rx,.wx or .rx,.rx,.wx */
	case ADD:
	case SUB:
	case AND:
	case OR:
	case XOR:
	case MUL:
	case DIV:
#ifdef EMOD
	case EDIV:
	case EMOD:
#endif EMOD
	case SHAL:
	case SHAR:
	case SHL:
	case SHR:
	case ADDA:
	case SUBA:
/* .rx,.wx */
	case MFPR:
	case COM:
	case NEG:
		splitrand(p);
		repladdr(p);
		dest(lastrand,p->subop, p->op!=ADDA && p->op!=SUBA);
		break;

/* .mx or .wx */
	case STF:
		if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) {
			delnode(p);
			nst++; nchange++; break;
		}
		savereg(ACC, p->code, p->subop);
	case INC:
	case DEC:
	case CVFL:
		dest(p->code,p->subop, 1);
		break;

	case CLR:
		dest(p->code,p->subop, 1);
		if ((regs[ACC][0]) && equstr(p->code,regs[ACC]+1))
			*(short *)(regs[ACC]) = 0;
		if ((r = isreg(p->code)) < 0)
			setcon("$0", p->code, p->subop);
		else
			savereg(r, "$0", p->subop);
		break;

/* .rx */
	case LDF:
		if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) {
			delnode(p);
			nld++; nchange++; break;
		}
		savereg(ACC, p->code, p->subop);
		goto case_tst;
	case LNF:
		if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) {
			p->op = NEGF; p->pop = 0; p->code = 0;
			regs[ACC][0] = 0;
			break;
		}
	case CVLF:
	case LDFD:
	case ADDF:
	case SUBF:
	case MULF:
	case DIVF:
		regs[ACC][0] = 0;
	case TST:
	case_tst:
	case PUSH:
		splitrand(p);
		lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */
		repladdr(p);
		lastrand=regs[RT1];
		if (p->op==TST && equstr(lastrand, ccloc+1)
		  && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))) {
			delnode(p); nrtst++; nchange++; break;
		}
		if (p->op==PUSH && p->subop!=LONG &&
		 (isreg(lastrand)>=0 || *lastrand=='$')) {
			p->subop = LONG;
			p->pop = 0;
			nchange++;
		}
		if (p->op==TST || p->op==PUSH)
			setcc(lastrand,p->subop);
		break;

/* .rx,.rx,.rx */
	case PROBE:
	case CASE:
/* .rx,.rx */
	case MTPR:
	case CALLS:
	case CALLF:
	case CMP:
	case BIT:
	case CMPF:
	case CMPF2:
		splitrand(p);
		/* fool repladdr into doing right number of operands */
		lastrand=byondrd(p);
		if (p->op==CALLF || p->op==CALLS) clearreg();
		else repladdr(p);
	case TSTF:
		ccloc[0]=0;
	case PUSHD:
		break;

/* acc only */
	case CVDF:
	case NEGF:
	case SINF:
	case COSF:
	case ATANF:
	case LOGF:
	case SQRTF:
	case EXPF:
		regs[ACC][0] = 0;
		break;

#ifndef EMOD
/* .rx,.rx,.wx,.wx */
	case EDIV:
		splitrand(p);
		lastrand = regs[RT3];
		repladdr(p);
		dest(regs[RT3], p->subop, 1);
		dest(regs[RT4], p->subop, 0);
		break;
#endif EMOD

/* .rx,.rx,.rx,wx */
	case EMUL:
		splitrand(p);
		lastrand = regs[RT4];
		repladdr(p);
		dest(regs[RT4],QUAD, 1); /* fourth operand is a quad */
		break;
	case CBR:
		if (p->subop>=JBC) {
			splitrand(p);
			lastrand=regs[RT3]; /* 2 operands can be optimized */
			repladdr(p);
			ccloc[0] = 0;
		} else
			reduncbr(p);
		break;

	case JBR:
		redunbr(p);

	default:
		clearreg();
	}
	}
}

jumpsw()
{
	register struct node *p, *p1, *pt;
	register int t, nj;

	t = 0;
	nj = 0;
	for (p=first.forw; p!=0; p = p->forw)
		p->seq = ++t;
	for (p=first.forw; p!=0; p = p1) {
		p1 = p->forw;
		if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
		 && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) {
			if (p->ref==p1->ref)
				continue;
			p->subop = revbr[p->subop];
			p->pop=0;
			pt = p1->ref;
			p1->ref = p->ref;
			p->ref = pt;
			t = p1->labno;
			p1->labno = p->labno;
			p->labno = t;
#ifdef COPYCODE
			if (p->labno == 0) {
				pt = (struct node *)p1->code; p1->code = p->code; p->code = (char *)pt;
			}
#endif
			nrevbr++;
			nj++;
		}
	}
	return(nj);
}

addaob()
{
	register struct node *p, *p1, *p2, *p3;

	for (p = &first; (p1 = p->forw)!=0; p = p1) {
	if (p->op==INC && p->subop==LONG) {
		if (p1->op==LABEL && p1->refc==1 && p1->forw->op==CMP && p1->forw->subop==LONG
		  && (p2=p1->forw->forw)->op==CBR && p2->subop==JLE
		  && (p3=p2->ref->back)->op==JBR && p3->subop==0 && p3->ref==p1
		  && p3->forw->op==LABEL && p3->forw==p2->ref) {
			/* change	INC LAB: CMP	to	LAB: INC CMP */
			p->back->forw=p1; p1->back=p->back;
			p->forw=p1->forw; p1->forw->back=p;
			p->back=p1; p1->forw=p;
			p1=p->forw;
			/* adjust beginning value by 1 */
			p2=alloc(sizeof first); p2->op = DEC; p2->subop = LONG;
			p2->pop=0;
			p2->forw=p3; p2->back=p3->back; p3->back->forw=p2;
			p3->back=p2; p2->code=p->code; p2->labno=0;
		}
		if (p1->op==CMP && p1->subop==LONG &&
		  (p2=p1->forw)->op==CBR && p2->forw->op!=CBR) {
			register char *cp1,*cp2;
			splitrand(p1); if (!equstr(p->code,regs[RT1])) continue;
			if ((p2->subop==JLE || p2->subop==JLT) &&
			    checkaobdisp(p2)){
				if (p2->subop==JLE) p->op = AOBLEQ; else p->op = AOBLSS; p->subop = 0;
				cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
				cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */
				p->pop=0; newcode(p);
				p->labno = p2->labno; delnode(p2); delnode(p1); naob++;
			}
		}
	}
	}
}

ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
	register int log;
	if (n==0 || n&(n-1)) return(-1); log=0;
	for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
}

equop(p1, p2)
register struct node *p1, *p2;
{
	register char *cp1, *cp2;

	if (p1->op != p2->op || p1->subop != p2->subop)
		return(0);
	if (p1->op == NIL && p1->subop == 0 && p1->pop != p2->pop)
		return(0);
	if (p1->op != NIL && ord(p1->op) < ord(MOV))
		return(0);
	switch (p1->op) {
	case EROU:	case JSW:	case TEXT:	case DATA:
	case BSS:	case ALIGN:	case WGEN:	case END:
		/* sufficient? */
		return(0);
	}
	if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
	cp1 = p1->code;
	cp2 = p2->code;
	if (cp1==0 && cp2==0)
		return(1);
	if (cp1==0 || cp2==0)
		return(0);
	while (*cp1 == *cp2++)
		if (*cp1++ == 0)
			return(1);
	return(0);
}

delnode(p) register struct node *p; {
	p->back->forw = p->forw;
	p->forw->back = p->back;
}

decref(p)
register struct node *p;
{
	if (p && --p->refc <= 0) {
		nrlab++; nchange++;
		delnode(p);
	}
}

struct node *
nonlab(ap)
struct node *ap;
{
	register struct node *p;

	p = ap;
	while (p && p->op==LABEL)
		p = p->forw;
	return(p);
}

clearuse() {
	register struct node **i;
	for (i=uses+NREG; i>uses;) *--i=0;
	useacc = 0;
}

clearreg() {
	register char **i;
	for (i=regs+NREG+1; i>regs;){ **--i=0; **i=0; }
	conloc[0] = 0; ccloc[0] = 0;
}

savereg(ai, s, type)
register char *s;
{
	register char *p, *sp;

	sp = p = regs[ai];
	/* if any indexing, must be parameter or local */
	/* indirection (as in "*-4(fp)") is ok, however */
	*p++ = type;
	if (*s=='*' || *s=='$')
		*p++ = *s++;
	if (natural(s))
		strcpy(p, s);
	else {*sp = 0; return;}
}

dest(s,type, ccflg)
register char *s;
{
	register int i;

	if ((i = isreg(s)) >= 0) {
		*(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */
		if (DOUBLE==(type&0xF) || DOUBLE==((type>>4)&0xF) || type==QUAD)
			*(short *)(regs[i+1]) = 0;
	}
	for (i=NREG; --i>=0;)
		if (regs[i][1]=='*' && equstr(s, regs[i]+2))
			*(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */
	while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */
		*(short *)(regs[i]) = 0;

	if (!natural(s)) {/* wild store, everything except constants vanishes */
		for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0;
		conloc[0] = 0; ccloc[0] = 0;
	} else {
		if(ccflg)setcc(s,type); /* natural destinations set condition codes */
		if (equstr(s, conloc))
			conloc[0] = 0;
	}
}

splitrand(p) struct node *p; {
/* separate operands at commas, set up 'regs' and 'lastrand' */
register char *p1, *p2; register char **preg;

	preg=regs+RT1;
	if (p1=p->code) while (*p1) {
		lastrand=p2= *preg++;
		while (*p1) if (','==(*p2++= *p1++)) {--p2; break;}
		*p2=0;
	}
	while (preg<(regs+RT1+5)) *(*preg++)=0;
}

compat(have, want)
register int have, want;
{
	register int hsrc, hdst;
	extern int bitsize[];

	if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */
	hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc;
	if (want>=QUAD)
		return(bitsize[hdst]==bitsize[want] && bitsize[hsrc]==bitsize[want]);
	return(hsrc==want && hdst>=want && hdst<QUAD);
}

equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));}

findrand(as, type)
char *as;
{
	register char **i;
	for (i = regs+NREG; --i>=regs;) {
		if (**i && equstr(*i+1, as) && compat(**i,type))
			return(i-regs);
	}
	return(-1);
}

isreg(s)
register char *s;
{
	if (*s++!='r' || !isdigit(*s++)) return(-1);
	if (*s==0) return(*--s-'0');
	if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0');
	return(-1);
}

/*
check()
{
	register struct node *p, *lp;

	lp = &first;
	for (p=first.forw; p!=0; p = p->forw) {
		if (p->back != lp)
			abort(-1);
		lp = p;
	}
}
*/

newcode(p) struct node *p; {
	register char *p1,*p2,**preg;

	preg=regs+RT1; p2=line;
	while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';}
	*--p2=0;
	p->code=copy(line);
}

repladdr(p)
struct node *p;
{
	register int r;
	register char *p1;
	register char **preg;
	register int nrepl;

	preg=regs+RT1; nrepl=0;
	while (lastrand!=(p1= *preg++))
		if (0<=(r=findrand(p1,p->subop))) {
			*p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0;
			nchange++; nrepl++; nsaddr++;
		}
	if (nrepl) newcode(p);
}

/* conditional branches which are never/always taken */
reduncbr(p)
register struct node *p;
{
	register struct node *p1;
	register char *ap1, *ap2;

	p1 = p->back;
	if (p1->op==CMP) {
		splitrand(p1);
		ap1 = findcon(regs[RT1], p1->subop);
		ap2 = findcon(regs[RT2], p1->subop);
	} else {
		if(!ccloc[0])
			return;
		ap1 = findcon(ccloc+1, ccloc[0]);
		ap2 = "$0";
	}
	switch (compare(p->subop, ap1, ap2)) {
	case 0:		/* branch never taken */
		delnode(p);
		nredunj++;
		nchange++;
		decref(p->ref);
		if(p->forw->op!=CBR && (p1->op==TST || p1->op==CMP)) {
			delnode(p1);
			nrtst++;
		}
		break;
	case 1:		/* branch always taken */
		p->op = JBR;
		p->subop = 0;
		p->pop = 0;
		nchange++;
		if(nonlab(p->ref)->op!=CBR && (p1->op==TST || p1->op==CMP)) {
			delnode(p1);
			nrtst++;
		}
	}
}

/* a jump to a redundant compare (start of a 'for') */
redunbr(p)
register struct node *p;
{
	register struct node *p1;
	register char *ap1, *ap2;

	if ((p1 = p->ref) == 0)
		return;
	p1 = nonlab(p1);
	if (p1->op==TST || p1->op==CMP)
		splitrand(p1);
	else
		return;
	if (p1->forw->op==CBR) {
		ap1 = findcon(regs[RT1], p1->subop);
		if (p1->op==TST)
			ap2 = "$0";
		else
			ap2 = findcon(regs[RT2], p1->subop);
		p1 = p1->forw;
		if (compare(p1->subop, ap1, ap2) > 0) {
			nredunj++;
			nchange++;
			decref(p->ref);
			p->ref = p1->ref;
			p->labno = p1->labno;
#ifdef COPYCODE
			if (p->labno == 0)
				p->code = p1->code;
			if (p->ref)
#endif
				p->ref->refc++;
		}
	} else if (p1->op==TST && equstr(regs[RT1],ccloc+1) &&
			equtype(ccloc[0],p1->subop)) {
		p1=insertl(p1->forw); decref(p->ref); p->ref=p1; 
		p->labno=p1->labno;
		nrtst++; nchange++;
	}
}

char *
findcon(p, type)
	register char *p;
{
	register int r;

	if (*p=='$')
		return(p);
	if ((r = isreg(p)) >= 0 && compat(regs[r][0],type))
		return(regs[r]+1);
	if (equstr(p, conloc) && equtype(conloc[0], type))
		return(conval+1);
	return(p);
}

/* compare constants: 0 - branch taken; 1 - not taken; -1 - don't know */
compare(op, acp1, acp2)
char *acp1, *acp2;
{
	register char *cp1, *cp2;
	register int n1, n2, sign;

	cp1 = acp1;
	cp2 = acp2;
	if (*cp1++ != '$' || *cp2++ != '$')
		return(-1);
	n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;}
	while (isdigit(*cp1)) {n1 *= 10; n1 += *cp1++ - '0';}
	n1 *= sign;
	n2 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;}
	while (isdigit(*cp2)) {n2 *= 10; n2 += *cp2++ - '0';}
	n2 *= sign;
	if (*cp1=='+')
		cp1++;
	if (*cp2=='+')
		cp2++;
	do {
		if (*cp1++ != *cp2)
			return(-1);
	} while (*cp2++);
	switch(op) {

	case JEQ:
		return(n1 == n2);
	case JNE:
		return(n1 != n2);
	case JLE:
		return(n1 <= n2);
	case JGE:
		return(n1 >= n2);
	case JLT:
		return(n1 < n2);
	case JGT:
		return(n1 > n2);
	case JLO:
		return((unsigned)n1 < (unsigned)n2);
	case JHI:
		return((unsigned)n1 > (unsigned)n2);
	case JLOS:
		return((unsigned)n1 <= (unsigned)n2);
	case JHIS:
		return((unsigned)n1 >= (unsigned)n2);
	}
	return(-1);
}

setcon(cv, cl, type)
register char *cv, *cl;
{
	register char *p;

	if (*cv != '$')
		return;
	if (!natural(cl))
		return;
	p = conloc;
	while (*p++ = *cl++);
	p = conval;
	*p++ = type;
	while (*p++ = *cv++);
}

setcc(ap,type)
char *ap;
{
	register char *p, *p1;

	p = ap;
	if (!natural(p)) {
		ccloc[0] = 0;
		return;
	}
	p1 = ccloc;
	*p1++ = type;
	while (*p1++ = *p++);
}

indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */
	while (*p) if (*p++=='[') return(1);
	return(0);
}

natural(p)
register char *p;
{/* 1->simple local, parameter, global, or register; 0->otherwise */

	if (*p=='*' || *p=='(' || *p=='$')
		return(0);
	while (*p++);
	p--;
	if (*--p==']' || *p==')' &&
	 !(*(p-2)=='f' || fortflg && (*--p=='1' || *p=='2') && *--p=='1'))
		return(0);
	return(1);
}

/*
** Tell if an argument is most likely static.
*/

isstatic(cp)
register char	*cp;
{
	if (*cp == '_' || *cp == 'L')
		return (1);
	return (0);
}


checkaobdisp(p)
register struct node *p;
{
register struct node *q;
register int i;
	

if (!aobflag) return(1);
/*  backward search */
	i = 0;
	q = p; 
	while (i++ < MAXAOBDISP && ((q= q->back) !=&first))
	{
		if (p->ref == q) 
		   return(1);
	}

/*  forward search */
	i = 0;
	q = p; 
	while (i++ < MAXAOBDISP && ((q= q->forw) !=0))
	{
		if (p->ref == q) 
		   return(1);
	}
	return(0);
}


struct intleavetab intltab[] = {
	ADDF,	FLOAT,		1,
	ADDF,	DOUBLE,		1,
	SUBF,	FLOAT,		1,
	SUBF,	DOUBLE,		1,
	MULF,	FLOAT,		1,
	MULF,	DOUBLE,		1,
	DIVF,	FLOAT,		1,
	DIVF,	DOUBLE,		1,
	SINF,	FLOAT,		1,
	COSF,	FLOAT,		1,
	ATANF,	FLOAT,		1,
	LOGF,	FLOAT,		1,
	SQRTF,	FLOAT,		1,
	EXPF,	FLOAT,		1,
	LDF,	FLOAT,		0,
	LDF,	DOUBLE,		0,
	LNF,	FLOAT,		0,
	LNF,	DOUBLE,		0,
	STF,	FLOAT,		0,
	CMPF,	FLOAT,		0,
	CMPF,	DOUBLE,		0,
	CMPF2,	FLOAT,		0,
	TSTF,	FLOAT,		0,
	TSTF,	DOUBLE,		0,
	PUSHD,	DOUBLE,		0,
	CVLF,	U(LONG,FLOAT),	0,
	CVFL,	U(FLOAT,LONG),	0, 
	LDFD,	U(FLOAT,DOUBLE),0, 
	CVDF,	U(DOUBLE,FLOAT),0,
	NEGF,	FLOAT,		0,
	NIL,	0,		0};

interleave()
{
	register struct node *p, *p1;

	register struct intleavetab *t;
	register int r;
	int count;
	for (p= first.forw; p!=0; p = p->forw){
		count = 0;
		for  (t =intltab; t->op != NIL; t++){
			if (t->op == p->op && t->subop == p->subop){
			count = t->intleavect;
			break;
			}
		}
		if (count < 1) continue;
		p1 = p->forw;
		clearuse();
		clearreg();
		while ((p1 != 0) && (p1->op != CBR) &&
		      (p1->subop == FLOAT || p1->subop == DOUBLE ||
	              ((p1->subop&0xF0)==DOUBLE<<4) || ((p1->subop&0xF)==DOUBLE )||
	              ((p1->subop&0xF0)==FLOAT<<4) || (p1->subop&0xF)==FLOAT))
		{
			if (((r = isreg(p1->code)) >= 0)){
			uses[r] = p1;
			if ((p1->subop == DOUBLE) || ((p->subop&0xF0)==DOUBLE<<4) || 
		           ((p->subop&0xF)==DOUBLE)) 
				uses[r+1] = p1;
			}
			else checkreg(p1,p1->code);
			p1 = p1->forw;

		}
		if (p1 == 0) return;
		if (!(sideeffect(p, p1)))
			insertblk(p,p1);
	}
		
}


insertblk(p, p1)
struct node *p, *p1;
{
	p1->back->forw = p1->forw;
	p1->forw->back = p1->back;
	p1->forw = p->forw;
	p->forw->back = p1;
	p->forw = p1;
	p1->back = p;
}

OpCode termop[] = {
	JBR, CBR, JMP, LABEL, DLABEL, EROU, JSW, TST, CMP, BIT,
	CALLF, CALLS, CASE, AOBLEQ, AOBLSS, CMPF, CMPF2, TSTF, MOVBLK, MFPR,
	MTPR, PROBE, MOVO, TEXT, DATA, BSS, ALIGN, END, LGEN, SET,
	LCOMM, COMM, NIL
}; 

sideeffect(p,p1)
struct node *p, *p1;
{
	register struct node *q;
	register int r;
	register OpCode *t;
	register char *cp;
	int i;

	if (p1->op == NIL) return(1);  /*  special instructions */

	for (t = termop; *t!=NIL; t++){
		if (*t == p1->op) return(1);
	}
	if ((p1->forw != NULL) && (p1->forw->op == CBR))
		return(1);
	splitrand(p1);
	r = isreg(lastrand);
	if (uses[r] &&  r >= 0 ) return(1);
	if ((p1->op == EDIV) && (r = isreg(regs[RT3]) >= 0) &&
	   (uses[r]))  return(1);

	for (q = p1->back ; q!=p; q=q->back)
	{
		if ((p1->op == PUSH || p1->op == PUSHA) &&
		    (q->op == PUSHD || q->op == PUSH || q->op == PUSHA))  
		     return(1); 		     /* keep args in order */
		if (((i = strlen(q->code)) >= 5 &&    /* cvdl -(sp); pushl r0*/
		    (strcmp(q->code+i-5,"-(sp)") == 0 )) || 
		    (strcmp(lastrand,"-(sp)") == 0)) return(1);
		if (equstr(q->code, lastrand))
		    return(1);
		if (q->op == STF || q->op == CVFL || q->op == CVLF) 
		   {
		    if (equstr(q->code, regs[RT1])) return(1);
		if (has3ops(p1) || p1->op == EMUL || p1->op == EDIV)
		    if (equstr(q->code, regs[RT2]))
		       return(1);
		/*  handle the case  std -56(fp) pushl -60(fp) pushl
		    -56(fp);
		*/
		if ((p1->forw != NULL) &&  (q->op == STF) &&
		(q->subop == DOUBLE)){ 
		if (!strncmp(q->code,p1->forw->code,strlen(q->code)))
			return(1);
		}
		}
	}
	return(0);
}
checkreg(p,s)
struct node *p;
char *s;
{
char *cp2;  
register int r;
	/* check for (r),[r] */
	do if (*s=='(' || *s=='[') {/* get register number */
		char t;
		cp2= ++s; while (*++s!=')' && *s!=']'); t= *s; *s=0;
		if ((r=isreg(cp2)) >= 0)  {
			uses[r]=p; 
		}
		*s=t;
	} while (*++s);
}