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