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