![[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] / 43BSDTahoe / lib / old_compiler / c2 / c2.tahoe / save2|
Return to c21.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / c2 / c2.tahoe / save2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "%W% (Berkeley/CCI) %G%";
3: #endif
4:
5: /*
6: * C object code improver-- second part
7: */
8:
9: #include "c2.h"
10: #include <stdio.h>
11: #include <ctype.h>
12:
13: int bitsize[] = {0,8,16,32,64,32,64}; /* index by type codes */
14:
15: redun3(p) register struct node *p; {
16: /* check for 3 addr instr which should be 2 addr */
17: if (has3ops(p)) {
18: if (equstr(regs[RT1],regs[RT3])
19: && (p->op==ADD || p->op==MUL || p->op==AND || p->op==OR || p->op==XOR)) {
20: register char *t=regs[RT1]; regs[RT1]=regs[RT2]; regs[RT2]=t;
21: }
22: if (equstr(regs[RT2],regs[RT3])) {
23: p->subop=(p->subop&0xF)|(OP2<<4); p->pop=0;
24: lastrand=regs[RT2]; *regs[RT3]=0; return(1);
25: }
26: } return(0);
27: }
28:
29: bmove() {
30: register struct node *p, *lastp; register char *cp1,*cp2; register int r;
31: struct node *flops();
32:
33: refcount();
34: for (p=lastp= &first; 0!=(p=p->forw); lastp=p);
35: clearreg(); clearuse();
36: for (p=lastp; p!= &first; p=p->back) {
37: if (debug) {
38: printf("Uses: ");
39: if (useacc)
40: printf("acc: %s\n",useacc->code? useacc->code:"");
41: for (r=0; r<NUSE; r++) if (isused(r))
42: printf("r%d: %s (%d times)\n",
43: r, uses[r] && uses[r]->code? uses[r]->code:"",
44: usecnt[r]);
45: printf("-\n");
46: }
47: r=(p->subop>>4)&0xF;
48: splitrand(p);
49: if (OP3==r && 0!=redun3(p)) {newcode(p); redunm++;}
50: /* ops that do nothing */
51: if(p->op==MOV && equstr(regs[RT1], regs[RT2]))
52: if(p->forw->op!=CBR) {
53: delnode(p); redunm++; continue;
54: } else {
55: p->op=TST; p->pop=0;
56: while(*p->code++ != ',');
57: redunm++;
58: }
59: else if((cp1=p->code, *cp1++)=='$' &&
60: (*cp1=='0' || *cp1=='1' || *cp1++=='-' && *cp1=='1') && cp1[1]==',') {
61: switch((p->code[1]<<8)|ord(p->op)) {
62: case (('0'<<8)|ord(ADD)):
63: case (('0'<<8)|ord(SUB)):
64: case (('-'<<8)|ord(AND)):
65: case (('0'<<8)|ord(OR)):
66: case (('0'<<8)|ord(XOR)):
67: case (('1'<<8)|ord(MUL)):
68: case (('1'<<8)|ord(DIV)):
69: case (('0'<<8)|ord(SHAL)):
70: case (('0'<<8)|ord(SHAR)):
71: case (('0'<<8)|ord(SHL)):
72: case (('0'<<8)|ord(SHR)):
73: if(r == OP2) {
74: if(p->forw->op!=CBR) {
75: delnode(p); redunm++; continue;
76: } else {
77: p->op=TST; p->subop&=0xF; p->pop=0;
78: while(*p->code++ != ',');
79: redunm++;
80: }
81: } else { /* OP3 or shift */
82: p->op=MOV; p->subop&=0xF; p->pop=0;
83: while(*p->code++ != ',');
84: p = p->forw; redunm++; continue;
85: }
86: break;
87: case (('0'<<8)|ord(MUL)):
88: case (('0'<<8)|ord(AND)):
89: p->op=CLR; p->subop&=0xF; p->pop=0;
90: while(*p->code++ != ',');
91: if(r == OP3)
92: while(*p->code++ != ',');
93: redunm++;
94: }
95: }
96: switch (p->op) {
97: case LABEL: case DLABEL:
98: for (r=NUSE; --r>=0;)
99: if (uses[r]) p->ref=(struct node *) (((int)p->ref)|(1<<r));
100: if (useacc) p->ref=(struct node *) (((int)p->ref)|(1<<NUSE));
101: break;
102: case CALLS:
103: case CALLF:
104: clearuse(); goto std;
105: case NIL:
106: clearuse(); break;
107: case CVT:
108: { long n;
109: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
110: if (*cp1++!='$') goto std; splitrand(p);
111: n = getnum(®s[RT1][1]);
112: if(r==BYTE && (n<-128 || n>127)) goto std;
113: if(r==WORD && (n<-32768 || n>32767)) goto std;
114: p->op = MOV; p->subop = r; p->pop = 0;
115: } goto std;
116:
117: case SUB:
118: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
119: if (*cp1++!='$') goto std; splitrand(p);
120: #ifdef MOVAFASTER
121: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
122: char buf[C2_ASIZE]; cp2=buf; *cp2++='-';
123: cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
124: cp1="(fp),"; while (*cp2++= *cp1++); --cp2;
125: cp1=regs[RT3]; while (*cp2++= *cp1++);
126: p->code=copy(buf); p->op = MOVA; p->subop = BYTE; p->pop=0;
127: } else
128: #endif MOVAFASTER
129: if (*cp1++=='-' && 0==(r=getnum(cp1)) &&
130: !checkexpr(cp1)) {
131: p->op=ADD; p->pop=0; *--cp1='$'; p->code=cp1;
132: } goto std;
133: case ADD:
134: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
135: if (*cp1++!='$') goto std; splitrand(p);
136: if (isstatic(cp1) && tempreg(regs[RT2],r) && uses[r]==p->forw)
137: {
138: /* address comp:
139: ** addl2 $_foo,r0 \ movab _foo[r0],bar
140: ** movl r0,bar /
141: */
142: register struct node *pnext = p->forw;
143: char buf[C2_ASIZE];
144:
145: if (pnext->op == MOV && pnext->subop == LONG)
146: {
147: cp1 = ®s[RT1][1]; cp2 = &buf[0];
148: while (*cp2++ = *cp1++) ; cp2--;
149: splitrand(pnext);
150: if (r == isreg(regs[RT1]))
151: {
152: delnode(p); p = pnext;
153: p->op = MOVA; p->subop = BYTE;
154: p->pop = 0;
155: cp1 = regs[RT1]; *cp2++ = '[';
156: while (*cp2++ = *cp1++) ; cp2--;
157: *cp2++ = ']'; *cp2++ = ',';
158: cp1 = regs[RT2];
159: while (*cp2++ = *cp1++) ;
160: p->code = copy(buf);
161: }
162: }
163: }
164: else
165: #ifdef MOVAFASTER
166: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
167: cp2=cp1-1; cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
168: cp1="(fp)"; while (*cp2++= *cp1++); *--cp2=',';
169: p->op = MOVA; p->subop = BYTE; p->pop=0;
170: } else
171: #endif MOVAFASTER
172: if (*cp1++=='-' && 0==(r=getnum(cp1)) &&
173: !checkexpr(cp1)) {
174: p->op=SUB; p->pop=0; *--cp1='$'; p->code=cp1;
175: }
176: /* fall thru ... */
177: case CASE:
178: default: std:
179: p=bflow(p); break;
180:
181: case MUL:
182: /*
183: ** Change multiplication
184: ** by constant powers of 2 to shifts.
185: */
186: splitrand(p);
187: if (regs[RT1][0] != '$' || regs[RT1][1] == '-') goto std;
188: if ((r = ispow2(getnum(®s[RT1][1]))) <= 0) goto std;
189: /* mull2 $2,x */
190: if(r == 1 && p->subop == U(LONG, OP2)) {
191: strcpy(regs[RT1], regs[RT2]);
192: p->op = ADD; p->pop = 0; newcode(p);
193: goto std;
194: }
195: if (p->subop == U(LONG,OP2))
196: strcpy(regs[RT3], regs[RT2]);
197: sprintf(regs[RT1], "$%d", r);
198: p->op = SHL; p->subop = LONG;
199: p->pop = 0; newcode(p);
200: goto std;
201:
202: case SHAL:
203: case SHL:
204: {
205: /* bit tests:
206: ** shll A,$1,rC \
207: ** bitl B,rC > jbc A,B,D
208: ** jeql D /
209: **
210: ** address comp:
211: ** shll $1,bar,r0 \ movl bar,r0
212: ** movab _foo[r0] / movaw _foo[r0]
213: **
214: ** shll $2,r0,r0 \ moval _foo[r0]
215: ** movab _foo[r0] /
216: */
217: register struct node *pf;
218: register struct node *pn;
219: register int shfrom, shto;
220: long shcnt;
221: char *regfrom;
222:
223: splitrand(p);
224: if (regs[RT1][0] != '$') {
225: if(isreg(regs[RT1]) < 0) goto std; /* alignment */
226: if (regs[RT2][0] != '$') goto std;
227: if (getnum(®s[RT2][1]) != 1) goto std;
228: if (!tempreg(regs[RT3],r)) goto std;
229: if ((pf = p->forw)->op != BIT && pf->op!=AND) goto std;
230: if (uses[r] && uses[r] != pf) goto std;
231: splitrand(pf);
232: if (r == isreg(regs[RT1])) cp2 = regs[RT2];
233: else if (r == isreg(regs[RT2])) cp2 = regs[RT1];
234: else goto std;
235: if (*cp2 == '$') goto std;
236: if ((pn = pf->forw)->op != CBR) goto std;
237: if (pn->subop != JEQ && pn->subop != JNE) goto std;
238: delnode(p); delnode(pf);
239: pn->subop = (pn->subop == JEQ) ? JBC : JBS;
240: for(cp1=p->code; *cp1++!=',';);
241: while (*cp1++= *cp2++);
242: pn->code = p->code; pn->pop = NULL;
243: deluse(r);
244: nbj++;
245: p = pn;
246: goto std;
247: }
248: if ((shcnt = getnum(®s[RT1][1])) < 1 || shcnt > 2) goto std;
249: if ((shfrom = isreg(regs[RT2])) >= 0)
250: regfrom = copy(regs[RT2]);
251: if (tempreg(regs[RT3],shto))
252: {
253: int regnum;
254:
255: if (uses[shto] != (pf = p->forw)) goto ashadd;
256: if (pf->op != MOVA && pf->op != PUSHA) goto ashadd;
257: if (pf->subop != BYTE) goto ashadd;
258: splitrand(pf);
259: if (!indexa(regs[RT1])) goto std;
260: cp2 = regs[RT1];
261: if(!isstatic(cp2)) goto std;
262: while (*cp2++ != '[') ;
263: if (*cp2++ != 'r' || !isdigit(*cp2)) goto std;
264: regnum = *cp2++ - '0';
265: if (isdigit(*cp2))
266: {
267: if (cp2[1] != ']') goto std;
268: regnum *= 10; regnum += *cp2 - '0';
269: }
270: if (regnum != shto) goto std;
271: if (shfrom >= 0) /* shll $N,r*,r0 */
272: {
273: delnode(p);
274: p = pf;
275: if (shfrom != shto)
276: {
277: deluse(shto);
278: splitrand(pf);
279: cp2=regs[RT1]; while (*cp2++!='[');
280: cp1=regfrom; while (*cp2++= *cp1++);
281: cp2[-1] = ']'; *cp2 = 0;
282: newcode(pf);
283: }
284: }
285: else
286: {
287: p->op = MOV; splitrand(p);
288: strcpy(regs[RT1], regs[RT2]);
289: strcpy(regs[RT2], regs[RT3]);
290: regs[RT3][0] = '\0';
291: p->pop = 0; newcode(p);
292: }
293: switch (shcnt)
294: {
295: case 1: pf->subop = WORD; break;
296: case 2: pf->subop = LONG; break;
297: }
298: redunm++; nsaddr++;
299: }
300: goto std;
301: ashadd:
302: /* at this point, RT2 and RT3 are guaranteed to be simple regs*/
303: if (shcnt == 1) {
304: /*
305: ** quickie:
306: ** shll $1,A,A > addl2 A,A
307: ** shll $1,A,B > addl3 A,A,B
308: */
309: p->op = ADD;
310: strcpy(regs[RT1], regs[RT2]);
311: if(equstr(regs[RT2], regs[RT3])) {
312: p->subop = U(LONG,OP2);
313: regs[RT3][0] = '\0';
314: } else
315: p->subop = U(LONG,OP3);
316: p->pop = 0;
317: newcode(p);
318: }
319: goto std;
320: }
321:
322: case SHAR:
323: case SHR:
324: {
325: /* bit tests:
326: ** shrl A,B,rC \
327: ** bitl $1,rC > jbc A,B,D
328: ** jeql D /
329: */
330: register struct node *pf; /* forward node */
331: register struct node *pn; /* next node (after pf) */
332: register int extreg; /* reg extracted to */
333:
334: splitrand(p);
335: if(isreg(regs[RT1]) < 0) goto std; /* alignment */
336: if (!tempreg(regs[RT3],extreg)) goto std;
337: if ((pf = p->forw)->op != BIT) goto std;
338: if (uses[extreg] && uses[extreg] != pf) goto std;
339: splitrand(pf);
340: if (regs[RT1][0] != '$') goto std;
341: if (getnum(®s[RT1][1]) != 1) goto std;
342: if (extreg != isreg(regs[RT2])) goto std;
343: if ((pn = pf->forw)->op != CBR) goto std;
344: if (pn->subop != JEQ && pn->subop != JNE) goto std;
345: delnode(p); delnode(pf);
346: pn->subop = (pn->subop == JEQ) ? JBC : JBS;
347: for(cp1=p->code; *cp1++!=',';);
348: while (*cp1!=',') cp1++; *cp1='\0';
349: pn->code = p->code; pn->pop = NULL;
350: deluse(extreg); nbj++;
351: p = pn;
352: goto std;
353: }
354:
355: case AND:
356: {
357: /* unsigned conversion:
358: ** cvtbl A,B; andl2 $255,B > movzbl A,B
359: **
360: ** also byte- and word-size fields:
361: ** shrl $(3-n)*8,A,B; andl2 $255,B > movzbl n+A,B
362: ** shrl $(1-n)*16,A,B; andl2 $65535,B > movzwl n+A,B
363: */
364: char src[C2_ASIZE];
365: register int f; /* field length */
366: register struct node *pb = p->back; /* backward node */
367:
368: if (p->subop != U(LONG,OP2))
369: goto std;
370: splitrand(p); cp1=regs[RT1];
371: if (*cp1++!='$' || (f=getnum(cp1))!=0xff && f!=0xffff)
372: goto std;
373: f = f==0xff ? 8 : 16;
374: if (pb->op!=CVT && pb->op!=MOVZ && pb->op!=SHAR && pb->op!=SHR)
375: goto std;
376: /* save source of ANDL in 'src' */
377: strcpy(src, regs[RT2]);
378: splitrand(pb);
379: if (!equstr(src,lastrand))
380: goto std;
381: if (pb->op==CVT || pb->op==MOVZ) {
382: if (!(bitsize[pb->subop&0xF]==f
383: && bitsize[pb->subop>>4]>=f)) /* good CVT */
384: goto std;
385: strcpy(src, regs[RT1]);
386: } else {
387: register int boff; /* bit offset */
388:
389: if (regs[RT1][0] != '$') goto std;
390: if ((boff = getnum(®s[RT1][1])) < 0) goto std;
391: if (isreg(regs[RT2])>=0 || !natural(regs[RT2])) goto std;
392: if ((boff & (f-1)) != 0) goto std;
393: boff = (32-boff-f) / 8;
394: if (boff == 0)
395: strcpy(src, regs[RT2]);
396: else
397: sprintf(src, "%d%s%s", boff, regs[RT2][0]=='(' ? "":"+",
398: regs[RT2]);
399: }
400: delnode(pb);
401: p->op = MOVZ;
402: p->subop = U((f==8 ? BYTE : WORD), LONG);
403: sprintf(line,"%s,%s",src,lastrand);
404: p->pop=0;
405: p->code = copy(line);
406: goto std;
407: }
408:
409: case CMP:
410: {
411: /* comparison to -63 to -1:
412: ** cmpl r0,$-1 > incl r0
413: ** jeql ...
414: **
415: ** cmpl r0,$-63 > addl2 $63,r0
416: ** jeql ...
417: */
418: register int num;
419: register int reg;
420: register struct node *regp = p->back;
421:
422: if (p->forw->op != CBR) goto std;
423: if (p->forw->subop != JEQ && p->forw->subop != JNE) goto std;
424: splitrand(p);
425: if (strncmp(regs[RT2], "$-", 2) != 0) goto std;
426: reg = r = isreg(regs[RT1]);
427: if (r < 0) goto std;
428: if (r < NUSE && uses[r] != 0) goto std;
429: if (r >= NUSE && regp->op == MOV && p->subop == regp->subop)
430: {
431: if (*regp->code != 'r') goto std;
432: reg = regp->code[1] - '0';
433: if (isdigit(regp->code[2]) || reg >= NUSE || uses[reg])
434: goto std;
435: }
436: if (r >= NUSE) goto std;
437: if (reg != r)
438: sprintf(regs[RT1], "r%d", reg);
439: if ((num = getnum(®s[RT2][2])) <= 0 || num > 63) goto std;
440: if (num == 1)
441: {
442: p->op = INC; regs[RT2][0] = '\0';
443: }
444: else
445: {
446: register char *t;
447:
448: t=regs[RT1];regs[RT1]=regs[RT2];regs[RT2]=t;
449: p->op = ADD; p->subop = U(p->subop, OP2);
450: for (t = ®s[RT1][2]; t[-1] = *t; t++) ;
451: }
452: p->pop = 0; newcode(p);
453: goto std;
454: }
455:
456: case JBR: case JMP:
457: clearuse();
458: if ((p->subop&0xF)==RET) {
459: switch((p->subop>>4)&0xF) {
460: case 2: adduse(1,p); regs[1][0]= -1;
461: case 1: adduse(0,p); regs[0][0]= -1;
462: }
463: break;
464: }
465: if (p->ref==0) goto std; /* jmp (r0) */
466: /* fall through */
467: case CBR:
468: if (p->ref->ref!=0) {
469: for (r=NUSE;--r>=0;)
470: if ((1<<r) & (int)p->ref->ref) {
471: adduse(r,p); regs[r][0]= -1;
472: }
473: if ((1<<NUSE) & (int)p->ref->ref) useacc=p;
474: }
475: break;
476: case LNF:
477: /* lnf a; addf b ==> ldf b; subf a */
478: { register struct node *pf = p->forw;
479: if(pf->op==ADDF && p->subop==pf->subop) {
480: p->op = LDF;
481: p->pop = 0;
482: pf->op = SUBF;
483: pf->pop = 0;
484: cp1 = p->code;
485: p->code = pf->code;
486: pf->code = cp1;
487: p = pf->forw;
488: break;
489: }}
490: case LDF: case LDFD: case CVLF: /* destroy acc */
491: useacc = 0;
492: goto std;
493: case STF:
494: { register struct node *pf;
495: if((pf=flops(p)) != p) {
496: p = pf; /* usually p->forw; */
497: break;
498: }}
499: if(ldmov(p)) {
500: p = p->forw;
501: break;
502: }
503: if(useacc == 0)
504: useacc = p;
505: goto std;
506: case ADDF: case MULF: /* commutatives - create clients for flops */
507: /* stf a; ldf b; addf a => stf a; ldf a; addf b */
508: { register struct node *pb = p->back;
509: register struct node *pbb = pb->back;
510: if(pb->op==LDF && pb->subop==p->subop &&
511: pbb && pbb->op==STF && pbb->subop==p->subop &&
512: equstr(pbb->code, p->code)) {
513: cp1 = p->code;
514: p->code = pb->code;
515: pb->code = cp1;
516: }}
517: /* use acc and regs */
518: case CMPF: case CVFL: case SUBF: case DIVF:
519: if(useacc == 0)
520: useacc = p;
521: goto std;
522: case TSTF:
523: break;
524: case PUSHD:
525: if(ldmov(p)) {
526: p = p->forw;
527: break;
528: }
529: case CVDF: case NEGF: /* use only acc */
530: case SINF: case COSF: case ATANF: case LOGF: case SQRTF: case EXPF:
531: if(useacc == 0)
532: useacc = p;
533: case EROU: case JSW:
534: case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ;
535: }
536: }
537: for (p= &first; p!=0; p=p->forw)
538: if (p->op==LABEL || p->op==DLABEL) p->ref=0; /* erase our tracks */
539: }
540:
541: char *
542: byondrd(p) register struct node *p; {
543: /* return pointer to register which is "beyond last read/modify operand" */
544: if (has2ops(p)) return(regs[RT3]);
545: switch (p->op) {
546: case MFPR:
547: case PUSHA:
548: case TST: case INC: case DEC: case PUSH:
549: case LDF: case LNF: case CVLF: case LDFD:
550: case ADDF: case SUBF: case MULF: case DIVF:
551: case CMPF:
552: return(regs[RT2]);
553: case MTPR:
554: #ifndef EMOD
555: case EDIV:
556: #endif EMOD
557: case CBR: /* must be JBC/JBS */
558: case BIT: case CMP: case CALLS: case CALLF:
559: case CMPF2:
560: return(regs[RT3]);
561: case EMUL:
562: case PROBE:
563: case MOVBLK:
564: case CASE:
565: return(regs[RT4]);
566: }
567: return(lastrand);
568: }
569:
570: struct node *
571: bflow(p)
572: register struct node *p;
573: {
574: register char *cp1,*cp2,**preg;
575: register int r, fr, dblflg=0;
576: int flow= -1;
577: struct node *olduse=0, *olduse1=0;
578:
579: if (p->subop==QUAD || p->subop==DOUBLE || (p->subop&0xF0)==DOUBLE<<4)
580: dblflg |= 1; /* double dest */
581: if ((p->subop&0xF)==DOUBLE || p->subop==QUAD)
582: dblflg |= 2; /* double src */
583: splitrand(p);
584: if (p->op!=PUSH &&
585: #ifndef EMOD
586: p->op!=EDIV &&
587: #endif EMOD
588: p->op!=EMUL &&
589: p->subop && tempreg(lastrand,r) && uses[r]==p->forw) {
590: if (equtype(p->subop,regs[r][0]) ||
591: ((p->op==CVT || p->op==MOVZ || p->op==CVFL) &&
592: (regs[r][0]&0xf) && compat((p->subop>>4)&0xf,regs[r][0])) ||
593: p->op==MOVA && compat(LONG, regs[r][0])) {
594: register int r2;
595:
596: if (regs[r][1]!=0) { /* send directly to destination */
597: if (p->op==INC || p->op==DEC) {
598: p->op = (p->op==DEC) ? SUB : ADD;
599: /* use 2 now, convert to 3 later */
600: p->subop=(OP2<<4)+(p->subop&0xF);
601: p->pop=0;
602: cp1=lastrand; cp2=regs[RT2];
603: while (*cp2++= *cp1++) /* copy reg */
604: ;
605: cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0;
606: }
607: cp1=regs[r]+1; cp2=lastrand;
608: if (has2ops(p)) {
609: /* use 3 operand form of instruction */
610: p->pop=0;
611: p->subop += (OP3-OP2)<<4;
612: lastrand = cp2 = regs[RT3];
613: }
614: while (*cp2++= *cp1++)
615: ;
616: if (p->op==MOVA && p->forw->op==PUSH) {
617: p->op=PUSHA;
618: *regs[RT2]=0; p->pop=0;
619: } else if ((p->op==MOV || p->op==CVT) &&
620: p->forw->op==PUSH) {
621: p->op=PUSH; p->subop &= 0xF;
622: *regs[RT2]=0; p->pop=0;
623: }
624: delnode(p->forw);
625: if (tempreg(lastrand,r2)) {
626: adduse(r2,uses[r]); /* ZZZ */
627: deluse(r);
628: }
629: redun3(p);
630: newcode(p); redunm++; flow=r;
631: } else if (p->op==MOV) { /* superfluous fetch */
632: int nmatch;
633: char src[C2_ASIZE];
634: movit:
635: for (cp2=src, cp1=regs[RT1]; *cp2++= *cp1++;)
636: ;
637: splitrand(p->forw);
638: if (p->forw->op != INC && p->forw->op != DEC)
639: lastrand=byondrd(p->forw);
640: nmatch=0;
641: for (preg=regs+RT1;*preg!=lastrand;preg++)
642: if (r==isreg(*preg)) {
643: cp2= *preg; cp1=src;
644: while (*cp2++= *cp1++)
645: ;
646: ++nmatch;
647: }
648: if (nmatch==1) {
649: if (has2ops(p->forw) && equstr(src,regs[RT2])) {
650: p->forw->pop=0;
651: p->forw->subop += (OP3-OP2)<<4;
652: cp1=regs[RT3];
653: *cp1++ = 'r'; *cp1++ = r+'0'; *cp1=0;
654: }
655: delnode(p);
656: p=p->forw;
657: if (tempreg(src,r2)) {
658: adduse(r2,uses[r]); /* ZZZ */
659: deluse(r);
660: }
661: redun3(p);
662: newcode(p); redunm++; flow=r;
663: } else
664: splitrand(p);
665: }
666: } else if (p->op==MOV && (p->forw->op==CVT || p->forw->op==MOVZ) &&
667: p->forw->subop&0xf && /* if base or index, then forget it */
668: compat(p->subop,p->forw->subop) && !indexa(cp1=regs[RT1]))
669: goto movit;
670: }
671: /* adjust 'lastrand' past any 'read' or 'modify' operands. */
672: lastrand=byondrd(p);
673: /* a 'write' clobbers the register. */
674: if (tempreg(lastrand,r) ||
675: (has2ops(p) && tempreg(regs[RT2],r) && !isused(r))) {
676: /*
677: * Writing a dead register is useless,
678: * but watch side effects
679: */
680: switch (p->op) {
681: #ifndef EMOD
682: case EDIV:
683: #endif EMOD
684: case EMUL:
685: case AOBLEQ: case AOBLSS:
686: break;
687: default:
688: /*
689: * If no direct uses, check for
690: * use of condition codes
691: */
692: if (!isused(r) && ((dblflg&1)==0 || !isused(r+1))) {
693: register struct node *q = p;
694:
695: while ((q = nonlab(q->forw))->op==JBR &&
696: q->subop==0)
697: q=q->ref; /* cc unused, unchanged */
698: if (q->op!=CBR && q->op!=ADDA && q->op!=SUBA) {
699: /* ... and destroyed */
700: preg=regs+RT1;
701: while (cp1 = *preg++) {
702: if (cp1==lastrand &&
703: p->op != CLR &&
704: p->op != CVFL) {
705: redunm++;
706: delnode(p);
707: return(p->forw);
708: }
709: if (equstr(cp1,lastrand))
710: break;
711: }
712: }
713: }
714: flow=r;
715: }
716: }
717: /*
718: * Clobber any registers written, but
719: * don't clobber use/reference count.
720: */
721: if ((r=flow) >= 0) {
722: olduse=uses[r]; deluse(r);
723: *(short *)(regs[r])=0;
724: /* if r0 destroyed, dont keep r1 */
725: if (dblflg&1) {
726: olduse1=uses[++r]; deluse(r);
727: *(short *)(regs[r])=0;
728: }
729: }
730: /* now look for 'read' or 'modify' (read & write) uses */
731: preg=regs+RT1;
732: while (*(cp1= *preg++)) {
733: /* check for r */
734: if (lastrand!=cp1 && tempreg(cp1,r) && uses[r]==0) {
735: adduse(r,p); /* ZZZ */
736: cp2=regs[r]; *cp2++=p->subop;
737: if ((p->op==SHAL || p->op==SHAR ||
738: p->op==SHL || p->op==SHR) &&
739: cp1==regs[RT1])
740: cp2[-1] = BYTE;
741: if (p->op==CBR && (p->subop==JBC || p->subop==JBS))
742: cp2[-1] = LONG;
743: if (p->op==MOVA && cp1==regs[RT2])
744: cp2[-1]=LONG;
745: /* ediv/emod's 2nd operand is quad */
746: if (((p->op==EDIV
747: #ifdef EMOD
748: || p->op==EMOD
749: #endif EMOD
750: ) && cp1==regs[RT2] || (dblflg&2)) &&
751: ++r<NUSE && uses[r]==0) {
752: *cp2=0;
753: adduse(r,p); /* ZZZ */
754: cp2=regs[r]; *cp2++=p->subop;
755: }
756: if (p->op==MOV || p->op==PUSH || p->op==CVT ||
757: p->op==MOVZ || p->op==COM || p->op==NEG ||
758: p->op==STF) {
759: if (p->op!=PUSH) {
760: cp1=regs[RT2];
761: if (tempreg(cp1,r)) {
762: /*
763: * reincarnation!!
764: * (as in addl2 r0,r1;
765: * movl r1,r0; ret)
766: */
767: if (uses[r]==0)
768: adduse(r,olduse);
769: if ((dblflg&1) && uses[r+1]==0)
770: adduse(r+1,olduse1);
771: }
772: if (p->op!=MOV)
773: cp1=0;
774: } else
775: cp1="-(sp)";
776: if (cp1)
777: while (*cp2++= *cp1++)
778: ;
779: else
780: *cp2=0;
781: } else
782: *cp2=0;
783: continue;
784: }
785: /* check for (r),[r] */
786: do {
787: if (*cp1=='(' || *cp1=='[') { /* get register number */
788: char t;
789: for (cp2= ++cp1; *++cp1!=')' && *cp1!=']';)
790: ;
791: t= *cp1; *cp1=0;
792: if (tempreg(cp2,r)) {
793: if (uses[r]==0 || uses[r]==p) {
794: adduse(r,p);
795: regs[r][0] = (*--cp2=='[' ?
796: OPX<<4 : OPB<<4);
797: } else
798: usecnt[r]++;
799: }
800: *cp1=t;
801: }
802: } while (*++cp1);
803: }
804: #ifdef MOVAFASTER
805: /* pushax or movax possibility? */
806: cp1=regs[RT1];
807: if (*cp1++=='$' && isstatic(cp1)) {
808: if (p->op==MOV && p->subop==LONG) {
809: if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) {
810: cp1=p->code; while (*cp1++!=','); p->code= --cp1;
811: }
812: p->op = MOVA; p->subop = BYTE; ++p->code; p->pop=0;
813: } else if (p->op==PUSH && p->subop==LONG) {
814: p->op = PUSHA; p->subop = BYTE; ++p->code; p->pop=0;
815: } else if (p->op==ADD && p->subop==U(LONG,OP3)
816: && 0<=(r=isreg(regs[RT2]))) {
817: cp1=cp2=p->code; ++cp1;
818: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='[';
819: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']';
820: if (!equstr(regs[RT3],"-(sp)")){ p->op = MOVA; p->subop = BYTE;}
821: else {p->op = PUSHA; p->subop = BYTE; *cp2=0;}
822: if (uses[r]==0) {adduse(r,p); regs[r][0]=OPX<<4;}
823: p->pop=0;
824: }
825: }
826: #endif MOVAFASTER
827: return (p);
828: }
829:
830: /* try to eliminate STF's */
831: struct node *
832: flops(q)
833: register struct node *q;
834: {
835: register struct node *p;
836: register int r;
837:
838: if(q->op!=STF || !tempreg(q->code,r))
839: return(q);
840: if(uses[r]) {
841: /* see if anyone destroys acc between us */
842: for(p=q->forw; p!=uses[r]; p=p->forw)
843: switch(p->op) {
844: case LABEL:
845: case LDF: case LNF: case CVLF: case LDFD:
846: case CVDF: case NEGF: case ADDF: case SUBF:
847: case MULF: case DIVF: case SINF: case COSF:
848: case ATANF: case LOGF: case SQRTF: case EXPF:
849: return(q);
850: }
851:
852: if(q->subop == p->subop)
853: switch(p->op) { /* do it in the accumulator */
854: case LDF: /* redundant load */
855: delnode(p); nld++;
856: p = p->forw;
857: break;
858: case LNF: /* stf r; lnf r ==> negf */
859: p->op = NEGF;
860: p->pop = 0;
861: p->code = 0;
862: break;
863: case CMPF2: /* stf r; cmpf2 r,x ==> cmpf x */
864: { register char *s;
865: register struct node *p1=p->forw;
866: for(s=p->code; *s!=','; s++);
867: *s = 0;
868: if(isreg(p->code) == r)
869: p->code = s+1;
870: else {
871: if(p1->op != CBR || isreg(s+1) != r) {
872: *s = ',';
873: return(q);
874: }
875: if(p1->subop > JNE) {
876: p1->subop ^= 1;
877: p1->pop = 0;
878: nrevbr++;
879: }
880: }
881: p->op = CMPF;
882: p->pop = 0;
883: }
884: break;
885: default:
886: return(q);
887: }
888: else if(p->subop==LONG) {
889: switch(p->op) {
890: case TST: /* stf r; tstl r ==> tstf */
891: p->op = TSTF;
892: p->code = 0;
893: break;
894: /* send directly to destination */
895: case MOV: /* stf r; movl r,x ==> stf x */
896: case PUSH: /* stf r; pushl r ==> stf -(sp)/pushd */
897: if(q->subop == DOUBLE) {
898: register struct node *b = p->back;
899: /* assume b's 2nd arg is ok */
900: if(!(b==uses[r+1] && b->op==p->op && b->subop==LONG))
901: return(q);
902: delnode(b); redunm++;
903: }
904: if(p->op==PUSH) {
905: if(q->subop == DOUBLE) {
906: p->op = PUSHD;
907: p->code = 0;
908: } else {
909: p->op = q->op;
910: p->code = copy("-(sp)");
911: }
912: } else {
913: p->op = q->op;
914: while(*p->code++ != ',');
915: }
916: break;
917: default:
918: return(q);
919: }
920: p->pop = 0;
921: p->subop = q->subop;
922: } else
923: return(q);
924: uses[r] = 0;
925: if(q->subop == DOUBLE)
926: uses[r+1] = 0;
927: { /* undo any effect on uses in the area between p and q,
928: * as we are going over it again */
929: register struct node *b;
930: for(b=p; b!=q; b=b->back) {
931: for(r=0; r<NUSE; r++) {
932: if(uses[r] == b)
933: uses[r] = 0;
934: if(useacc == b)
935: useacc = 0;
936: }
937: }
938: }
939: return(p->forw); /* make p the next for bflow */
940: }
941: /* it's a store to reg which isnt used elsewhere */
942: if((p=q->forw)->op == CBR) {
943: q->op = TSTF;
944: q->pop = 0;
945: q->code = 0;
946: } else {
947: delnode(q); nst++;
948: if(p->op ==STF || p->op==TSTF || p->op==PUSHD) {
949: if(useacc == p)
950: useacc = 0;
951: return(p->forw); /* so ldmov can be used on p */
952: }
953: }
954: return(p);
955: }
956:
957: /* try to change load/store sequences to movl */
958: ldmov(q)
959: register struct node *q;
960: {
961: register struct node *p;
962: register char *s, *pcod, *cp;
963: char *dlsw();
964:
965: p = q->back;
966: if(!(useacc==0 && (q->op==STF || q->op==TSTF || q->op==PUSHD)
967: && ((p->op==LDF && p->subop==q->subop) || (p->op==LDFD && q->subop==DOUBLE))))
968: return(0);
969: pcod = p->code;
970: cp = p->code;
971: /* prepare args for movl/pushl */
972: if(q->op!=TSTF && q->subop==DOUBLE) {
973: if(p->op == LDF) {
974: if((s = dlsw(p->code)) == NULL)
975: return(0);
976:
977: strcpy(line, s);
978: if(q->op == STF) {
979: strcat(line, ",");
980: if((s = dlsw(q->code)) == NULL)
981: return(0);
982: strcat(line, s);
983: p->op = MOV;
984: } else
985: p->op = PUSH;
986: } else { /* LDFD */
987: if(q->op == STF) {
988: if((s = dlsw(q->code)) == NULL)
989: return(0);
990: } else
991: s = "-(sp)";
992: strcpy(line, s);
993: p->op = CLR;
994: }
995: p->pop = 0;
996: p->subop = LONG;
997: p->code = copy(line);
998: } else
999: {
1000: if ((p->op == LDF) && (p->subop == DOUBLE) &&
1001: (indexa(cp))) return(0);
1002: delnode(p);
1003: }
1004: strcpy(line, pcod);
1005: if(q->op == STF) { /* ldf x; stf y ==> movl x,y */
1006: strcat(line, ",");
1007: strcat(line, q->code);
1008: q->op = MOV;
1009: nst++;
1010: } else if(q->op == TSTF) /* ldf x; tstf ==> tstl x */
1011: q->op = TST;
1012: else /* ldd x; pushd ==> pushl x+4; pushl x */
1013: q->op = PUSH;
1014: q->pop = 0;
1015: q->subop = LONG;
1016: q->code = copy(line);
1017: nld++;
1018: return(1);
1019: }
1020:
1021: /* reconstruct the address of l.s.w. of a double operand */
1022: char *
1023: dlsw(d)
1024: register char *d;
1025: {
1026: register char *s, *t, *c;
1027: register int r;
1028: static char lsw[C2_ASIZE];
1029:
1030: if(d[0] == '*' || d[0] == '$')
1031: return(NULL);
1032: if (((strncmp(d, "(r", 2)) == 0) && isdigit(d[2]))
1033: return(NULL);
1034: t = lsw;
1035: if((r=isreg(d)) >= 0)
1036: sprintf(t, "r%d", r+1);
1037: else {
1038: for(s=d; *s && *s!='('; *t++ = *s++)
1039: if(*s == '[')
1040: return(NULL);
1041: if(s!=d)
1042: *t++ = '+';
1043: *t++ = '4';
1044: while(*t++ = *s)
1045: if(*s++ == '[' )
1046: {
1047: return(NULL);
1048: }
1049: }
1050: return(lsw);
1051: }
1052: checkexpr(p)
1053: register char *p;
1054: {
1055:
1056: while(*p && *p != ','){
1057: if ((*p == '+' ) || (*p == '-'))
1058: return(1);
1059: *p++;
1060: }
1061: return(0);
1062: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.