[unix-history] / usr / src / cmd / c / c21.c

#
/*
 * C object code improver-- second part
 */

#include "c2.h"

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

	for (p=first.forw; p!=0; p = p->forw) {
	flt = 0;
	switch (p->op) {

	case MOVF:
	case MOVFO:
	case MOVOF:
		flt = NREG;

	case MOV:
		if (p->subop==BYTE)
			goto dble;
		dualop(p);
		if ((r = findrand(regs[RT1], flt)) >= 0) {
			if (r == flt+isreg(regs[RT2]) && p->forw->op!=CBR
			   && p->forw->op!=SXT
			   && p->forw->op!=CFCC) {
				p->forw->back = p->back;
				p->back->forw = p->forw;
				redunm++;
				continue;
			}
		}
		if (equstr(regs[RT1], "$0")) {
			p->op = CLR;
			strcpy(regs[RT1], regs[RT2]);
			regs[RT2][0] = 0;
			p->code = copy(1, regs[RT1]);
			goto sngl;
		}
		repladdr(p, 0, flt);
		r = isreg(regs[RT1]);
		r1 = isreg(regs[RT2]);
		dest(regs[RT2], flt);
		if (r >= 0)
			if (r1 >= 0)
				savereg(r1+flt, regs[r+flt]);
			else
				savereg(r+flt, regs[RT2]);
		else
			if (r1 >= 0)
				savereg(r1+flt, regs[RT1]);
			else
				setcon(regs[RT1], regs[RT2]);
		source(regs[RT1]);
		setcc(regs[RT2]);
		continue;

	case ADDF:
	case SUBF:
	case DIVF:
	case MULF:
		flt = NREG;
		goto dble;

	case ADD:
	case SUB:
	case BIC:
	case BIS:
	case MUL:
	case DIV:
	case ASH:
	dble:
		dualop(p);
		if (p->op==BIC && (equstr(regs[RT1], "$-1") || equstr(regs[RT1], "$177777"))) {
			p->op = CLR;
			strcpy(regs[RT1], regs[RT2]);
			regs[RT2][0] = 0;
			p->code = copy(1, regs[RT1]);
			goto sngl;
		}
		if ((p->op==BIC || p->op==BIS) && equstr(regs[RT1], "$0")) {
			if (p->forw->op!=CBR) {
				p->back->forw = p->forw;
				p->forw->back = p->back;
				continue;
			}
		}
		repladdr(p, 0, flt);
		source(regs[RT1]);
		dest(regs[RT2], flt);
		if (p->op==DIV && (r = isreg(regs[RT2])>=0))
			regs[r+1][0] = 0;
		ccloc[0] = 0;
		continue;

	case CLRF:
	case NEGF:
		flt = NREG;

	case CLR:
	case COM:
	case INC:
	case DEC:
	case NEG:
	case ASR:
	case ASL:
	case SXT:
		singop(p);
	sngl:
		dest(regs[RT1], flt);
		if (p->op==CLR && flt==0)
			if ((r = isreg(regs[RT1])) >= 0)
				savereg(r, "$0");
			else
				setcon("$0", regs[RT1]);
		ccloc[0] = 0;
		continue;

	case TSTF:
		flt = NREG;

	case TST:
		singop(p);
		repladdr(p, 0, flt);
		source(regs[RT1]);
		if (equstr(regs[RT1], ccloc)) {
			p->back->forw = p->forw;
			p->forw->back = p->back;
			p = p->back;
			nrtst++;
			nchange++;
		}
		continue;

	case CMPF:
		flt = NREG;

	case CMP:
	case BIT:
		dualop(p);
		source(regs[RT1]);
		source(regs[RT2]);
		if(p->op==BIT) {
			if (equstr(regs[RT1], "$-1") || equstr(regs[RT1], "$177777")) {
				p->op = TST;
				strcpy(regs[RT1], regs[RT2]);
				regs[RT2][0] = 0;
				p->code = copy(1, regs[RT1]);
				nchange++;
				nsaddr++;
			} else if (equstr(regs[RT2], "$-1") || equstr(regs[RT2], "$177777")) {
				p->op = TST;
				regs[RT2][0] = 0;
				p->code = copy(1, regs[RT1]);
				nchange++;
				nsaddr++;
			}
			if (equstr(regs[RT1], "$0")) {
				p->op = TST;
				regs[RT2][0] = 0;
				p->code = copy(1, regs[RT1]);
				nchange++;
				nsaddr++;
			} else if (equstr(regs[RT2], "$0")) {
				p->op = TST;
				strcpy(regs[RT1], regs[RT2]);
				regs[RT2][0] = 0;
				p->code = copy(1, regs[RT1]);
				nchange++;
				nsaddr++;
			}
		}
		repladdr(p, 1, flt);
		ccloc[0] = 0;
		continue;

	case CBR:
		if (p->back->op==TST || p->back->op==CMP) {
			if (p->back->op==TST) {
				singop(p->back);
				savereg(RT2, "$0");
			} else
				dualop(p->back);
			r = compare(p->subop, findcon(RT1), findcon(RT2));
			if (r==0) {
				p->back->back->forw = p->forw;
				p->forw->back = p->back->back;
				decref(p->ref);
				p = p->back->back;
				nchange++;
			} else if (r>0) {
				p->op = JBR;
				p->subop = 0;
				p->back->back->forw = p;
				p->back = p->back->back;
				p = p->back;
				nchange++;
			}
		}
	case CFCC:
		ccloc[0] = 0;
		continue;

	case JBR:
		redunbr(p);

	default:
		clearreg();
	}
	}
}

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

	t = 0;
	nj = 0;
	for (p=first.forw; p!=0; p = p->forw)
		p->refc = ++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->refc - p->ref->refc) > abs(p1->refc - p1->ref->refc)) {
			if (p->ref==p1->ref)
				continue;
			p->subop = revbr[p->subop];
			tp = p1->ref;
			p1->ref = p->ref;
			p->ref = tp;
			t = p1->labno;
			p1->labno = p->labno;
			p->labno = t;
			nrevbr++;
			nj++;
		}
	}
	return(nj);
}

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

	for (p = &first; (p1 = p->forw)!=0; p = p1) {
		if (p->op==DEC && isreg(p->code)>=0
		 && p1->op==CBR && p1->subop==JNE) {
			if (p->refc < p1->ref->refc)
				continue;
			if (toofar(p1))
				continue;
			p->labno = p1->labno;
			p->op = SOB;
			p->subop = 0;
			p1->forw->back = p;
			p->forw = p1->forw;
			nsob++;
		}
	}
}

