![[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] / 42BSD / lib / c2|
Return to c21.c CVS log | Up to [CSRG BSD Unix] / 42BSD / lib / c2 |
1.1 root 1: static char sccsid[] = "@(#)c21.c 4.9 5/27/82";
2: /* char C21[] = {"@(#)c21.c 1.83 80/10/16 21:18:22 JFR"}; /* sccs ident */
3:
4: /*
5: * C object code improver-- second part
6: */
7:
8: #include "c2.h"
9: #include <stdio.h>
10: #include <ctype.h>
11:
12: #define NUSE 6
13: int ioflag;
14: int biti[NUSE] = {1,2,4,8,16,32};
15: int bitsize[] = { /* index by type codes */
16: 0, /* 0 not allocated */
17: 8, /* 1 BYTE */
18: 16, /* 2 WORD */
19: 32, /* 3 LONG */
20: 32, /* 4 FFLOAT /
21: 64, /* 5 DFLOAT */
22: 64, /* 6 QUAD */
23: 0, /* 7 OP2 */
24: 0, /* 8 OP3 */
25: 0, /* 9 OPB */
26: 0, /* 10 OPX */
27: 64, /* 11 GFLOAT */
28: 128, /* 12 HFLOAT */
29: 128 /* 13 OCTA */
30: };
31: int pos,siz; long f; /* for bit field communication */
32: struct node *uses[NUSE]; /* for backwards flow analysis */
33: char *lastrand; /* last operand of instruction */
34: struct node *bflow();
35: struct node *bicopt();
36: char *findcon();
37:
38: redun3(p,split) register struct node *p; int split; {
39: /* check for 3 addr instr which should be 2 addr */
40: if (OP3==((p->subop>>4)&0xF)) {
41: if (split) splitrand(p);
42: if (equstr(regs[RT1],regs[RT3])
43: && (p->op==ADD || p->op==MUL || p->op==BIS || p->op==XOR)) {
44: register char *t=regs[RT1]; regs[RT1]=regs[RT2]; regs[RT2]=t;
45: }
46: if (equstr(regs[RT2],regs[RT3])) {
47: p->subop=(p->subop&0xF)|(OP2<<4); p->pop=0;
48: lastrand=regs[RT2]; *regs[RT3]=0; return(1);
49: }
50: } return(0);
51: }
52:
53: bmove() {
54: register struct node *p, *lastp; register char *cp1,*cp2; register int r;
55: refcount();
56: for (p=lastp= &first; 0!=(p=p->forw); lastp=p);
57: clearreg(); clearuse();
58: for (p=lastp; p!= &first; p=p->back) {
59: if (debug) {
60: printf("Uses:\n");
61: for (r=NUSE;--r>=0;) if (uses[r])
62: printf("%d: %s\n",r,uses[r]->code? uses[r]->code:"");
63: printf("-\n");
64: }
65: r=(p->subop>>4)&0xF;
66: if (OP2==r && (cp1=p->code, *cp1++)=='$' && *cp1++=='0' && *cp1++==',' &&
67: !source(cp1)) {/* a no-op unless MUL or DIV */
68: if (p->op==MUL) {p->op=MOV; p->subop&=0xF; p->pop=0;}
69: else if (p->op==DIV) fprintf(stderr,"c2: zero divide\n");
70: else {delnode(p); redunm++; continue;}
71: }
72: if (OP3==r && 0!=redun3(p,1)) {newcode(p); redunm++;}
73: switch (p->op) {
74: case LABEL: case DLABEL:
75: for (r=NUSE; --r>=0;)
76: if (uses[r]) p->ref=(struct node *) (((int)p->ref)|biti[r]);
77: break;
78: case CALLS:
79: clearuse(); goto std;
80: case 0:
81: clearuse(); break;
82: case SUB:
83: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
84: if (*cp1++!='$') goto std; splitrand(p);
85: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
86: char buf[C2_ASIZE]; cp2=buf; *cp2++='-';
87: cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
88: cp1="(fp),"; while (*cp2++= *cp1++); --cp2;
89: cp1=regs[RT3]; while (*cp2++= *cp1++);
90: p->code=copy(buf); p->combop=T(MOVA,LONG); p->pop=0;
91: } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
92: p->op=ADD; p->pop=0; *--cp1='$'; p->code=cp1;
93: } goto std;
94: case ADD:
95: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
96: if (*cp1++!='$') goto std; splitrand(p);
97: if (isstatic(cp1) && (r=isreg(regs[RT2]))>=0 && r<NUSE && uses[r]==p->forw)
98: {
99: /* address comp:
100: ** addl2 $_foo,r0 \ movab _foo[r0],bar
101: ** movl r0,bar /
102: */
103: register struct node *pnext = p->forw;
104: char buf[C2_ASIZE];
105:
106: if (pnext->op == MOV && pnext->subop == LONG)
107: {
108: cp1 = ®s[RT1][1]; cp2 = &buf[0];
109: while (*cp2++ = *cp1++) ; cp2--;
110: splitrand(pnext);
111: if (r == isreg(regs[RT1]))
112: {
113: delnode(p); p = pnext;
114: p->op = MOVA; p->subop = BYTE;
115: p->pop = 0;
116: cp1 = regs[RT1]; *cp2++ = '[';
117: while (*cp2++ = *cp1++) ; cp2--;
118: *cp2++ = ']'; *cp2++ = ',';
119: cp1 = regs[RT2];
120: while (*cp2++ = *cp1++) ;
121: p->code = copy(buf);
122: }
123: }
124: }
125: else
126: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
127: cp2=cp1-1; cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
128: cp1="(fp)"; while (*cp2++= *cp1++); *--cp2=',';
129: p->combop=T(MOVA,LONG); p->pop=0;
130: } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
131: p->op=SUB; p->pop=0; *--cp1='$'; p->code=cp1;
132: }
133: /* fall thru ... */
134: case CASE:
135: default: std:
136: p=bflow(p); break;
137: case MUL:
138: {
139: /*
140: ** Change multiplication by constant powers of 2 to
141: ** shifts.
142: */
143: splitrand(p);
144: if (regs[RT1][0] != '$' || regs[RT1][1] == '-') goto std;
145: if ((r = ispow2(getnum(®s[RT1][1]))) < 0) goto std;
146: switch (r)
147: {
148: case 0: /* mull3 $1,x,y */
149: if (p->subop == U(LONG,OP3))
150: {
151: if (equstr(regs[RT2], regs[RT3]))
152: {
153: delnode(p); p = p->forw;
154: }
155: else
156: {
157: p->op = MOV; p->subop = LONG;
158: p->pop = 0; newcode(p); nchange++;
159: }
160: }
161: else
162: if (p->subop == U(LONG,OP2))
163: {
164: delnode(p); p = p->forw;
165: }
166: goto std;
167:
168: case 1: /* mull2 $2,x */
169: if (p->subop == U(LONG, OP2) && !source(regs[RT2]))
170: {
171: strcpy(regs[RT1], regs[RT2]);
172: p->op = ADD; p->pop = 0; newcode(p); nchange++;
173: }
174: goto std;
175: }
176: if(p->subop==U(LONG,OP3)||(p->subop==U(LONG,OP2)&&!source(regs[RT2])))
177: {
178: if (p->subop == U(LONG,OP2))
179: strcpy(regs[RT3], regs[RT2]);
180: sprintf(regs[RT1], "$%d", r);
181: p->op = ASH; p->subop = LONG;
182: p->pop = 0; newcode(p); nchange++;
183: }
184: goto std;
185: }
186: case ASH:
187: {
188: /* address comp:
189: ** ashl $1,bar,r0 \ movl bar,r0
190: ** movab _foo[r0] / movaw _foo[r0]
191: **
192: ** ashl $2,r0,r0 \ moval _foo[r0]
193: ** movab _foo[r0] /
194: */
195: register struct node *pf;
196: register int shfrom, shto;
197: long shcnt;
198: char *regfrom;
199:
200: splitrand(p);
201: if (regs[RT1][0] != '$') goto std;
202: if ((shcnt = getnum(®s[RT1][1])) < 1 || shcnt > 3) goto std;
203: if ((shfrom = isreg(regs[RT2])) >= 0)
204: regfrom = copy(regs[RT2],"]");
205: if ((shto = isreg(regs[RT3])) >= 0 && shto<NUSE)
206: {
207: int regnum;
208:
209: if (uses[shto] != (pf = p->forw)) goto ashadd;
210: if (pf->op != MOVA && pf->op != PUSHA) goto ashadd;
211: if (pf->subop != BYTE) goto ashadd;
212: splitrand(pf);
213: if (!indexa(regs[RT1])) goto std;
214: cp2 = regs[RT1];
215: if(!isstatic(cp2)) goto std;
216: while (*cp2++ != '[') ;
217: if (*cp2++ != 'r' || !isdigit(*cp2)) goto std;
218: regnum = *cp2++ - '0';
219: if (isdigit(*cp2))
220: {
221: if (cp2[1] != ']') goto std;
222: regnum *= 10; regnum += *cp2 - '0';
223: }
224: if (regnum != shto) goto std;
225: if (shfrom >= 0) /* ashl $N,r*,r0 */
226: {
227: delnode(p);
228: if (shfrom != shto)
229: {
230: uses[shto] = NULL; splitrand(pf);
231: cp2=regs[RT1]; while (*cp2++!='[');
232: cp1=regfrom; while (*cp2++= *cp1++);
233: newcode(pf);
234: }
235: }
236: else
237: {
238: p->op = MOV; splitrand(p);
239: strcpy(regs[RT1], regs[RT2]);
240: strcpy(regs[RT2], regs[RT3]);
241: regs[RT3][0] = '\0';
242: p->pop = 0; newcode(p);
243: }
244: switch (shcnt)
245: {
246: case 1: pf->subop = WORD; break;
247: case 2: pf->subop = LONG; break;
248: case 3: pf->subop = QUAD; break;
249: }
250: redunm++; nsaddr++; nchange++;
251: }
252: goto std;
253: ashadd:
254: /* at this point, RT2 and RT3 are guaranteed to be simple regs*/
255: if (shcnt == 1 && equstr(regs[RT2], regs[RT3]))
256: {
257: /*
258: ** quickie:
259: ** ashl $1,A,A > addl2 A,A
260: */
261: p->op = ADD; p->subop = U(LONG,OP2); p->pop = 0;
262: strcpy(regs[RT1], regs[RT2]); regs[RT3][0] = '\0';
263: newcode(p); nchange++;
264: }
265: goto std;
266: }
267:
268: case EXTV:
269: case EXTZV:
270: {
271: /* bit tests:
272: ** extv A,$1,B,rC \
273: ** tstl rC > jbc A,B,D
274: ** jeql D /
275: **
276: ** also byte- and word-size fields:
277: ** extv $n*8,$8,A,B > cvtbl n+A,B
278: ** extv $n*16,$16,A,B > cvtwl n+A,B
279: ** extzv $n*8,$8,A,B > movzbl n+A,B
280: ** extzv $n*16,$16,A,B > movzwl n+A,B
281: */
282: register struct node *pf; /* forward node */
283: register struct node *pn; /* next node (after pf) */
284: int flen; /* field length */
285:
286: splitrand(p);
287: if (regs[RT2][0] != '$') goto std;
288: if ((flen = getnum(®s[RT2][1])) < 0) goto std;
289: if (flen == 1)
290: {
291: register int extreg; /* reg extracted to */
292:
293: extreg = isreg(regs[RT4]);
294: if (extreg < 0 || extreg >= NUSE) goto std;
295: if ((pf = p->forw)->op != TST) goto std;
296: if (uses[extreg] && uses[extreg] != pf) goto std;
297: splitrand(pf);
298: if (extreg != isreg(regs[RT1])) goto std;
299: if ((pn = pf->forw)->op != CBR) goto std;
300: if (pn->subop != JEQ && pn->subop != JNE) goto std;
301: delnode(p); delnode(pf);
302: pn->subop = (pn->subop == JEQ) ? JBC : JBS;
303: for(cp2=p->code; *cp2++!=',';);
304: for(cp1=cp2; *cp1++!=',';);
305: while (*cp1!=',') *cp2++= *cp1++; *cp2='\0';
306: pn->code = p->code; pn->pop = NULL;
307: uses[extreg] = NULL;
308: }
309: else
310: if (flen == 8 || flen == 16)
311: {
312: register int boff; /* bit offset */
313: register int coff; /* chunk (byte or word) offset*/
314:
315: if (regs[RT1][0] != '$') goto std;
316: if ((boff = getnum(®s[RT1][1])) < 0) goto std;
317: coff = boff / flen;
318: if (coff && (isreg(regs[RT3]) >= 0)) goto std;
319: if (boff < 0 || (boff % flen) != 0) goto std;
320: p->op = (p->op == EXTV) ? CVT : MOVZ;
321: p->subop = U((flen == 8 ? BYTE : WORD), LONG);
322: if (coff == 0)
323: strcpy(regs[RT1], regs[RT3]);
324: else
325: sprintf(regs[RT1], "%d%s%s", coff, regs[RT3][0]=='(' ? "":"+",
326: regs[RT3]);
327: strcpy(regs[RT2], regs[RT4]);
328: regs[RT3][0] = '\0'; regs[RT4][0] = '\0';
329: p->pop = 0; newcode(p);
330: }
331: nchange++;
332: goto std;
333: }
334:
335: case CMP:
336: {
337: /* comparison to -63 to -1:
338: ** cmpl r0,$-1 > incl r0
339: ** jeql ...
340: **
341: ** cmpl r0,$-63 > addl2 $63,r0
342: ** jeql ...
343: */
344: register int num;
345: register int reg;
346: register struct node *regp = p->back;
347:
348: if (p->forw->op != CBR) goto std;
349: if (p->forw->subop != JEQ && p->forw->subop != JNE) goto std;
350: splitrand(p);
351: if (strncmp(regs[RT2], "$-", 2) != 0) goto std;
352: reg = r = isreg(regs[RT1]);
353: if (r < 0) goto std;
354: if (r < NUSE && uses[r] != 0) goto std;
355: if (r >= NUSE && regp->op == MOV && p->subop == regp->subop)
356: {
357: if (*regp->code != 'r') goto std;
358: reg = regp->code[1] - '0';
359: if (isdigit(regp->code[2]) || reg >= NUSE || uses[reg])
360: goto std;
361: }
362: if (r >= NUSE) goto std;
363: if (reg != r)
364: sprintf(regs[RT1], "r%d", reg);
365: if ((num = getnum(®s[RT2][2])) <= 0 || num > 63) goto std;
366: if (num == 1)
367: {
368: p->op = INC; regs[RT2][0] = '\0';
369: }
370: else
371: {
372: register char *t;
373:
374: t=regs[RT1];regs[RT1]=regs[RT2];regs[RT2]=t;
375: p->op = ADD; p->subop = U(p->subop, OP2);
376: for (t = ®s[RT1][2]; t[-1] = *t; t++) ;
377: }
378: p->pop = 0; newcode(p);
379: nchange++;
380: goto std;
381: }
382:
383: case JSB:
384: if (equstr(p->code,"mcount")) {uses[0]=p; regs[0][0]= -1;}
385: goto std;
386: case JBR: case JMP:
387: clearuse();
388: if (p->subop==RET || p->subop==RSB) {uses[0]=p; regs[0][0]= -1; break;}
389: if (p->ref==0) goto std; /* jmp (r0) */
390: /* fall through */
391: case CBR:
392: if (p->ref->ref!=0) for (r=NUSE;--r>=0;)
393: if (biti[r] & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;}
394: case EROU: case JSW:
395: case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ;
396: }
397: }
398: for (p= &first; p!=0; p=p->forw)
399: if (p->op==LABEL || p->op==DLABEL) p->ref=0; /* erase our tracks */
400: }
401:
402: rmove()
403: {
404: register struct node *p, *lastp;
405: register int r;
406: int r1;
407:
408: clearreg();
409: for (p=first.forw; p!=0; p = p->forw) {
410: lastp=p;
411: if (debug) {
412: printf("Regs:\n");
413: for (r=0; r<NREG; r++)
414: if (regs[r][0]) {
415: r1=regs[r][0];
416: printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1);
417: }
418: printf("-\n");
419: }
420: switch (p->op) {
421:
422: case CVT:
423: splitrand(p); goto mov;
424:
425: case MOV:
426: splitrand(p);
427: if ((r = findrand(regs[RT1],p->subop)) >= 0) {
428: if (r == isreg(regs[RT2]) && p->forw->op!=CBR) {
429: delnode(p); redunm++; break;
430: }
431: }
432: mov:
433: repladdr(p);
434: r = isreg(regs[RT1]);
435: r1 = isreg(regs[RT2]);
436: dest(regs[RT2],p->subop);
437: if (r>=0) {
438: if (r1>=0) savereg(r1, regs[r]+1, p->subop);
439: else if (p->op!=CVT) savereg(r, regs[RT2], p->subop);
440: } else if (r1>=0) savereg(r1, regs[RT1], p->subop);
441: else if (p->op!=CVT) setcon(regs[RT1], regs[RT2], p->subop);
442: break;
443:
444: /* .rx,.wx */
445: case MFPR:
446: case COM:
447: case NEG:
448: /* .rx,.wx or .rx,.rx,.wx */
449: case ADD:
450: case SUB:
451: case BIC:
452: case BIS:
453: case XOR:
454: case MUL:
455: case DIV:
456: case ASH:
457: case MOVZ:
458: /* .rx,.rx,.rx,.wx */
459: case EXTV:
460: case EXTZV:
461: case INSV:
462: splitrand(p);
463: repladdr(p);
464: dest(lastrand,p->subop);
465: if (p->op==INSV) ccloc[0]=0;
466: break;
467:
468: /* .mx or .wx */
469: case CLR:
470: case INC:
471: case DEC:
472: splitrand(p);
473: dest(lastrand,p->subop);
474: if (p->op==CLR)
475: if ((r = isreg(regs[RT1])) >= 0)
476: savereg(r, "$0", p->subop);
477: else
478: setcon("$0", regs[RT1], p->subop);
479: break;
480:
481: /* .rx */
482: case TST:
483: case PUSH:
484: splitrand(p);
485: lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */
486: repladdr(p);
487: if (p->op==TST && equstr(lastrand=regs[RT1], ccloc+1)
488: && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))
489: &&!source(lastrand)) {
490: delnode(p); p = p->back; nrtst++; nchange++;
491: }
492: setcc(lastrand,p->subop);
493: break;
494:
495: /* .rx,.rx,.rx */
496: case PROBER:
497: case PROBEW:
498: case CASE:
499: case MOVC3:
500: /* .rx,.rx */
501: case MTPR:
502: case CALLS:
503: case CMP:
504: case BIT:
505: splitrand(p);
506: /* fool repladdr into doing right number of operands */
507: if (p->op==CASE || p->op==PROBER || p->op==PROBEW) lastrand=regs[RT4];
508: /* else if (p->op==CMPV || p->op==CMPZV) lastrand=regs[RT4+1]; */
509: else if (p->op==MOVC3) lastrand=regs[RT1];
510: else lastrand=regs[RT3];
511: repladdr(p);
512: if (p->op==CALLS || p->op==MOVC3) clearreg();
513: if (p->op==BIT) bitopt(p);
514: ccloc[0]=0; break;
515:
516: case CBR:
517: if (p->subop>=JBC) {
518: splitrand(p);
519: if (p->subop<JBCC) lastrand=regs[RT3]; /* 2 operands can be optimized */
520: else lastrand=regs[RT2]; /* .mb destinations lose */
521: repladdr(p);
522: }
523: ccloc[0] = 0;
524: break;
525:
526: case JBR:
527: redunbr(p);
528:
529: /* .wx,.bb */
530: case SOB:
531:
532: default:
533: clearreg();
534: }
535: }
536: }
537:
538: char *
539: byondrd(p) register struct node *p; {
540: /* return pointer to register which is "beyond last read/modify operand" */
541: if (OP2==(p->subop>>4)) return(regs[RT3]);
542: switch (p->op) {
543: case MFPR:
544: case JSB:
545: case PUSHA:
546: case TST: case INC: case DEC: case PUSH: return(regs[RT2]);
547: case MTPR:
548: case BIT: case CMP: case CALLS: return(regs[RT3]);
549: case PROBER: case PROBEW:
550: case CASE: case MOVC3: return(regs[RT4]);
551: }
552: return(lastrand);
553: }
554:
555: struct node *
556: bflow(p)
557: register struct node *p;
558: {
559: register char *cp1,*cp2,**preg; register int r;
560: int flow= -1;
561: struct node *olduse=0;
562: splitrand(p);
563: if (p->op!=PUSH && p->subop && 0<=(r=isreg(lastrand)) && r<NUSE && uses[r]==p->forw) {
564: if (equtype(p->subop,regs[r][0])
565: || ((p->op==CVT || p->op==MOVZ)
566: && 0xf®s[r][0] && compat(0xf&(p->subop>>4),regs[r][0]))) {
567: register int r2;
568: if (regs[r][1]!=0) {/* send directly to destination */
569: if (p->op==INC || p->op==DEC) {
570: if (p->op==DEC) p->op=SUB; else p->op=ADD;
571: p->subop=(OP2<<4)+(p->subop&0xF); /* use 2 now, convert to 3 later */
572: p->pop=0;
573: cp1=lastrand; cp2=regs[RT2]; while (*cp2++= *cp1++); /* copy reg */
574: cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0;
575: }
576: cp1=regs[r]+1; cp2=lastrand;
577: if (OP2==(p->subop>>4)) {/* use 3 operand form of instruction */
578: p->pop=0;
579: p->subop += (OP3-OP2)<<4; lastrand=cp2=regs[RT3];
580: }
581: while (*cp2++= *cp1++);
582: if (p->op==MOVA && p->forw->op==PUSH) {
583: p->op=PUSHA; *regs[RT2]=0; p->pop=0;
584: } else if (p->op==MOV && p->forw->op==PUSH) {
585: p->op=PUSH ; *regs[RT2]=0; p->pop=0;
586: }
587: delnode(p->forw);
588: if (0<=(r2=isreg(lastrand)) && r2<NUSE) {
589: uses[r2]=uses[r]; uses[r]=0;
590: }
591: redun3(p,0);
592: newcode(p); redunm++; flow=r;
593: } else if (p->op==MOV && p->forw->op!=EXTV && p->forw->op!=EXTZV) {
594: /* superfluous fetch */
595: int nmatch;
596: char src[C2_ASIZE];
597: movit:
598: cp2=src; cp1=regs[RT1]; while (*cp2++= *cp1++);
599: splitrand(p->forw);
600: if (p->forw->op != INC && p->forw->op != DEC)
601: lastrand=byondrd(p->forw);
602: nmatch=0;
603: for (preg=regs+RT1;*preg!=lastrand;preg++)
604: if (r==isreg(*preg)) {
605: cp2= *preg; cp1=src; while (*cp2++= *cp1++); ++nmatch;
606: }
607: if (nmatch==1) {
608: if (OP2==(p->forw->subop>>4) && equstr(src,regs[RT2])) {
609: p->forw->pop=0;
610: p->forw->subop += (OP3-OP2)<<4; cp1=regs[RT3];
611: *cp1++='r'; *cp1++=r+'0'; *cp1=0;
612: }
613: delnode(p); p=p->forw;
614: if (0<=(r2=isreg(src)) && r2<NUSE) {
615: uses[r2]=uses[r]; uses[r]=0;
616: }
617: redun3(p,0);
618: newcode(p); redunm++; flow=r;
619: } else splitrand(p);
620: }
621: } else if (p->op==MOV && (p->forw->op==CVT || p->forw->op==MOVZ)
622: && p->forw->subop&0xf /* if base or index, then forget it */
623: && compat(p->subop,p->forw->subop) && !source(cp1=regs[RT1])
624: && !indexa(cp1)) goto movit;
625: }
626: /* adjust 'lastrand' past any 'read' or 'modify' operands. */
627: lastrand=byondrd(p);
628: /* a 'write' clobbers the register. */
629: if (0<=(r=isreg(lastrand)) && r<NUSE
630: || OP2==(p->subop>>4) && 0<=(r=isreg(regs[RT2])) && r<NUSE && uses[r]==0) {
631: /* writing a dead register is useless, but watch side effects */
632: switch (p->op) {
633: case ACB:
634: case AOBLEQ: case AOBLSS: case SOBGTR: case SOBGEQ: break;
635: default:
636: if (uses[r]==0) {/* no direct uses, check for use of condition codes */
637: register struct node *q=p;
638: while ((q=nonlab(q->forw))->combop==JBR) q=q->ref; /* cc unused, unchanged */
639: if (q->op!=CBR) {/* ... and destroyed */
640: preg=regs+RT1;
641: while (cp1= *preg++) {
642: if (cp1==lastrand) {redunm++; delnode(p); return(p->forw);}
643: if (source(cp1) || equstr(cp1,lastrand)) break;
644: }
645: }
646: }
647: flow=r;
648: }
649: }
650: if (0<=(r=flow)) {olduse=uses[r]; uses[r]=0; *(short *)(regs[r])=0;}
651: /* these two are here, rather than in bmove(),
652: /* because I decided that it was better to go for 3-address code
653: /* (save time) rather than fancy jbxx (save 1 byte)
654: /* on sequences like bisl2 $64,r0; movl r0,foo
655: */
656: if (p->op==BIC) {p=bicopt(p); splitrand(p); lastrand=byondrd(p);}
657: if (p->op==BIS) {bixprep(p,JBSS); lastrand=byondrd(p);}
658: /* now look for 'read' or 'modify' (read & write) uses */
659: preg=regs+RT1;
660: while (*(cp1= *preg++)) {
661: /* check for r */
662: if (lastrand!=cp1 && 0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0) {
663: uses[r]=p; cp2=regs[r]; *cp2++=p->subop;
664: if (p->op==ASH && preg==(regs+RT1+1)) cp2[-1]=BYTE; /* stupid DEC */
665: if (p->op==MOV || p->op==PUSH || p->op==CVT || p->op==MOVZ || p->op==COM || p->op==NEG) {
666: if (p->op==PUSH) cp1="-(sp)";
667: else {
668: cp1=regs[RT2];
669: if (0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0)
670: uses[r]=olduse; /* reincarnation!! */
671: /* as in addl2 r0,r1; movl r1,r0; ret */
672: if (p->op!=MOV) cp1=0;
673: }
674: if (cp1) while (*cp2++= *cp1++);
675: else *cp2=0;
676: } else *cp2=0;
677: continue;
678: }
679: /* check for (r),(r)+,-(r),[r] */
680: do if (*cp1=='(' || *cp1=='[') {/* get register number */
681: char t;
682: cp2= ++cp1; while (*++cp1!=')' && *cp1!=']'); t= *cp1; *cp1=0;
683: if (0<=(r=isreg(cp2)) && r<NUSE && (uses[r]==0 || uses[r]==p)) {
684: uses[r]=p; regs[r][0]=(*--cp2=='[' ? OPX<<4 : OPB<<4);
685: }
686: *cp1=t;
687: } while (*++cp1);
688: }
689: /* pushax or movax possibility? */
690: cp1=regs[RT1];
691: if (*cp1++=='$' && isstatic(cp1) && natural(regs[RT1])) {
692: if (p->combop==T(MOV,LONG)) {
693: if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) {
694: cp1=p->code; while (*cp1++!=','); p->code= --cp1;
695: }
696: p->combop=T(MOVA,LONG); ++p->code; p->pop=0;
697: } else if (p->combop==T(PUSH,LONG)) {
698: p->combop=T(PUSHA,LONG); ++p->code; p->pop=0;
699: } else if ((p->combop&0xFFFF)==T(ADD,U(LONG,OP3))
700: && 0<=(r=isreg(regs[RT2]))) {
701: cp1=cp2=p->code; ++cp1;
702: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='[';
703: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']';
704: if (!equstr(regs[RT3],"-(sp)")) p->combop=T(MOVA,BYTE);
705: else {p->combop=T(PUSHA,BYTE); *cp2=0;}
706: if (uses[r]==0) {uses[r]=p; regs[r][0]=OPX<<4;}
707: p->pop=0;
708: }
709: }
710: return(p);
711: }
712:
713: ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
714: register int log;
715: if (n==0 || n&(n-1)) return(-1); log=0;
716: for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
717: }
718:
719: bitopt(p) register struct node *p; {
720: /* change "bitx $<power_of_2>,a" followed by JEQ or JNE
721: /* into JBC or JBS. watch out for I/O registers. (?)
722: /* assumes that 'splitrand' has already been called.
723: */
724: register char *cp1,*cp2; int b;
725: cp1=regs[RT1]; cp2=regs[RT2];
726: if (*cp1++!='$' || !okio(cp2) || p->forw->op!=CBR || p->forw->subop&-2 ||
727: 0>(b=ispow2(getnum(cp1))) ||
728: p->subop!=BYTE && (source(cp2) || indexa(cp2))) return;
729: if (b>=bitsize[p->subop]) {/* you dummy! */
730: if (source(cp2)) {/* side effect: auto increment or decrement */
731: p->pop=0;
732: p->op=TST; --cp1; while (*cp1++= *cp2++);
733: regs[RT2][0]=0; newcode(p);
734: } else delnode(p);
735: p = p->forw;
736: if (p->subop==JEQ) {p->combop=JBR; p->pop=0;}
737: else delnode(p);
738: nchange++; nbj++; return;
739: }
740: if (cp1=p->forw->code) {/* destination is not an internal label */
741: cp2=regs[RT3]; while (*cp2++= *cp1++);
742: }
743: if (b==0 && (p->subop==LONG || !indexa(regs[RT2]))) {/* JLB optimization, ala BLISS */
744: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++);
745: cp2=regs[RT2]; cp1=regs[RT3]; while (*cp2++= *cp1++);
746: *(regs[RT3])=0; p->forw->subop += JLBC-JBC;
747: p->forw->pop=0;
748: } else {
749: cp1=regs[RT1]+1;
750: if (b>9) *cp1++= b/10 +'0'; *cp1++= b%10 +'0'; *cp1=0; /* $<bit_number> */
751: }
752: nbj++; newcode(p); p->combop = p->forw->combop+((JBC-JEQ)<<8);
753: p->labno = p->forw->labno; delnode(p->forw);
754: p->pop=0;
755: }
756:
757: isfield(n) register long n; {/* -1 -> no; else -> position of low bit */
758: register int pos; register long t;
759: t= ((n-1)|n) +1;
760: if (n!=0 && (0==t || 0==n || 0<=ispow2(t))) {
761: pos=0; while(!(n&1)) {n >>= 1; ++pos;} return(pos);
762: } else return(-1);
763: }
764:
765: bixprep(p,bix) register struct node *p; {
766: /* initial setup, single-bit checking for bisopt, bicopt.
767: /* return: 0->don't bother any more; 1->worthwhile trying
768: */
769: register char *cp1,*cp2;
770: splitrand(p); cp1=regs[RT1]; cp2=regs[RT2];
771: if (*cp1++!='$' || 0>(pos=isfield(f=getnum(cp1)))
772: || !okio(cp2) || indexa(cp2) || source(cp2) || !okio(lastrand)) return(0);
773: f |= f-1; if (++f==0) siz=32-pos; else siz=ispow2(f)-pos;
774: if (siz==1 && pos>5 && (p->subop>>4)==OP2 && (p->subop&0xF)!=BYTE
775: && pos<bitsize[p->subop&0xF]) {
776: p->ref = insertl(p->forw); p->combop = CBR | (bix<<8);
777: p->pop=0;
778: p->labno = p->ref->labno;
779: if (pos>9) {*cp1++= pos/10 +'0'; pos %= 10;}
780: *cp1++=pos+'0'; *cp1=0; newcode(p); nbj++; return(0);
781: }
782: return(1);
783: }
784:
785:
786: struct node *
787: bicopt(p) register struct node *p; {
788: /* use field operations or MOVZ if possible. done as part of 'bflow'.
789: */
790: register char *cp1,*cp2; int r;
791: char src[C2_ASIZE];
792: if (!bixprep(p,JBCC)) return(p);
793: if (f==0) {/* the BIC isolates low order bits */
794: siz=pos; pos=0;
795: if ((p->subop&0xF)==LONG && *(regs[RT2])!='$') {/* result of EXTZV is long */
796: /* save source of BICL in 'src' */
797: cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
798: if (p->back->op==ASH) {/* try for more */
799: splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT3];
800: if (*cp1++=='$' && *(regs[RT2])!='$' && !indexa(regs[RT2])
801: && 0>(f=getnum(cp1)) && equstr(src,cp2)
802: && 0<=(r=isreg(cp2)) && r<NUSE) {/* a good ASH */
803: pos -= f; cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
804: delnode(p->back);
805: }
806: }
807: if (p->back->op==CVT || p->back->op==MOVZ) {/* greedy, aren't we? */
808: splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT2];
809: if (equstr(src,cp2) && okio(cp1) && !indexa(cp1)
810: && 0<=(r=isreg(cp2)) && r<NUSE
811: && bitsize[p->back->subop&0xF]>=(pos+siz)
812: && bitsize[p->back->subop>>4]>=(pos+siz)) {/* good CVT */
813: cp1=regs[RT1]; cp2=src; while (*cp2++= *cp1++);
814: delnode(p->back);
815: }
816: }
817: /* 'pos', 'siz' known; source of field is in 'src' */
818: splitrand(p); /* retrieve destination of BICL */
819: if (siz==8 && pos==0) {
820: p->combop = T(MOVZ,U(BYTE,LONG));
821: sprintf(line,"%s,%s",src,lastrand);
822: } else {
823: p->combop = T(EXTZV,LONG);
824: sprintf(line,"$%d,$%d,%s,%s",pos,siz,src,lastrand);
825: }
826: p->pop=0;
827: p->code = copy(line); nfield++; return(p);
828: }/* end EXTZV possibility */
829: }/* end low order bits */
830: /* unfortunately, INSV clears the condition codes, thus cannot be used */
831: /* else {/* see if BICL2 of positive field should be INSV $0 */
832: /* if (p->subop==(LONG | (OP2<<4)) && 6<=(pos+siz)) {
833: /* p->combop = INSV;
834: /* sprintf(line,"$0,$%d,$%d,%s",pos,siz,lastrand);
835: /* p->code = copy(line); nfield++; return(p);
836: /* }
837: /* }
838: */
839: return(p);
840: }
841:
842: jumpsw()
843: {
844: register struct node *p, *p1;
845: register t;
846: int nj;
847:
848: t = 0;
849: nj = 0;
850: for (p=first.forw; p!=0; p = p->forw)
851: p->seq = ++t;
852: for (p=first.forw; p!=0; p = p1) {
853: p1 = p->forw;
854: if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
855: && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) {
856: if (p->ref==p1->ref)
857: continue;
858: p->subop = revbr[p->subop];
859: p->pop=0;
860: t = p1->ref;
861: p1->ref = p->ref;
862: p->ref = t;
863: t = p1->labno;
864: p1->labno = p->labno;
865: p->labno = t;
866: #ifdef COPYCODE
867: if (p->labno == 0) {
868: t = p1->code; p1->code = p->code; p->code = t;
869: }
870: #endif
871: nrevbr++;
872: nj++;
873: }
874: }
875: return(nj);
876: }
877:
878: addsob()
879: {
880: register struct node *p, *p1, *p2, *p3;
881:
882: for (p = &first; (p1 = p->forw)!=0; p = p1) {
883: if (p->combop==T(DEC,LONG) && p1->op==CBR) {
884: if (abs(p->seq - p1->ref->seq) > 8) continue;
885: if (p1->subop==JGE || p1->subop==JGT) {
886: if (p1->subop==JGE) p->combop=SOBGEQ; else p->combop=SOBGTR;
887: p->pop=0;
888: p->labno = p1->labno; delnode(p1); nsob++;
889: }
890: } else if (p->combop==T(INC,LONG)) {
891: if (p1->op==LABEL && p1->refc==1 && p1->forw->combop==T(CMP,LONG)
892: && (p2=p1->forw->forw)->combop==T(CBR,JLE)
893: && (p3=p2->ref->back)->combop==JBR && p3->ref==p1
894: && p3->forw->op==LABEL && p3->forw==p2->ref) {
895: /* change INC LAB: CMP to LAB: INC CMP */
896: p->back->forw=p1; p1->back=p->back;
897: p->forw=p1->forw; p1->forw->back=p;
898: p->back=p1; p1->forw=p;
899: p1=p->forw;
900: /* adjust beginning value by 1 */
901: p2=alloc(sizeof first); p2->combop=T(DEC,LONG);
902: p2->pop=0;
903: p2->forw=p3; p2->back=p3->back; p3->back->forw=p2;
904: p3->back=p2; p2->code=p->code; p2->labno=0;
905: }
906: if (p1->combop==T(CMP,LONG) && (p2=p1->forw)->op==CBR) {
907: register char *cp1,*cp2;
908: splitrand(p1); if (!equstr(p->code,regs[RT1])) continue;
909: if (abs(p->seq - p2->ref->seq)>8) {/* outside byte displ range */
910: if (p2->subop!=JLE) continue;
911: p->combop=T(ACB,LONG);
912: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
913: cp2=regs[RT2]; cp1="$1"; while (*cp2++= *cp1++); /* increment */
914: cp2=regs[RT3]; cp1=p->code; while (*cp2++= *cp1++); /* index */
915: p->pop=0; newcode(p);
916: p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
917: } else if (p2->subop==JLE || p2->subop==JLT) {
918: if (p2->subop==JLE) p->combop=AOBLEQ; else p->combop=AOBLSS;
919: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
920: cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */
921: p->pop=0; newcode(p);
922: p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
923: }
924: }
925: }
926: }
927: }
928:
929: abs(x)
930: {
931: return(x<0? -x: x);
932: }
933:
934: equop(p1, p2)
935: register struct node *p1;
936: struct node *p2;
937: {
938: register char *cp1, *cp2;
939:
940: if (p1->combop != p2->combop)
941: return(0);
942: if (p1->op>0 && p1->op<MOV)
943: return(0);
944: if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
945: cp1 = p1->code;
946: cp2 = p2->code;
947: if (cp1==0 && cp2==0)
948: return(1);
949: if (cp1==0 || cp2==0)
950: return(0);
951: while (*cp1 == *cp2++)
952: if (*cp1++ == 0)
953: return(1);
954: return(0);
955: }
956:
957: delnode(p) register struct node *p; {
958: p->back->forw = p->forw;
959: p->forw->back = p->back;
960: }
961:
962: decref(p)
963: register struct node *p;
964: {
965: if (p && --p->refc <= 0) {
966: nrlab++;
967: delnode(p);
968: }
969: }
970:
971: struct node *
972: nonlab(ap)
973: struct node *ap;
974: {
975: register struct node *p;
976:
977: p = ap;
978: while (p && p->op==LABEL)
979: p = p->forw;
980: return(p);
981: }
982:
983: clearuse() {
984: register struct node **i;
985: for (i=uses+NUSE; i>uses;) *--i=0;
986: }
987:
988: clearreg() {
989: register short **i;
990: for (i=regs+NREG; i>regs;) **--i=0;
991: conloc[0] = 0; ccloc[0] = 0;
992: }
993:
994: savereg(ai, s, type)
995: register char *s;
996: {
997: register char *p, *sp;
998:
999: sp = p = regs[ai];
1000: if (source(s)) /* side effects in addressing */
1001: return;
1002: /* if any indexing, must be parameter or local */
1003: /* indirection (as in "*-4(fp)") is ok, however */
1004: *p++ = type;
1005: while (*p++ = *s)
1006: if (*s=='[' || *s++=='(' && *s!='a' && *s!='f') {*sp = 0; return;}
1007: }
1008:
1009: dest(s,type)
1010: register char *s;
1011: {
1012: register int i;
1013:
1014: source(s); /* handle addressing side effects */
1015: if ((i = isreg(s)) >= 0) {
1016: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */
1017: switch(type & 0xF){
1018: case DFLOAT: /* clobber two at once */
1019: /*FALLTHROUGH*/
1020: case GFLOAT:
1021: *(short *)(regs[i+1]) = 0;
1022: break;
1023: case HFLOAT: /* clobber four at once */
1024: *(short *)(regs[i+1]) = 0;
1025: *(short *)(regs[i+2]) = 0;
1026: *(short *)(regs[i+3]) = 0;
1027: break;
1028: }
1029: switch((type>>4)&0xF){
1030: case DFLOAT: /* clobber two at once */
1031: /*FALLTHROUGH*/
1032: case GFLOAT:
1033: *(short *)(regs[i+1]) = 0;
1034: break;
1035: case HFLOAT: /* clobber four at once */
1036: *(short *)(regs[i+1]) = 0;
1037: *(short *)(regs[i+2]) = 0;
1038: *(short *)(regs[i+3]) = 0;
1039: break;
1040: }
1041: /*
1042: if (DFLOAT==(type&0xF) || DFLOAT==((type>>4)&0xF))
1043: *(short *)(regs[i+1]) = 0;
1044: */
1045: }
1046: for (i=NREG; --i>=0;)
1047: if (regs[i][1]=='*' && equstr(s, regs[i]+2))
1048: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */
1049: while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */
1050: *(short *)(regs[i]) = 0;
1051: if (!natural(s)) {/* wild store, everything except constants vanishes */
1052: for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0;
1053: conloc[0] = 0; ccloc[0] = 0;
1054: } else setcc(s,type); /* natural destinations set condition codes */
1055: }
1056:
1057: splitrand(p) struct node *p; {
1058: /* separate operands at commas, set up 'regs' and 'lastrand' */
1059: register char *p1, *p2; register char **preg;
1060: preg=regs+RT1;
1061: if (p1=p->code) while (*p1) {
1062: lastrand=p2= *preg++;
1063: while (*p1) if (','==(*p2++= *p1++)) {--p2; break;}
1064: *p2=0;
1065: }
1066: while (preg<(regs+RT1+5)) *(*preg++)=0;
1067: }
1068:
1069: compat(have, want) {
1070: register int hsrc, hdst;
1071: if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */
1072: hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc;
1073: if (want>=FFLOAT) return(hdst==want && hsrc==want);
1074: /* FLOAT, DFLOAT not compat: rounding */
1075: return(hsrc>=want && hdst>=want && hdst<FFLOAT);
1076: }
1077:
1078: equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));}
1079:
1080: findrand(as, type)
1081: char *as;
1082: {
1083: register char **i;
1084: for (i = regs+NREG; --i>=regs;) {
1085: if (**i && equstr(*i+1, as) && compat(**i,type))
1086: return(i-regs);
1087: }
1088: return(-1);
1089: }
1090:
1091: isreg(s)
1092: register char *s;
1093: {
1094: if (*s++!='r' || !isdigit(*s++)) return(-1);
1095: if (*s==0) return(*--s-'0');
1096: if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0');
1097: return(-1);
1098: }
1099:
1100: check()
1101: {
1102: register struct node *p, *lp;
1103:
1104: lp = &first;
1105: for (p=first.forw; p!=0; p = p->forw) {
1106: if (p->back != lp)
1107: abort(-1);
1108: lp = p;
1109: }
1110: }
1111:
1112: source(ap)
1113: char *ap;
1114: {
1115: register char *p1, *p2;
1116:
1117: p1 = ap;
1118: p2 = p1;
1119: if (*p1==0)
1120: return(0);
1121: while (*p2++ && *(p2-1)!='[');
1122: if (*p1=='-' && *(p1+1)=='('
1123: || *p1=='*' && *(p1+1)=='-' && *(p1+2)=='('
1124: || *(p2-2)=='+') {
1125: while (*p1 && *p1++!='r');
1126: if (isdigit(*p1++))
1127: if (isdigit(*p1)) *(short *)(regs[10+*p1-'0'])=0;
1128: else *(short *)(regs[*--p1-'0'])=0;
1129: return(1);
1130: }
1131: return(0);
1132: }
1133:
1134: newcode(p) struct node *p; {
1135: register char *p1,*p2,**preg;
1136: preg=regs+RT1; p2=line;
1137: while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';}
1138: *--p2=0;
1139: p->code=copy(line);
1140: }
1141:
1142: repladdr(p)
1143: struct node *p;
1144: {
1145: register r;
1146: register char *p1, *p2;
1147: char **preg; int nrepl;
1148:
1149: preg=regs+RT1; nrepl=0;
1150: while (lastrand!=(p1= *preg++))
1151: if (!source(p1) && 0<=(r=findrand(p1,p->subop))) {
1152: *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0;
1153: nrepl++; nsaddr++;
1154: }
1155: if (nrepl) newcode(p);
1156: }
1157:
1158: /* movedat()
1159: /* {
1160: /* register struct node *p1, *p2;
1161: /* struct node *p3;
1162: /* register seg;
1163: /* struct node data;
1164: /* struct node *datp;
1165: /*
1166: /* if (first.forw == 0)
1167: /* return;
1168: /* datp = &data;
1169: /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
1170: /* if (p1->op == DATA) {
1171: /* p2 = p1->forw;
1172: /* while (p2 && p2->op!=TEXT)
1173: /* p2 = p2->forw;
1174: /* if (p2==0)
1175: /* break;
1176: /* p3 = p1->back;
1177: /* p1->back->forw = p2->forw;
1178: /* p2->forw->back = p3;
1179: /* p2->forw = 0;
1180: /* datp->forw = p1;
1181: /* p1->back = datp;
1182: /* p1 = p3;
1183: /* datp = p2;
1184: /* }
1185: /* }
1186: /* if (data.forw) {
1187: /* datp->forw = first.forw;
1188: /* first.forw->back = datp;
1189: /* data.forw->back = &first;
1190: /* first.forw = data.forw;
1191: /* }
1192: /* seg = -1;
1193: /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
1194: /* if (p1->op==TEXT||p1->op==DATA||p1->op==BSS) {
1195: /* if (p1->op == seg || p1->forw&&p1->forw->op==seg) {
1196: /* p1->back->forw = p1->forw;
1197: /* p1->forw->back = p1->back;
1198: /* p1 = p1->back;
1199: /* continue;
1200: /* }
1201: /* seg = p1->op;
1202: /* }
1203: /* }
1204: /* }
1205: */
1206:
1207: redunbr(p)
1208: register struct node *p;
1209: {
1210: register struct node *p1;
1211: register char *ap1;
1212: char *ap2;
1213:
1214: if ((p1 = p->ref) == 0)
1215: return;
1216: p1 = nonlab(p1);
1217: if (p1->op==TST) {
1218: splitrand(p1);
1219: savereg(RT2, "$0", p1->subop);
1220: } else if (p1->op==CMP)
1221: splitrand(p1);
1222: else
1223: return;
1224: if (p1->forw->op==CBR) {
1225: ap1 = findcon(RT1, p1->subop);
1226: ap2 = findcon(RT2, p1->subop);
1227: p1 = p1->forw;
1228: if (compare(p1->subop, ap1, ap2)) {
1229: nredunj++;
1230: nchange++;
1231: decref(p->ref);
1232: p->ref = p1->ref;
1233: p->labno = p1->labno;
1234: #ifdef COPYCODE
1235: if (p->labno == 0)
1236: p->code = p1->code;
1237: if (p->ref)
1238: #endif
1239: p->ref->refc++;
1240: }
1241: } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) &&
1242: equtype(ccloc[0],p1->subop)) {
1243: p1=insertl(p1->forw); decref(p->ref); p->ref=p1;
1244: nrtst++; nchange++;
1245: }
1246: }
1247:
1248: char *
1249: findcon(i, type)
1250: {
1251: register char *p;
1252: register r;
1253:
1254: p = regs[i];
1255: if (*p=='$')
1256: return(p);
1257: if ((r = isreg(p)) >= 0 && compat(regs[r][0],type))
1258: return(regs[r]+1);
1259: if (equstr(p, conloc))
1260: return(conval+1);
1261: return(p);
1262: }
1263:
1264: compare(op, acp1, acp2)
1265: char *acp1, *acp2;
1266: {
1267: register char *cp1, *cp2;
1268: register n1;
1269: int n2; int sign;
1270:
1271: cp1 = acp1;
1272: cp2 = acp2;
1273: if (*cp1++ != '$' || *cp2++ != '$')
1274: return(0);
1275: n1 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;}
1276: while (isdigit(*cp2)) {n1 *= 10; n1 += (*cp2++ - '0')*sign;}
1277: n2 = n1;
1278: n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;}
1279: while (isdigit(*cp1)) {n1 *= 10; n1 += (*cp1++ - '0')*sign;}
1280: if (*cp1=='+')
1281: cp1++;
1282: if (*cp2=='+')
1283: cp2++;
1284: do {
1285: if (*cp1++ != *cp2)
1286: return(0);
1287: } while (*cp2++);
1288: cp1 = n1;
1289: cp2 = n2;
1290: switch(op) {
1291:
1292: case JEQ:
1293: return(cp1 == cp2);
1294: case JNE:
1295: return(cp1 != cp2);
1296: case JLE:
1297: return(((int)cp1) <= ((int)cp2));
1298: case JGE:
1299: return(((int)cp1) >= ((int)cp2));
1300: case JLT:
1301: return(((int)cp1) < ((int)cp2));
1302: case JGT:
1303: return(((int)cp1) > ((int)cp2));
1304: case JLO:
1305: return(cp1 < cp2);
1306: case JHI:
1307: return(cp1 > cp2);
1308: case JLOS:
1309: return(cp1 <= cp2);
1310: case JHIS:
1311: return(cp1 >= cp2);
1312: }
1313: return(0);
1314: }
1315:
1316: setcon(cv, cl, type)
1317: register char *cv, *cl;
1318: {
1319: register char *p;
1320:
1321: if (*cv != '$')
1322: return;
1323: if (!natural(cl))
1324: return;
1325: p = conloc;
1326: while (*p++ = *cl++);
1327: p = conval;
1328: *p++ = type;
1329: while (*p++ = *cv++);
1330: }
1331:
1332: equstr(p1, p2)
1333: register char *p1, *p2;
1334: {
1335: do {
1336: if (*p1++ != *p2)
1337: return(0);
1338: } while (*p2++);
1339: return(1);
1340: }
1341:
1342: setcc(ap,type)
1343: char *ap;
1344: {
1345: register char *p, *p1;
1346:
1347: p = ap;
1348: if (!natural(p)) {
1349: ccloc[0] = 0;
1350: return;
1351: }
1352: p1 = ccloc;
1353: *p1++ = type;
1354: while (*p1++ = *p++);
1355: }
1356:
1357: okio(p) register char *p; {/* 0->probable I/O space address; 1->not */
1358: if (ioflag && (!natural(p) || 0>getnum(p))) return(0);
1359: return(1);
1360: }
1361:
1362: indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */
1363: while (*p) if (*p++=='[') return(1);
1364: return(0);
1365: }
1366:
1367: natural(p)
1368: register char *p;
1369: {/* 1->simple local, parameter, global, or register; 0->otherwise */
1370: if (*p=='*' || *p=='(' || *p=='-'&&*(p+1)=='(' || *p=='$'&&getnum(p+1))
1371: return(0);
1372: while (*p++);
1373: p--;
1374: if (*--p=='+' || *p==']' || *p==')' && *(p-2)!='a' && *(p-2)!='f')
1375: return(0);
1376: return(1);
1377: }
1378:
1379: /*
1380: ** Tell if an argument is most likely static.
1381: */
1382:
1383: isstatic(cp)
1384: register char *cp;
1385: {
1386: if (*cp == '_' || *cp == 'L' || (*cp++ == 'v' && *cp == '.'))
1387: return (1);
1388: return (0);
1389: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.