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