toofar(p)
struct node *p;
{
	register struct node *p1;
	int len;

	len = 0;
	for (p1 = p->ref; p1 && p1!=p; p1 = p1->forw)
		len += ilen(p1);
	if (len < 128)
		return(0);
	return(1);
}

ilen(p)
register struct node *p;
{
	register l;

	switch (p->op) {
	case LABEL:
	case DLABEL:
	case TEXT:
	case EROU:
	case EVEN:
		return(0);

	case CBR:
		return(6);

	default:
		dualop(p);
		return(2 + adrlen(regs[RT1]) + adrlen(regs[RT2]));
	}
}

adrlen(s)
register char *s;
{
	if (*s == 0)
		return(0);
	if (*s=='r')
		return(0);
	if (*s=='(' && *(s+1)=='r')
		return(0);
	if (*s=='-' && *(s+1)=='(')
		return(0);
	return(2);
}

abs(x)
{
	return(x<0? -x: x);
}

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

	p1 = ap1;
	if (p1->op!=p2->op || p1->subop!=p2->subop)
		return(0);
	if (p1->op>0 && p1->op<MOV)
		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);
}

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

struct node *
nonlab(p)
struct node *p;
{
	while (p && p->op==LABEL)
		p = p->forw;
	return(p);
}

char *
alloc(n)
register n;
{
	register char *p;

	n++;
	n &= ~01;
	if (lasta+n >= lastr) {
		if (sbrk(2000) == (char *)-1) {
			fprintf(stderr, "C Optimizer: out of space\n");
			exit(1);
		}
		lastr += 2000;
	}
	p = lasta;
	lasta += n;
	return(p);
}

clearreg()
{
	register int i;

	for (i=0; i<2*NREG; i++)
		regs[i][0] = '\0';
	conloc[0] = 0;
	ccloc[0] = 0;
}

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

	sp = p = regs[ai];
	s = as;
	if (source(s))
		return;
	while (*p++ = *s) {
		if (s[0]=='(' && s[1]=='r' && s[2]<'5') {
			*sp = 0;
			return;
		}
		if (*s++ == ',')
			break;
	}
	*--p = '\0';
}

dest(as, flt)
char *as;
{
	register char *s;
	register int i;

	s = as;
	source(s);
	if ((i = isreg(s)) >= 0)
		regs[i+flt][0] = 0;
	for (i=0; i<NREG+NREG; i++)
		if (*regs[i]=='*' && equstr(s, regs[i]+1))
			regs[i][0] = 0;
	while ((i = findrand(s, flt)) >= 0)
		regs[i][0] = 0;
	while (*s) {
		if ((*s=='(' && (*(s+1)!='r' || *(s+2)!='5')) || *s++=='*') {
			for (i=0; i<NREG+NREG; i++) {
				if (regs[i][0] != '$')
					regs[i][0] = 0;
				conloc[0] = 0;
			}
			return;
		}
	}
}

