![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c21.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / c2|
Return to c21.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / c2 |
1.1 root 1: #
2: char C21[] = {"@(#)c21.c 1.59 79/01/20 11:07:52"}; /* sccs ident */
3: /*
4: * C object code improver-- second part
5: */
6:
7: #include <stdio.h>
8: #include "c2.h"
9: #include <ctype.h>
10:
11: #define NUSE 6
12: extern int ioflag;
13: int biti[NUSE] = {1,2,4,8,16,32};
14: int bitsize[4] = {0,8,16,32}; /* index by type codes */
15: int pos,siz; long f; /* for bit field communication */
16: struct node *uses[NUSE]; /* for backwards flow analysis */
17: char *lastrand; /* last operand of instruction */
18: struct node *bflow();
19: struct node *bicopt();
20: char *findcon();
21:
22: redun3(p,split) register struct node *p; int split; {
23: /* check for 3 addr instr which should be 2 addr */
24: if (OP3==((p->subop>>4)&0xF)) {
25: if (split) splitrand(p);
26: if (equstr(regs[RT1],regs[RT3])
27: && (p->op==ADD || p->op==MUL || p->op==BIS || p->op==XOR)) {
28: register char *t=regs[RT1]; regs[RT1]=regs[RT2]; regs[RT2]=t;
29: }
30: if (equstr(regs[RT2],regs[RT3])) {
31: p->subop=(p->subop&0xF)|(OP2<<4); p->pop=0;
32: lastrand=regs[RT2]; *regs[RT3]=0; return(1);
33: }
34: } return(0);
35: }
36:
37: bmove() {
38: register struct node *p, *lastp; register char *cp1,*cp2; register int r;
39: refcount();
40: for (p=lastp= &first; 0!=(p=p->forw); lastp=p);
41: clearreg(); clearuse();
42: for (p=lastp; p!= &first; p=p->back) {
43: if (debug) {
44: for (r=NUSE;--r>=0;) if (uses[r]) printf("%d: %s\n",r,uses[r]->code);
45: printf("-\n");
46: }
47: if (OP3==((p->subop>>4)&0xF) && 0!=redun3(p,1)) {newcode(p); redunm++;}
48: switch (p->op) {
49: case LABEL: case DLABEL:
50: if (p->back && p->back->op==JBR && p->back->subop!=RET)
51: for (r=NUSE; --r>=0;) if (uses[r] && regs[r][0]!= -1)
52: p->ref=(struct node *) (((int)p->ref)|biti[r]);
53: case CALLS: case 0:
54: clearuse(); break;
55: case SUB:
56: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
57: if (*cp1++!='$') goto std; splitrand(p);
58: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
59: char buf[50]; cp2=buf; *cp2++='-';
60: cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
61: cp1="(fp),"; while (*cp2++= *cp1++); --cp2;
62: cp1=regs[RT3]; while (*cp2++= *cp1++);
63: p->code=copy(buf); p->combop=T(MOVA,LONG); p->pop=0;
64: } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
65: p->op=ADD; p->pop=0; *--cp1='$'; p->code=cp1;
66: } goto std;
67: case ADD:
68: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
69: if (*cp1++!='$') goto std; splitrand(p);
70: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
71: cp2=cp1-1; cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
72: cp1="(fp)"; while (*cp2++= *cp1++); *--cp2=',';
73: p->combop=T(MOVA,LONG); p->pop=0;
74: } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
75: p->op=SUB; p->pop=0; *--cp1='$'; p->code=cp1;
76: }
77: case CASE:
78: default: std:
79: p=bflow(p); break;
80: case JBR:
81: if (p->subop==RET) {uses[0]=p; regs[0][0]= -1; break;}
82: else if (p->ref->ref!=0) for (r=NUSE;--r>=0;)
83: if (biti[r] & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;}
84: case CBR: case JMP: case EROU: case JSW:
85: case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ;
86: }
87: }
88: }
89:
90: rmove()
91: {
92: register struct node *p, *lastp;
93: register int r;
94: int r1;
95:
96: clearreg();
97: for (p=first.forw; p!=0; p = p->forw) {
98: lastp=p;
99: if (debug) {
100: for (r=0; r<NREG; r++)
101: if (regs[r][0]) {
102: r1=regs[r][0];
103: printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1);
104: }
105: printf("-\n");
106: }
107: switch (p->op) {
108:
109: case CVT:
110: splitrand(p); goto mov;
111:
112: case MOV:
113: splitrand(p);
114: if ((r = findrand(regs[RT1],p->subop)) >= 0) {
115: if (r == isreg(regs[RT2]) && p->forw->op!=CBR) {
116: delnode(p); redunm++; break;
117: }
118: }
119: mov:
120: repladdr(p);
121: r = isreg(regs[RT1]);
122: r1 = isreg(regs[RT2]);
123: dest(regs[RT2],p->subop);
124: if (r >= 0)
125: if (r1 >= 0) savereg(r1, regs[r]+1, p->subop);
126: else savereg(r, regs[RT2], p->subop);
127: else
128: if (r1 >= 0) savereg(r1, regs[RT1], p->subop);
129: else setcon(regs[RT1], regs[RT2], p->subop);
130: break;
131:
132: /* .rx,.wx */
133: case COM:
134: case NEG:
135: /* .rx,.wx or .rx,.rx,.wx */
136: case ADD:
137: case SUB:
138: case BIC:
139: case BIS:
140: case XOR:
141: case MUL:
142: case DIV:
143: case ASH:
144: case MOVZ:
145: /* .rx,.rx,.rx,.wx */
146: case EXTV:
147: case EXTZV:
148: case INSV:
149: splitrand(p);
150: repladdr(p);
151: dest(lastrand,p->subop);
152: if (p->op==INSV) ccloc[0]=0;
153: break;
154:
155: /* .mx or .wx */
156: case CLR:
157: case INC:
158: case DEC:
159: splitrand(p);
160: dest(lastrand,p->subop);
161: if (p->op==CLR)
162: if ((r = isreg(regs[RT1])) >= 0)
163: savereg(r, "$0", p->subop);
164: else
165: setcon("$0", regs[RT1], p->subop);
166: break;
167:
168: /* .rx */
169: case TST:
170: case PUSH:
171: splitrand(p);
172: lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */
173: repladdr(p);
174: if (p->op==TST && equstr(lastrand=regs[RT1], ccloc+1)
175: && equtype(ccloc[0],p->subop) &&!source(lastrand)) {
176: delnode(p); p = p->back; nrtst++; nchange++;
177: }
178: setcc(lastrand,p->subop);
179: break;
180:
181: /* .rx,.rx,.rx */
182: case CASE:
183: /* .rx,.rx */
184: case CALLS:
185: case CMP:
186: case BIT:
187: splitrand(p);
188: /* fool repladdr into doing right number of operands */
189: if (p->op!=CASE) lastrand=regs[RT3]; else lastrand=regs[RT4];
190: repladdr(p);
191: if (p->op==CALLS) clearreg();
192: if (p->op==BIT) bitopt(p);
193: ccloc[0]=0; break;
194:
195: case CBR:
196: if (p->subop>=JBC) {/* 2 operands can be optimized */
197: splitrand(p); lastrand=regs[RT3]; repladdr(p);
198: }
199: ccloc[0] = 0;
200: break;
201:
202: case JBR:
203: redunbr(p);
204:
205: /* .wx,.bb */
206: case SOB:
207:
208: default:
209: clearreg();
210: }
211: }
212: }
213:
214: char *
215: byondrd(p) register struct node *p; {
216: /* return pointer to register which is "beyond last read/modify operand" */
217: if (OP2==(p->subop>>4)) return(regs[RT3]);
218: switch (p->op) {
219: case PUSHA:
220: case TST: case INC: case DEC: case PUSH: return(regs[RT2]);
221: case BIT: case CMP: case CALLS: return(regs[RT3]);
222: case CASE: return(regs[RT4]);
223: }
224: return(lastrand);
225: }
226:
227: struct node *
228: bflow(p) register struct node *p; {
229: register char *cp1,*cp2,**preg; register int r;
230: splitrand(p);
231: if (0<=(r=isreg(lastrand)) && r<NUSE && p->op!=PUSH &&
232: uses[r]==p->forw && p->subop && equtype(regs[r][0],p->subop)) {
233: if (regs[r][1]!=0) {/* send directly to destination */
234: if (p->op==INC || p->op==DEC) {
235: if (p->op==DEC) p->op=SUB; else p->op=ADD;
236: p->subop=(OP2<<4)+(p->subop&0xF); /* use 2 now, convert to 3 later */
237: p->pop=0;
238: cp1=lastrand; cp2=regs[RT2]; while (*cp2++= *cp1++); /* copy reg */
239: cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0;
240: }
241: cp1=regs[r]+1; cp2=lastrand;
242: if (OP2==(p->subop>>4)) {/* use 3 operand form of instruction */
243: p->pop=0;
244: p->subop += (OP3-OP2)<<4; lastrand=cp2=regs[RT3];
245: }
246: while (*cp2++= *cp1++);
247: if (p->op==MOVA && p->forw->op==PUSH) {
248: p->op=PUSHA; *regs[RT2]=0; p->pop=0;
249: }
250: delnode(p->forw);
251: redun3(p,0);
252: newcode(p); redunm++; uses[r]=0; *(short *)(regs[r])=0;
253: } else if (p->op==MOV && p->forw->op!=EXTV && p->forw->op!=EXTZV) {
254: /* superfluous fetch */
255: int nmatch;
256: char src[20]; cp2=src; cp1=regs[RT1]; while (*cp2++= *cp1++);
257: splitrand(p->forw); lastrand=byondrd(p->forw); nmatch=0;
258: for (preg=regs+RT1;*preg!=lastrand;preg++) if (r==isreg(*preg)) {
259: cp2= *preg; cp1=src; while (*cp2++= *cp1++); ++nmatch;
260: }
261: if (nmatch==1) {
262: if (OP2==(p->forw->subop>>4) && equstr(src,regs[RT2])) {
263: p->forw->pop=0;
264: p->forw->subop += (OP3-OP2)<<4; cp1=regs[RT3];
265: *cp1++='r'; *cp1++=r+'0'; *cp1=0;
266: }
267: delnode(p); p=p->forw;
268: redun3(p,0);
269: newcode(p); redunm++; uses[r]=0; *(short *)(regs[r])=0;
270: }
271: }
272: }
273: /* adjust 'lastrand' past any 'read' or 'modify' operands. */
274: lastrand=byondrd(p);
275: /* a 'write' clobbers the register. */
276: if (0<=(r=isreg(lastrand)) && r<NUSE
277: || OP2==(p->subop>>4) && 0<=(r=isreg(regs[RT2])) && r<NUSE)
278: {uses[r]=0; *(short *)(regs[r])=0;}
279: if (p->op==BIC) {p=bicopt(p); splitrand(p); lastrand=byondrd(p);}
280: if (p->op==BIS) bixprep(p,JBSS);
281: /* now look for 'read' or 'modify' (read & write) uses */
282: preg=regs+RT1;
283: while (*(cp1= *preg++)) {
284: /* check for r */
285: if (lastrand!=cp1 && 0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0) {
286: uses[r]=p; cp2=regs[r]; *cp2++=p->subop;
287: if (p->op==MOV || p->op==PUSH) {
288: if (p->op==PUSH) cp1="-(sp)"; else cp1=regs[RT2];
289: while (*cp2++= *cp1++);
290: } else *cp2++=0;
291: continue;
292: }
293: /* check for (r),(r)+,-(r),[r] */
294: do if (*cp1=='(' || *cp1=='[') {/* get register number */
295: char t;
296: cp2= ++cp1; while (*++cp1!=')' && *cp1!=']'); t= *cp1; *cp1=0;
297: if (0<=(r=isreg(cp2)) && r<NUSE && (uses[r]==0 || uses[r]==p)) {
298: uses[r]=p; regs[r][0]=(*--cp2=='[' ? OPX<<4 : OPB<<4);
299: }
300: *cp1=t;
301: } while (*++cp1);
302: }
303: /* pushax or movax possibility? */
304: cp1=regs[RT1];
305: if (*cp1++=='$'
306: && (*cp1=='_' || *cp1=='L' || (*cp1++=='v' && *cp1=='.'))
307: && natural(regs[RT1])) {
308: if (p->combop==T(MOV,LONG)) {
309: if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) {
310: cp1=p->code; while (*cp1++!=','); p->code= --cp1;
311: }
312: p->combop=T(MOVA,LONG); ++p->code; p->pop=0;
313: } else if (p->combop==T(PUSH,LONG)) {
314: p->combop=T(PUSHA,LONG); ++p->code; p->pop=0;
315: } else if ((p->combop&0xFFFF)==T(ADD,U(LONG,OP3))
316: && 0<=(r=isreg(regs[RT2]))) {
317: cp1=cp2=p->code; ++cp1;
318: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='[';
319: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']';
320: if (!equstr(regs[RT3],"-(sp)")) p->combop=T(MOVA,BYTE);
321: else {p->combop=T(PUSHA,BYTE); *cp2=0;}
322: if (uses[r]==0) {uses[r]=p; regs[r][0]=OPX<<4;}
323: p->pop=0;
324: }
325: }
326: return(p);
327: }
328:
329: ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
330: register int log;
331: if (n==0 || n&(n-1)) return(-1); log=0;
332: for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
333: }
334:
335: bitopt(p) register struct node *p; {
336: /* change "bitx $<power_of_2>,a" followed by JEQ or JNE
337: /* into JBC or JBS. watch out for I/O registers. (?)
338: /* assumes that 'splitrand' has already been called.
339: */
340: register char *cp1,*cp2; int b;
341: cp1=regs[RT1]; cp2=regs[RT2];
342: if (*cp1++!='$' || !okio(cp2) || p->forw->op!=CBR || p->forw->subop&-2 ||
343: 0>(b=ispow2(getnum(cp1))) || p->subop!=BYTE && indexa(cp2)) return;
344: if (b>=bitsize[p->subop]) {/* you dummy! */
345: if (source(cp2)) {/* side effect: auto increment or decrement */
346: p->pop=0;
347: p->op=TST; --cp1; while (*cp1++= *cp2++);
348: regs[RT2][0]=0; newcode(p);
349: } else delnode(p);
350: p = p->forw;
351: if (p->subop==JEQ) {p->combop=JBR; p->pop=0;}
352: else delnode(p);
353: nchange++; nbj++; return;
354: }
355: if (cp1=p->forw->code) {/* destination is not an internal label */
356: cp2=regs[RT3]; while (*cp2++= *cp1++);
357: }
358: if (b==0 && (p->subop==LONG || !indexa(regs[RT2]))) {/* JLB optimization, ala BLISS */
359: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++);
360: cp2=regs[RT2]; cp1=regs[RT3]; while (*cp2++= *cp1++);
361: *(regs[RT3])=0; p->forw->subop += JLBC-JBC;
362: p->forw->pop=0;
363: } else {
364: cp1=regs[RT1]+1;
365: if (b>9) *cp1++= b/10 +'0'; *cp1++= b%10 +'0'; *cp1=0; /* $<bit_number> */
366: }
367: nbj++; newcode(p); p->combop = p->forw->combop+((JBC-JEQ)<<8);
368: p->labno = p->forw->labno; delnode(p->forw);
369: p->pop=0;
370: }
371:
372: isfield(n) register long n; {/* -1 -> no; else -> position of low bit */
373: register int pos; register long t;
374: t= ((n-1)|n) +1;
375: if (n!=0 && (0==t || 0==n || 0<=ispow2(t))) {
376: pos=0; while(!(n&1)) {n >>= 1; ++pos;} return(pos);
377: } else return(-1);
378: }
379:
380: bixprep(p,bix) register struct node *p; {
381: /* initial setup, single-bit checking for bisopt, bicopt.
382: /* return: 0->don't bother any more; 1->worthwhile trying
383: */
384: register char *cp1,*cp2;
385: splitrand(p); cp1=regs[RT1]; cp2=regs[RT2];
386: if (*cp1++!='$' || 0>(pos=isfield(f=getnum(cp1)))
387: || !okio(cp2) || indexa(cp2) || source(cp2) || !okio(lastrand)) return(0);
388: f |= f-1; if (++f==0) siz=32-pos; else siz=ispow2(f)-pos;
389: if (siz==1 && pos>5 && (p->subop>>4)==OP2 && (p->subop&0xF)!=BYTE
390: && pos<bitsize[p->subop&0xF]) {
391: p->ref = insertl(p->forw); p->combop = CBR | (bix<<8);
392: p->pop=0;
393: p->labno = p->ref->labno;
394: if (pos>9) {*cp1++= pos/10 +'0'; pos %= 10;}
395: *cp1++=pos+'0'; *cp1=0; newcode(p); nbj++; return(0);
396: }
397: return(1);
398: }
399:
400:
401: struct node *
402: bicopt(p) register struct node *p; {
403: /* use field operations or MOVZ if possible. done as part of 'bflow'.
404: */
405: register char *cp1,*cp2; int r;
406: char src[50];
407: if (!bixprep(p,JBCC)) return(p);
408: if (f<=0) {/* the BIC isolates low order bits */
409: siz=pos; pos=0;
410: if ((p->subop&0xF)==LONG && *(regs[RT2])!='$') {/* result of EXTZV is long */
411: /* save source of BICL in 'src' */
412: cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
413: if (p->back->op==ASH) {/* try for more */
414: splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT3];
415: if (*cp1++=='$' && *(regs[RT2])!='$' && !indexa(regs[RT2])
416: && 0>(f=getnum(cp1)) && equstr(src,cp2)
417: && 0<=(r=isreg(cp2)) && r<NUSE && uses[r]==0) {/* a good ASH */
418: pos -= f; cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
419: delnode(p->back);
420: }
421: }
422: if (p->back->op==CVT || p->back->op==MOVZ) {/* greedy, aren't we? */
423: splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT2];
424: if (equstr(src,cp2) && okio(cp1) && !indexa(cp1)
425: && 0<=(r=isreg(cp2)) && r<NUSE && uses[r]==0
426: && bitsize[p->back->subop&0xF]>=(pos+siz)
427: && bitsize[p->back->subop>>4]>=(pos+siz)) {/* good CVT */
428: cp1=regs[RT1]; cp2=src; while (*cp2++= *cp1++);
429: delnode(p->back);
430: }
431: }
432: /* 'pos', 'siz' known; source of field is in 'src' */
433: splitrand(p); /* retrieve destination of BICL */
434: if (siz==8 && pos==0) {
435: p->combop = T(MOVZ,U(BYTE,LONG));
436: sprintf(line,"%s,%s",src,lastrand);
437: } else {
438: p->combop = T(EXTZV,LONG);
439: sprintf(line,"$%d,$%d,%s,%s",pos,siz,src,lastrand);
440: }
441: p->pop=0;
442: p->code = copy(line); nfield++; return(p);
443: }/* end EXTZV possibility */
444: }/* end low order bits */
445: /* unfortunately, INSV clears the condition codes, thus cannot be used */
446: /* else {/* see if BICL2 of positive field should be INSV $0 */
447: /* if (p->subop==(LONG | (OP2<<4)) && 6<=(pos+siz)) {
448: /* p->combop = INSV;
449: /* sprintf(line,"$0,$%d,$%d,%s",pos,siz,lastrand);
450: /* p->code = copy(line); nfield++; return(p);
451: /* }
452: /* }
453: */
454: return(p);
455: }
456:
457: jumpsw()
458: {
459: register struct node *p, *p1;
460: register t;
461: int nj;
462:
463: t = 0;
464: nj = 0;
465: for (p=first.forw; p!=0; p = p->forw)
466: p->seq = ++t;
467: for (p=first.forw; p!=0; p = p1) {
468: p1 = p->forw;
469: if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
470: && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) {
471: if (p->ref==p1->ref)
472: continue;
473: p->subop = revbr[p->subop];
474: p->pop=0;
475: t = p1->ref;
476: p1->ref = p->ref;
477: p->ref = t;
478: t = p1->labno;
479: p1->labno = p->labno;
480: p->labno = t;
481: nrevbr++;
482: nj++;
483: }
484: }
485: return(nj);
486: }
487:
488: addsob()
489: {
490: register struct node *p, *p1, *p2, *p3;
491:
492: for (p = &first; (p1 = p->forw)!=0; p = p1) {
493: if (p->combop==T(DEC,LONG) && p1->op==CBR) {
494: if (abs(p->seq - p1->ref->seq) > 12) continue;
495: if (p1->subop==JGE || p1->subop==JGT) {
496: if (p1->subop==JGE) p->combop=SOBGEQ; else p->combop=SOBGTR;
497: p->pop=0;
498: p->labno = p1->labno; delnode(p1); nsob++;
499: }
500: } else if (p->combop==T(INC,LONG)) {
501: if (p1->op==LABEL && p1->refc==1 && p1->forw->combop==T(CMP,LONG)
502: && (p2=p1->forw->forw)->combop==T(CBR,JLE)
503: && (p3=p2->ref->back)->combop==JBR && p3->ref==p1
504: && p3->forw->op==LABEL && p3->forw==p2->ref) {
505: /* change INC LAB: CMP to LAB: INC CMP */
506: p->back->forw=p1; p1->back=p->back;
507: p->forw=p1->forw; p1->forw->back=p;
508: p->back=p1; p1->forw=p;
509: p1=p->forw;
510: /* adjust beginning value by 1 */
511: p2=alloc(sizeof first); p2->combop=T(DEC,LONG);
512: p2->pop=0;
513: p2->forw=p3; p2->back=p3->back; p3->back->forw=p2;
514: p3->back=p2; p2->code=p->code; p2->labno=0;
515: }
516: if (p1->combop==T(CMP,LONG) && (p2=p1->forw)->op==CBR) {
517: register char *cp1,*cp2;
518: splitrand(p1); if (!equstr(p->code,regs[RT1])) continue;
519: if (abs(p->seq - p2->ref->seq)>12) {/* outside byte displ range */
520: if (p2->subop!=JLE) continue;
521: p->combop=T(ACB,LONG);
522: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
523: cp2=regs[RT2]; cp1="$1"; while (*cp2++= *cp1++); /* increment */
524: cp2=regs[RT3]; cp1=p->code; while (*cp2++= *cp1++); /* index */
525: p->pop=0; newcode(p);
526: p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
527: } else if (p2->subop==JLE || p2->subop==JLT) {
528: if (p2->subop==JLE) p->combop=AOBLEQ; else p->combop=AOBLSS;
529: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
530: cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */
531: p->pop=0; newcode(p);
532: p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
533: }
534: }
535: }
536: }
537: }
538:
539: abs(x)
540: {
541: return(x<0? -x: x);
542: }
543:
544: equop(p1, p2)
545: register struct node *p1;
546: struct node *p2;
547: {
548: register char *cp1, *cp2;
549:
550: if (p1->combop != p2->combop)
551: return(0);
552: if (p1->op>0 && p1->op<MOV)
553: return(0);
554: if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
555: cp1 = p1->code;
556: cp2 = p2->code;
557: if (cp1==0 && cp2==0)
558: return(1);
559: if (cp1==0 || cp2==0)
560: return(0);
561: while (*cp1 == *cp2++)
562: if (*cp1++ == 0)
563: return(1);
564: return(0);
565: }
566:
567: delnode(p) register struct node *p; {
568: p->back->forw = p->forw;
569: p->forw->back = p->back;
570: }
571:
572: decref(p)
573: register struct node *p;
574: {
575: if (p && --p->refc <= 0) {
576: nrlab++;
577: delnode(p);
578: }
579: }
580:
581: struct node *
582: nonlab(ap)
583: struct node *ap;
584: {
585: register struct node *p;
586:
587: p = ap;
588: while (p && p->op==LABEL)
589: p = p->forw;
590: return(p);
591: }
592:
593: clearuse() {
594: register struct node **i;
595: for (i=uses+NUSE; i>uses;) *--i=0;
596: }
597:
598: clearreg() {
599: register short **i;
600: for (i=regs+NREG; i>regs;) **--i=0;
601: conloc[0] = 0; ccloc[0] = 0;
602: }
603:
604: savereg(ai, s, type)
605: register char *s;
606: {
607: register char *p, *sp;
608:
609: sp = p = regs[ai];
610: if (source(s)) /* side effects in addressing */
611: return;
612: /* if any indexing, must be parameter or local */
613: /* indirection (as in "*-4(fp)") is ok, however */
614: *p++ = type;
615: while (*p++ = *s)
616: if (*s=='[' || *s++=='(' && *s!='a' && *s!='f') {*sp = 0; return;}
617: }
618:
619: dest(s,type)
620: register char *s;
621: {
622: register int i;
623:
624: source(s); /* handle addressing side effects */
625: if ((i = isreg(s)) >= 0) {
626: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */
627: if (DOUBLE==(type&0xF) || DOUBLE==((type>>4)&0xF))
628: *(short *)(regs[i+1]) = 0; /* clobber two at once */
629: }
630: for (i=NREG; --i>=0;)
631: if (regs[i][1]=='*' && equstr(s, regs[i]+2))
632: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */
633: while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */
634: *(short *)(regs[i]) = 0;
635: if (!natural(s)) {/* wild store, everything except constants vanishes */
636: for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0;
637: conloc[0] = 0; ccloc[0] = 0;
638: } else setcc(s,type); /* natural destinations set condition codes */
639: }
640:
641: splitrand(p) struct node *p; {
642: /* separate operands at commas, set up 'regs' and 'lastrand' */
643: register char *p1, *p2; register char **preg;
644: preg=regs+RT1;
645: if (p1=p->code) while (*p1) {
646: lastrand=p2= *preg++;
647: while (*p1) if (','==(*p2++= *p1++)) {--p2; break;}
648: *p2=0;
649: }
650: while (preg<(regs+RT1+5)) *(*preg++)=0;
651: }
652:
653: compat(have, want) {
654: register int hsrc, hdst;
655: if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */
656: hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc;
657: /* last term prevents floats, doubles from satisfying a request for an int */
658: return(hsrc>=want && hdst>=want && !((want>=FLOAT) ^ (hdst>=FLOAT)));
659: }
660:
661: equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));}
662:
663: findrand(as, type)
664: char *as;
665: {
666: register char **i;
667: for (i = regs+NREG; --i>=regs;) {
668: if (**i && equstr(*i+1, as) && compat(**i,type))
669: return(i-regs);
670: }
671: return(-1);
672: }
673:
674: isreg(s)
675: register char *s;
676: {
677: if (*s++!='r' || !isdigit(*s++)) return(-1);
678: if (*s==0) return(*--s-'0');
679: if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0');
680: return(-1);
681: }
682:
683: check()
684: {
685: register struct node *p, *lp;
686:
687: lp = &first;
688: for (p=first.forw; p!=0; p = p->forw) {
689: if (p->back != lp)
690: abort(-1);
691: lp = p;
692: }
693: }
694:
695: source(ap)
696: char *ap;
697: {
698: register char *p1, *p2;
699:
700: p1 = ap;
701: p2 = p1;
702: if (*p1==0)
703: return(0);
704: while (*p2++ && *(p2-1)!='[');
705: if (*p1=='-' && *(p1+1)=='('
706: || *p1=='*' && *(p1+1)=='-' && *(p1+2)=='('
707: || *(p2-2)=='+') {
708: while (*p1 && *p1++!='r');
709: if (isdigit(*p1++))
710: if (isdigit(*p1)) *(short *)(regs[10+*p1-'0'])=0;
711: else *(short *)(regs[*--p1-'0'])=0;
712: return(1);
713: }
714: return(0);
715: }
716:
717: newcode(p) struct node *p; {
718: register char *p1,*p2,**preg;
719: preg=regs+RT1; p2=line;
720: while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';}
721: *--p2=0;
722: p->code=copy(line);
723: }
724:
725: repladdr(p)
726: struct node *p;
727: {
728: register r;
729: register char *p1, *p2;
730: char **preg; int nrepl;
731:
732: preg=regs+RT1; nrepl=0;
733: while (lastrand!=(p1= *preg++))
734: if (!source(p1) && 0<=(r=findrand(p1,p->subop))) {
735: *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0;
736: nrepl++; nsaddr++;
737: }
738: if (nrepl) newcode(p);
739: }
740:
741: /* movedat()
742: /* {
743: /* register struct node *p1, *p2;
744: /* struct node *p3;
745: /* register seg;
746: /* struct node data;
747: /* struct node *datp;
748: /*
749: /* if (first.forw == 0)
750: /* return;
751: /* datp = &data;
752: /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
753: /* if (p1->op == DATA) {
754: /* p2 = p1->forw;
755: /* while (p2 && p2->op!=TEXT)
756: /* p2 = p2->forw;
757: /* if (p2==0)
758: /* break;
759: /* p3 = p1->back;
760: /* p1->back->forw = p2->forw;
761: /* p2->forw->back = p3;
762: /* p2->forw = 0;
763: /* datp->forw = p1;
764: /* p1->back = datp;
765: /* p1 = p3;
766: /* datp = p2;
767: /* }
768: /* }
769: /* if (data.forw) {
770: /* datp->forw = first.forw;
771: /* first.forw->back = datp;
772: /* data.forw->back = &first;
773: /* first.forw = data.forw;
774: /* }
775: /* seg = -1;
776: /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
777: /* if (p1->op==TEXT||p1->op==DATA||p1->op==BSS) {
778: /* if (p1->op == seg || p1->forw&&p1->forw->op==seg) {
779: /* p1->back->forw = p1->forw;
780: /* p1->forw->back = p1->back;
781: /* p1 = p1->back;
782: /* continue;
783: /* }
784: /* seg = p1->op;
785: /* }
786: /* }
787: /* }
788: */
789:
790: redunbr(p)
791: register struct node *p;
792: {
793: register struct node *p1;
794: register char *ap1;
795: char *ap2;
796:
797: if ((p1 = p->ref) == 0)
798: return;
799: p1 = nonlab(p1);
800: if (p1->op==TST) {
801: splitrand(p1);
802: savereg(RT2, "$0", p1->subop);
803: } else if (p1->op==CMP)
804: splitrand(p1);
805: else
806: return;
807: if (p1->forw->op==CBR) {
808: ap1 = findcon(RT1, p1->subop);
809: ap2 = findcon(RT2, p1->subop);
810: p1 = p1->forw;
811: if (compare(p1->subop, ap1, ap2)) {
812: nredunj++;
813: nchange++;
814: decref(p->ref);
815: p->ref = p1->ref;
816: p->labno = p1->labno;
817: p->ref->refc++;
818: }
819: } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) &&
820: equtype(ccloc[0],p1->subop)) {
821: p1=insertl(p1->forw); decref(p->ref); p->ref=p1;
822: nrtst++; nchange++;
823: }
824: }
825:
826: char *
827: findcon(i, type)
828: {
829: register char *p;
830: register r;
831:
832: p = regs[i];
833: if (*p=='$')
834: return(p);
835: if ((r = isreg(p)) >= 0 && compat(regs[r][0],type))
836: return(regs[r]+1);
837: if (equstr(p, conloc))
838: return(conval+1);
839: return(p);
840: }
841:
842: compare(op, acp1, acp2)
843: char *acp1, *acp2;
844: {
845: register char *cp1, *cp2;
846: register n1;
847: int n2; int sign;
848:
849: cp1 = acp1;
850: cp2 = acp2;
851: if (*cp1++ != '$' || *cp2++ != '$')
852: return(0);
853: n1 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;}
854: while (isdigit(*cp2)) {n1 *= 10; n1 += (*cp2++ - '0')*sign;}
855: n2 = n1;
856: n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;}
857: while (isdigit(*cp1)) {n1 *= 10; n1 += (*cp1++ - '0')*sign;}
858: if (*cp1=='+')
859: cp1++;
860: if (*cp2=='+')
861: cp2++;
862: do {
863: if (*cp1++ != *cp2)
864: return(0);
865: } while (*cp2++);
866: cp1 = n1;
867: cp2 = n2;
868: switch(op) {
869:
870: case JEQ:
871: return(cp1 == cp2);
872: case JNE:
873: return(cp1 != cp2);
874: case JLE:
875: return(((int)cp1) <= ((int)cp2));
876: case JGE:
877: return(((int)cp1) >= ((int)cp2));
878: case JLT:
879: return(((int)cp1) < ((int)cp2));
880: case JGT:
881: return(((int)cp1) > ((int)cp2));
882: case JLO:
883: return(cp1 < cp2);
884: case JHI:
885: return(cp1 > cp2);
886: case JLOS:
887: return(cp1 <= cp2);
888: case JHIS:
889: return(cp1 >= cp2);
890: }
891: return(0);
892: }
893:
894: setcon(cv, cl, type)
895: register char *cv, *cl;
896: {
897: register char *p;
898:
899: if (*cv != '$')
900: return;
901: if (!natural(cl))
902: return;
903: p = conloc;
904: while (*p++ = *cl++);
905: p = conval;
906: *p++ = type;
907: while (*p++ = *cv++);
908: }
909:
910: equstr(p1, p2)
911: register char *p1, *p2;
912: {
913: do {
914: if (*p1++ != *p2)
915: return(0);
916: } while (*p2++);
917: return(1);
918: }
919:
920: setcc(ap,type)
921: char *ap;
922: {
923: register char *p, *p1;
924:
925: p = ap;
926: if (!natural(p)) {
927: ccloc[0] = 0;
928: return;
929: }
930: p1 = ccloc;
931: *p1++ = type;
932: while (*p1++ = *p++);
933: }
934:
935: okio(p) register char *p; {/* 0->probable I/O space address; 1->not */
936: if (ioflag && (!natural(p) || 0>getnum(p))) return(0);
937: return(1);
938: }
939:
940: indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */
941: while (*p) if (*p++=='[') return(1);
942: return(0);
943: }
944:
945: natural(p)
946: register char *p;
947: {/* 1->simple local, parameter, global, or register; 0->otherwise */
948: if (*p=='*' || *p=='(' || *p=='-'&&*(p+1)=='(' || *p=='$'&&getnum(p+1))
949: return(0);
950: while (*p++);
951: p--;
952: if (*--p=='+' || *p==']' || *p==')' && *(p-2)!='a' && *(p-2)!='f')
953: return(0);
954: return(1);
955: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.