singop(ap)
struct node *ap;
{
	register char *p1, *p2;

	p1 = ap->code;
	p2 = regs[RT1];
	while (*p2++ = *p1++);
	regs[RT2][0] = 0;
}


dualop(ap)
struct node *ap;
{
	register char *p1, *p2;
	register struct node *p;

	p = ap;
	p1 = p->code;
	p2 = regs[RT1];
	while (*p1 && *p1!=',')
		*p2++ = *p1++;
	*p2++ = 0;
	p2 = regs[RT2];
	*p2 = 0;
	if (*p1++ !=',')
		return;
	while (*p2++ = *p1++);
}

findrand(as, flt)
char *as;
{
	register int i;
	for (i = flt; i<NREG+flt; i++) {
		if (equstr(regs[i], as))
			return(i);
	}
	return(-1);
}

isreg(as)
char *as;
{
	register char *s;

	s = as;
	if (s[0]=='r' && s[1]>='0' && s[1]<='4' && s[2]==0)
		return(s[1]-'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();
		lp = p;
	}
}

source(ap)
char *ap;
{
	register char *p1, *p2;

	p1 = ap;
	p2 = p1;
	if (*p1==0)
		return(0);
	while (*p2++);
	if (*p1=='-' && *(p1+1)=='('
	 || *p1=='*' && *(p1+1)=='-' && *(p1+2)=='('
	 || *(p2-2)=='+') {
		while (*p1 && *p1++!='r');
		if (*p1>='0' && *p1<='4')
			regs[*p1 - '0'][0] = 0;
		return(1);
	}
	return(0);
}

repladdr(p, f, flt)
struct node *p;
{
	register r;
	int r1;
	register char *p1, *p2;
	static char rt1[50], rt2[50];

	if (f)
		r1 = findrand(regs[RT2], flt);
	else
		r1 = -1;
	r = findrand(regs[RT1], flt);
	if (r1 >= NREG)
		r1 -= NREG;
	if (r >= NREG)
		r -= NREG;
	if (r>=0 || r1>=0) {
		p2 = regs[RT1];
		for (p1 = rt1; *p1++ = *p2++;);
		if (regs[RT2][0]) {
			p1 = rt2;
			*p1++ = ',';
			for (p2 = regs[RT2]; *p1++ = *p2++;);
		} else
			rt2[0] = 0;
		if (r>=0) {
			rt1[0] = 'r';
			rt1[1] = r + '0';
			rt1[2] = 0;
			nsaddr++;
		}
		if (r1>=0) {
			rt2[1] = 'r';
			rt2[2] = r1 + '0';
			rt2[3] = 0;
			nsaddr++;
		}
		p->code = copy(2, rt1, rt2);
	}
}

movedat()
{
	register struct node *p1, *p2;
	struct node *p3;
	register seg;
	struct node data;
	struct node *datp;

	if (first.forw == 0)
		return;
	if (lastseg != TEXT && lastseg != -1) {
		p1 = (struct node *)alloc(sizeof(first));
		p1->op = lastseg;
		p1->subop = 0;
		p1->code = NULL;
		p1->forw = first.forw;
		p1->back = &first;
		first.forw->back = p1;
		first.forw = p1;
	}
	datp = &data;
	for (p1 = first.forw; p1!=0; p1 = p1->forw) {
		if (p1->op == DATA) {
			p2 = p1->forw;
			while (p2 && p2->op!=TEXT)
				p2 = p2->forw;
			if (p2==0)
				break;
			p3 = p1->back;
			p1->back->forw = p2->forw;
			p2->forw->back = p3;
			p2->forw = 0;
			datp->forw = p1;
			p1->back = datp;
			p1 = p3;
			datp = p2;
		}
	}
	if (data.forw) {
		datp->forw = first.forw;
		first.forw->back = datp;
		data.forw->back = &first;
		first.forw = data.forw;
	}
	seg = lastseg;
	for (p1 = first.forw; p1!=0; p1 = p1->forw) {
		if (p1->op==TEXT||p1->op==DATA||p1->op==BSS) {
			if (p2 = p1->forw) {
				if (p2->op==TEXT||p2->op==DATA||p2->op==BSS)
					p1->op  = p2->op;
			}
			if (p1->op == seg || p1->forw&&p1->forw->op==seg) {
				p1->back->forw = p1->forw;
				p1->forw->back = p1->back;
				p1 = p1->back;
				continue;
			}
			seg = p1->op;
		}
	}
}

redunbr(p)
register struct node *p;
{
	register struct node *p1;
	register char *ap1;
	char *ap2;

	if ((p1 = p->ref) == 0)
		return;
	p1 = nonlab(p1);
	if (p1->op==TST) {
		singop(p1);
		savereg(RT2, "$0");
	} else if (p1->op==CMP)
		dualop(p1);
	else
		return;
	if (p1->forw->op!=CBR)
		return;
	ap1 = findcon(RT1);
	ap2 = findcon(RT2);
	p1 = p1->forw;
	if (compare(p1->subop, ap1, ap2)>0) {
		nredunj++;
		nchange++;
		decref(p->ref);
		p->ref = p1->ref;
		p->labno = p1->labno;
		p->ref->refc++;
	}
}

char *
findcon(i)
{
	register char *p;
	register r;

	p = regs[i];
	if (*p=='$')
		return(p);
	if ((r = isreg(p)) >= 0)
		return(regs[r]);
	if (equstr(p, conloc))
		return(conval);
	return(p);
}

compare(oper, cp1, cp2)
register char *cp1, *cp2;
{
	register unsigned n1, n2;

	if (*cp1++ != '$' || *cp2++ != '$')
		return(-1);
	n1 = 0;
	while (*cp2 >= '0' && *cp2 <= '7') {
		n1 <<= 3;
		n1 += *cp2++ - '0';
	}
	n2 = n1;
	n1 = 0;
	while (*cp1 >= '0' && *cp1 <= '7') {
		n1 <<= 3;
		n1 += *cp1++ - '0';
	}
	if (*cp1=='+')
		cp1++;
	if (*cp2=='+')
		cp2++;
	do {
		if (*cp1++ != *cp2)
			return(-1);
	} while (*cp2++);
	switch(oper) {

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

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

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

equstr(ap1, ap2)
char *ap1, *ap2;
{
	char *p1, *p2;

	p1 = ap1;
	p2 = ap2;
	do {
		if (*p1++ != *p2)
			return(0);
	} while (*p2++);
	return(1);
}

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

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

natural(ap)
char *ap;
{
	register char *p;

	p = ap;
	if (*p=='*' || *p=='(' || *p=='-'&&*(p+1)=='(')
		return(0);
	while (*p++);
	p--;
	if (*--p == '+' || *p ==')' && *--p != '5')
		return(0);
	return(1);
}
Commit	Line	Data
3823a6ae DR	1	#
	2	/*
	3	* C object code improver-- second part
	4	*/
	5
	6	#include "c2.h"
	7
	8	rmove()
	9	{
	10	register struct node *p;
	11	register int r;
	12	register r1, flt;
	13
	14	for (p=first.forw; p!=0; p = p->forw) {
	15	flt = 0;
	16	switch (p->op) {
	17
	18	case MOVF:
	19	case MOVFO:
	20	case MOVOF:
	21	flt = NREG;
	22
	23	case MOV:
	24	if (p->subop==BYTE)
	25	goto dble;
	26	dualop(p);
	27	if ((r = findrand(regs[RT1], flt)) >= 0) {
	28	if (r == flt+isreg(regs[RT2]) && p->forw->op!=CBR
	29	&& p->forw->op!=SXT
	30	&& p->forw->op!=CFCC) {
	31	p->forw->back = p->back;
	32	p->back->forw = p->forw;
	33	redunm++;
	34	continue;
	35	}
	36	}
	37	if (equstr(regs[RT1], "$0")) {
	38	p->op = CLR;
	39	strcpy(regs[RT1], regs[RT2]);
	40	regs[RT2][0] = 0;
	41	p->code = copy(1, regs[RT1]);
	42	goto sngl;
	43	}
	44	repladdr(p, 0, flt);
	45	r = isreg(regs[RT1]);
	46	r1 = isreg(regs[RT2]);
	47	dest(regs[RT2], flt);
	48	if (r >= 0)
	49	if (r1 >= 0)
	50	savereg(r1+flt, regs[r+flt]);
	51	else
	52	savereg(r+flt, regs[RT2]);
	53	else
	54	if (r1 >= 0)
	55	savereg(r1+flt, regs[RT1]);
	56	else
	57	setcon(regs[RT1], regs[RT2]);
	58	source(regs[RT1]);
	59	setcc(regs[RT2]);
	60	continue;
	61
	62	case ADDF:
	63	case SUBF:
	64	case DIVF:
65	case MULF:
66	flt = NREG;
67	goto dble;
68
69	case ADD:
70	case SUB:
71	case BIC:
72	case BIS:
73	case MUL:
74	case DIV:
75	case ASH:
76	dble:
77	dualop(p);
78	if (p->op==BIC && (equstr(regs[RT1], "$-1") \|\| equstr(regs[RT1], "$177777"))) {
79	p->op = CLR;
80	strcpy(regs[RT1], regs[RT2]);
81	regs[RT2][0] = 0;
82	p->code = copy(1, regs[RT1]);
83	goto sngl;
84	}
85	if ((p->op==BIC \|\| p->op==BIS) && equstr(regs[RT1], "$0")) {
86	if (p->forw->op!=CBR) {
87	p->back->forw = p->forw;
88	p->forw->back = p->back;
89	continue;
90	}
91	}
92	repladdr(p, 0, flt);
93	source(regs[RT1]);
94	dest(regs[RT2], flt);
95	if (p->op==DIV && (r = isreg(regs[RT2])>=0))
96	regs[r+1][0] = 0;
97	ccloc[0] = 0;
98	continue;
99
100	case CLRF:
101	case NEGF:
102	flt = NREG;
103
104	case CLR:
105	case COM:
106	case INC:
107	case DEC:
108	case NEG:
109	case ASR:
110	case ASL:
111	case SXT:
112	singop(p);
113	sngl:
114	dest(regs[RT1], flt);
115	if (p->op==CLR && flt==0)
116	if ((r = isreg(regs[RT1])) >= 0)
117	savereg(r, "$0");
118	else
119	setcon("$0", regs[RT1]);
120	ccloc[0] = 0;
121	continue;
122
123	case TSTF:
124	flt = NREG;
125
126	case TST:
127	singop(p);
128	repladdr(p, 0, flt);
129	source(regs[RT1]);
130	if (equstr(regs[RT1], ccloc)) {
131	p->back->forw = p->forw;
132	p->forw->back = p->back;
133	p = p->back;
134	nrtst++;
135	nchange++;
136	}
137	continue;
138
139	case CMPF:
140	flt = NREG;
141
142	case CMP:
143	case BIT:
144	dualop(p);
145	source(regs[RT1]);
146	source(regs[RT2]);
147	if(p->op==BIT) {
148	if (equstr(regs[RT1], "$-1") \|\| equstr(regs[RT1], "$177777")) {
149	p->op = TST;
150	strcpy(regs[RT1], regs[RT2]);
151	regs[RT2][0] = 0;
152	p->code = copy(1, regs[RT1]);
153	nchange++;
154	nsaddr++;
155	} else if (equstr(regs[RT2], "$-1") \|\| equstr(regs[RT2], "$177777")) {
156	p->op = TST;
157	regs[RT2][0] = 0;
158	p->code = copy(1, regs[RT1]);
159	nchange++;
160	nsaddr++;
161	}
162	if (equstr(regs[RT1], "$0")) {
163	p->op = TST;
164	regs[RT2][0] = 0;
165	p->code = copy(1, regs[RT1]);
166	nchange++;
167	nsaddr++;
168	} else if (equstr(regs[RT2], "$0")) {
169	p->op = TST;
170	strcpy(regs[RT1], regs[RT2]);
171	regs[RT2][0] = 0;
172	p->code = copy(1, regs[RT1]);
173	nchange++;
174	nsaddr++;
175	}
176	}
177	repladdr(p, 1, flt);
178	ccloc[0] = 0;
179	continue;
180
181	case CBR:
182	if (p->back->op==TST \|\| p->back->op==CMP) {
183	if (p->back->op==TST) {
184	singop(p->back);
185	savereg(RT2, "$0");
186	} else
187	dualop(p->back);
188	r = compare(p->subop, findcon(RT1), findcon(RT2));
189	if (r==0) {
190	p->back->back->forw = p->forw;
191	p->forw->back = p->back->back;
192	decref(p->ref);
193	p = p->back->back;
194	nchange++;
195	} else if (r>0) {
196	p->op = JBR;
197	p->subop = 0;
198	p->back->back->forw = p;
199	p->back = p->back->back;
200	p = p->back;
201	nchange++;
202	}
203	}
204	case CFCC:
205	ccloc[0] = 0;
206	continue;
207
208	case JBR:
209	redunbr(p);
210
211	default:
212	clearreg();
213	}
214	}
215	}
216
217	jumpsw()
218	{
219	register struct node p, p1;
220	register t;
221	register struct node *tp;
222	int nj;
223
224	t = 0;
225	nj = 0;
226	for (p=first.forw; p!=0; p = p->forw)
227	p->refc = ++t;
228	for (p=first.forw; p!=0; p = p1) {
229	p1 = p->forw;
230	if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
231	&& abs(p->refc - p->ref->refc) > abs(p1->refc - p1->ref->refc)) {
232	if (p->ref==p1->ref)
233	continue;
234	p->subop = revbr[p->subop];
235	tp = p1->ref;
236	p1->ref = p->ref;
237	p->ref = tp;
238	t = p1->labno;
239	p1->labno = p->labno;
240	p->labno = t;
241	nrevbr++;
242	nj++;
243	}
244	}
245	return(nj);
246	}
247
248	addsob()
249	{
250	register struct node p, p1;
251
252	for (p = &first; (p1 = p->forw)!=0; p = p1) {
253	if (p->op==DEC && isreg(p->code)>=0
254	&& p1->op==CBR && p1->subop==JNE) {
255	if (p->refc < p1->ref->refc)
256	continue;
257	if (toofar(p1))
258	continue;
259	p->labno = p1->labno;
260	p->op = SOB;
261	p->subop = 0;
262	p1->forw->back = p;
263	p->forw = p1->forw;
264	nsob++;
265	}
266	}
267	}
268
269	toofar(p)
270	struct node *p;
271	{
272	register struct node *p1;
273	int len;
274
275	len = 0;
276	for (p1 = p->ref; p1 && p1!=p; p1 = p1->forw)
277	len += ilen(p1);
278	if (len < 128)
279	return(0);
280	return(1);
281	}
282
283	ilen(p)
284	register struct node *p;
285	{
286	register l;
287
288	switch (p->op) {
289	case LABEL:
290	case DLABEL:
291	case TEXT:
292	case EROU:
293	case EVEN:
294	return(0);
295
296	case CBR:
297	return(6);
298
299	default:
300	dualop(p);
301	return(2 + adrlen(regs[RT1]) + adrlen(regs[RT2]));
302	}
303	}
304
305	adrlen(s)
306	register char *s;
307	{
308	if (*s == 0)
309	return(0);
310	if (*s=='r')
311	return(0);
312	if (s=='(' && (s+1)=='r')
313	return(0);
314	if (s=='-' && (s+1)=='(')
315	return(0);
316	return(2);
317	}
318
319	abs(x)
320	{
321	return(x<0? -x: x);
322	}
323
324	equop(ap1, p2)
325	struct node ap1, p2;
326	{
327	register char cp1, cp2;
328	register struct node *p1;
329
330	p1 = ap1;
331	if (p1->op!=p2->op \|\| p1->subop!=p2->subop)
332	return(0);
333	if (p1->op>0 && p1->op<MOV)
334	return(0);
335	cp1 = p1->code;
336	cp2 = p2->code;
337	if (cp1==0 && cp2==0)
338	return(1);
339	if (cp1==0 \|\| cp2==0)
340	return(0);
341	while (cp1 == cp2++)
342	if (*cp1++ == 0)
343	return(1);
344	return(0);
345	}
346
347	decref(p)
348	register struct node *p;
349	{
350	if (--p->refc <= 0) {
351	nrlab++;
352	p->back->forw = p->forw;
353	p->forw->back = p->back;
354	}
355	}
356
357	struct node *
358	nonlab(p)
359	struct node *p;
360	{
361	while (p && p->op==LABEL)
362	p = p->forw;
363	return(p);
364	}
365
366	char *
367	alloc(n)
368	register n;
369	{
370	register char *p;
371
372	n++;
373	n &= ~01;
374	if (lasta+n >= lastr) {
375	if (sbrk(2000) == (char *)-1) {
376	fprintf(stderr, "C Optimizer: out of space\n");
377	exit(1);
378	}
379	lastr += 2000;
380	}
381	p = lasta;
382	lasta += n;
383	return(p);
384	}
385
386	clearreg()
387	{
388	register int i;
389
390	for (i=0; i<2*NREG; i++)
391	regs[i][0] = '\0';
392	conloc[0] = 0;
393	ccloc[0] = 0;
394	}
395
396	savereg(ai, as)
397	char *as;
398	{
399	register char p, s, *sp;
400
401	sp = p = regs[ai];
402	s = as;
403	if (source(s))
404	return;
405	while (p++ = s) {
406	if (s[0]=='(' && s[1]=='r' && s[2]<'5') {
407	*sp = 0;
408	return;
409	}
410	if (*s++ == ',')
411	break;
412	}
413	*--p = '\0';
414	}
415
416	dest(as, flt)
417	char *as;
418	{
419	register char *s;
420	register int i;
421
422	s = as;
423	source(s);
424	if ((i = isreg(s)) >= 0)
425	regs[i+flt][0] = 0;
426	for (i=0; i<NREG+NREG; i++)
427	if (regs[i]=='' && equstr(s, regs[i]+1))
428	regs[i][0] = 0;
429	while ((i = findrand(s, flt)) >= 0)
430	regs[i][0] = 0;
431	while (*s) {
432	if ((s=='(' && ((s+1)!='r' \|\| (s+2)!='5')) \|\| s++=='*') {
433	for (i=0; i<NREG+NREG; i++) {
434	if (regs[i][0] != '$')
435	regs[i][0] = 0;
436	conloc[0] = 0;
437	}
438	return;
439	}
440	}
441	}
442
443	singop(ap)
444	struct node *ap;
445	{
446	register char p1, p2;
447
448	p1 = ap->code;
449	p2 = regs[RT1];
450	while (p2++ = p1++);
451	regs[RT2][0] = 0;
452	}
453
454
455	dualop(ap)
456	struct node *ap;
457	{
458	register char p1, p2;
459	register struct node *p;
460
461	p = ap;
462	p1 = p->code;
463	p2 = regs[RT1];
464	while (p1 && p1!=',')
465	p2++ = p1++;
466	*p2++ = 0;
467	p2 = regs[RT2];
468	*p2 = 0;
469	if (*p1++ !=',')
470	return;
471	while (p2++ = p1++);
472	}
473
474	findrand(as, flt)
475	char *as;
476	{
477	register int i;
478	for (i = flt; i<NREG+flt; i++) {
479	if (equstr(regs[i], as))
480	return(i);
481	}
482	return(-1);
483	}
484
485	isreg(as)
486	char *as;
487	{
488	register char *s;
489
490	s = as;
491	if (s[0]=='r' && s[1]>='0' && s[1]<='4' && s[2]==0)
492	return(s[1]-'0');
493	return(-1);
494	}
495
496	check()
497	{
498	register struct node p, lp;
499
500	lp = &first;
501	for (p=first.forw; p!=0; p = p->forw) {
502	if (p->back != lp)
503	abort();
504	lp = p;
505	}
506	}
507
508	source(ap)
509	char *ap;
510	{
511	register char p1, p2;
512
513	p1 = ap;
514	p2 = p1;
515	if (*p1==0)
516	return(0);
517	while (*p2++);
518	if (p1=='-' && (p1+1)=='('
519	\|\| p1=='' && (p1+1)=='-' && (p1+2)=='('
520	\|\| *(p2-2)=='+') {
521	while (p1 && p1++!='r');
522	if (p1>='0' && p1<='4')
523	regs[*p1 - '0'][0] = 0;
524	return(1);
525	}
526	return(0);
527	}
528
529	repladdr(p, f, flt)
530	struct node *p;
531	{
532	register r;
533	int r1;
534	register char p1, p2;
535	static char rt1[50], rt2[50];
536
537	if (f)
538	r1 = findrand(regs[RT2], flt);
539	else
540	r1 = -1;
541	r = findrand(regs[RT1], flt);
542	if (r1 >= NREG)
543	r1 -= NREG;
544	if (r >= NREG)
545	r -= NREG;
546	if (r>=0 \|\| r1>=0) {
547	p2 = regs[RT1];
548	for (p1 = rt1; p1++ = p2++;);
549	if (regs[RT2][0]) {
550	p1 = rt2;
551	*p1++ = ',';
552	for (p2 = regs[RT2]; p1++ = p2++;);
553	} else
554	rt2[0] = 0;
555	if (r>=0) {
556	rt1[0] = 'r';
557	rt1[1] = r + '0';
558	rt1[2] = 0;
559	nsaddr++;
560	}
561	if (r1>=0) {
562	rt2[1] = 'r';
563	rt2[2] = r1 + '0';
564	rt2[3] = 0;
565	nsaddr++;
566	}
567	p->code = copy(2, rt1, rt2);
568	}
569	}
570
571	movedat()
572	{
573	register struct node p1, p2;
574	struct node *p3;
575	register seg;
576	struct node data;
577	struct node *datp;
578
579	if (first.forw == 0)
580	return;
581	if (lastseg != TEXT && lastseg != -1) {
582	p1 = (struct node *)alloc(sizeof(first));
583	p1->op = lastseg;
584	p1->subop = 0;
585	p1->code = NULL;
586	p1->forw = first.forw;
587	p1->back = &first;
588	first.forw->back = p1;
589	first.forw = p1;
590	}
591	datp = &data;
592	for (p1 = first.forw; p1!=0; p1 = p1->forw) {
593	if (p1->op == DATA) {
594	p2 = p1->forw;
595	while (p2 && p2->op!=TEXT)
596	p2 = p2->forw;
597	if (p2==0)
598	break;
599	p3 = p1->back;
600	p1->back->forw = p2->forw;
601	p2->forw->back = p3;
602	p2->forw = 0;
603	datp->forw = p1;
604	p1->back = datp;
605	p1 = p3;
606	datp = p2;
607	}
608	}
609	if (data.forw) {
610	datp->forw = first.forw;
611	first.forw->back = datp;
612	data.forw->back = &first;
613	first.forw = data.forw;
614	}
615	seg = lastseg;
616	for (p1 = first.forw; p1!=0; p1 = p1->forw) {
617	if (p1->op==TEXT\|\|p1->op==DATA\|\|p1->op==BSS) {
618	if (p2 = p1->forw) {
619	if (p2->op==TEXT\|\|p2->op==DATA\|\|p2->op==BSS)
620	p1->op = p2->op;
621	}
622	if (p1->op == seg \|\| p1->forw&&p1->forw->op==seg) {
623	p1->back->forw = p1->forw;
624	p1->forw->back = p1->back;
625	p1 = p1->back;
626	continue;
627	}
628	seg = p1->op;
629	}
630	}
631	}
632
633	redunbr(p)
634	register struct node *p;
635	{
636	register struct node *p1;
637	register char *ap1;
638	char *ap2;
639
640	if ((p1 = p->ref) == 0)
641	return;
642	p1 = nonlab(p1);
643	if (p1->op==TST) {
644	singop(p1);
645	savereg(RT2, "$0");
646	} else if (p1->op==CMP)
647	dualop(p1);
648	else
649	return;
650	if (p1->forw->op!=CBR)
651	return;
652	ap1 = findcon(RT1);
653	ap2 = findcon(RT2);
654	p1 = p1->forw;
655	if (compare(p1->subop, ap1, ap2)>0) {
656	nredunj++;
657	nchange++;
658	decref(p->ref);
659	p->ref = p1->ref;
660	p->labno = p1->labno;
661	p->ref->refc++;
662	}
663	}
664
665	char *
666	findcon(i)
667	{
668	register char *p;
669	register r;
670
671	p = regs[i];
672	if (*p=='$')
673	return(p);
674	if ((r = isreg(p)) >= 0)
675	return(regs[r]);
676	if (equstr(p, conloc))
677	return(conval);
678	return(p);
679	}
680
681	compare(oper, cp1, cp2)
682	register char cp1, cp2;
683	{
684	register unsigned n1, n2;
685
686	if (cp1++ != '$' \|\| cp2++ != '$')
687	return(-1);
688	n1 = 0;
689	while (cp2 >= '0' && cp2 <= '7') {
690	n1 <<= 3;
691	n1 += *cp2++ - '0';
692	}
693	n2 = n1;
694	n1 = 0;
695	while (cp1 >= '0' && cp1 <= '7') {
696	n1 <<= 3;
697	n1 += *cp1++ - '0';
698	}
699	if (*cp1=='+')
700	cp1++;
701	if (*cp2=='+')
702	cp2++;
703	do {
704	if (cp1++ != cp2)
705	return(-1);
706	} while (*cp2++);
707	switch(oper) {
708
709	case JEQ:
710	return(n1 == n2);
711	case JNE:
712	return(n1 != n2);
713	case JLE:
714	return((int)n1 <= (int)n2);
715	case JGE:
716	return((int)n1 >= (int)n2);
717	case JLT:
718	return((int)n1 < (int)n2);
719	case JGT:
720	return((int)n1 > (int)n2);
721	case JLO:
722	return(n1 < n2);
723	case JHI:
724	return(n1 > n2);
725	case JLOS:
726	return(n1 <= n2);
727	case JHIS:
728	return(n1 >= n2);
729	}
730	return(-1);
731	}
732
733	setcon(ar1, ar2)
734	char ar1, ar2;
735	{
736	register char cl, cv, *p;
737
738	cl = ar2;
739	cv = ar1;
740	if (*cv != '$')
741	return;
742	if (!natural(cl))
743	return;
744	p = conloc;
745	while (p++ = cl++);
746	p = conval;
747	while (p++ = cv++);
748	}
749
750	equstr(ap1, ap2)
751	char ap1, ap2;
752	{
753	char p1, p2;
754
755	p1 = ap1;
756	p2 = ap2;
757	do {
758	if (p1++ != p2)
759	return(0);
760	} while (*p2++);
761	return(1);
762	}
763
764	setcc(ap)
765	char *ap;
766	{
767	register char p, p1;
768
769	p = ap;
770	if (!natural(p)) {
771	ccloc[0] = 0;
772	return;
773	}
774	p1 = ccloc;
775	while (p1++ = p++);
776	}
777
778	natural(ap)
779	char *ap;
780	{
781	register char *p;
782
783	p = ap;
784	if (p=='' \|\| p=='(' \|\| p=='-'&&*(p+1)=='(')
785	return(0);
786	while (*p++);
787	p--;
788	if (--p == '+' \|\| p ==')' && *--p != '5')
789	return(0);
790	return(1);
791	}