![[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 / c2 / c2.tahoe|
Return to c21.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / c2 / c2.tahoe |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)c21.c 1.9 (Berkeley/CCI) 5/12/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: } ! 298: goto std; ! 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: p->op = ADD; ! 308: strcpy(regs[RT1], regs[RT2]); ! 309: if(equstr(regs[RT2], regs[RT3])) { ! 310: p->subop = U(LONG,OP2); ! 311: regs[RT3][0] = '\0'; ! 312: } else ! 313: p->subop = U(LONG,OP3); ! 314: p->pop = 0; ! 315: newcode(p); ! 316: } ! 317: goto std; ! 318: } ! 319: ! 320: case SHAR: ! 321: case SHR: ! 322: { ! 323: /* bit tests: ! 324: ** shrl A,B,rC \ ! 325: ** bitl $1,rC > jbc A,B,D ! 326: ** jeql D / ! 327: */ ! 328: register struct node *pf; /* forward node */ ! 329: register struct node *pn; /* next node (after pf) */ ! 330: register int extreg; /* reg extracted to */ ! 331: ! 332: splitrand(p); ! 333: if(isreg(regs[RT1]) < 0) goto std; /* alignment */ ! 334: if (!tempreg(regs[RT3],extreg)) goto std; ! 335: if ((pf = p->forw)->op != BIT) goto std; ! 336: if (uses[extreg] && uses[extreg] != pf) goto std; ! 337: splitrand(pf); ! 338: if (regs[RT1][0] != '$') goto std; ! 339: if (getnum(®s[RT1][1]) != 1) goto std; ! 340: if (extreg != isreg(regs[RT2])) goto std; ! 341: if ((pn = pf->forw)->op != CBR) goto std; ! 342: if (pn->subop != JEQ && pn->subop != JNE) goto std; ! 343: delnode(p); delnode(pf); ! 344: pn->subop = (pn->subop == JEQ) ? JBC : JBS; ! 345: for(cp1=p->code; *cp1++!=',';); ! 346: while (*cp1!=',') cp1++; *cp1='\0'; ! 347: pn->code = p->code; pn->pop = NULL; ! 348: uses[extreg] = NULL; nbj++; ! 349: p = pn; ! 350: goto std; ! 351: } ! 352: ! 353: case AND: ! 354: { ! 355: /* unsigned conversion: ! 356: ** cvtbl A,B; andl2 $255,B > movzbl A,B ! 357: ** ! 358: ** also byte- and word-size fields: ! 359: ** shrl $(3-n)*8,A,B; andl2 $255,B > movzbl n+A,B ! 360: ** shrl $(1-n)*16,A,B; andl2 $65535,B > movzwl n+A,B ! 361: */ ! 362: char src[C2_ASIZE]; ! 363: register int f; /* field length */ ! 364: register struct node *pb = p->back; /* backward node */ ! 365: ! 366: if (p->subop != U(LONG,OP2)) ! 367: goto std; ! 368: splitrand(p); cp1=regs[RT1]; ! 369: if (*cp1++!='$' || (f=getnum(cp1))!=0xff && f!=0xffff) ! 370: goto std; ! 371: f = f==0xff ? 8 : 16; ! 372: if (pb->op!=CVT && pb->op!=MOVZ && pb->op!=SHAR && pb->op!=SHR) ! 373: goto std; ! 374: /* save source of ANDL in 'src' */ ! 375: strcpy(src, regs[RT2]); ! 376: splitrand(pb); ! 377: if (!equstr(src,lastrand)) ! 378: goto std; ! 379: if (pb->op==CVT || pb->op==MOVZ) { ! 380: if (!(bitsize[pb->subop&0xF]==f ! 381: && bitsize[pb->subop>>4]>=f)) /* good CVT */ ! 382: goto std; ! 383: strcpy(src, regs[RT1]); ! 384: } else { ! 385: register int boff; /* bit offset */ ! 386: ! 387: if (regs[RT1][0] != '$') goto std; ! 388: if ((boff = getnum(®s[RT1][1])) < 0) goto std; ! 389: if (isreg(regs[RT2])>=0 || !natural(regs[RT2])) goto std; ! 390: if ((boff & (f-1)) != 0) goto std; ! 391: boff = (32-boff-f) / 8; ! 392: if (boff == 0) ! 393: strcpy(src, regs[RT2]); ! 394: else ! 395: sprintf(src, "%d%s%s", boff, regs[RT2][0]=='(' ? "":"+", ! 396: regs[RT2]); ! 397: } ! 398: delnode(pb); ! 399: p->op = MOVZ; ! 400: p->subop = U((f==8 ? BYTE : WORD), LONG); ! 401: sprintf(line,"%s,%s",src,lastrand); ! 402: p->pop=0; ! 403: p->code = copy(line); ! 404: goto std; ! 405: } ! 406: ! 407: case CMP: ! 408: { ! 409: /* comparison to -63 to -1: ! 410: ** cmpl r0,$-1 > incl r0 ! 411: ** jeql ... ! 412: ** ! 413: ** cmpl r0,$-63 > addl2 $63,r0 ! 414: ** jeql ... ! 415: */ ! 416: register int num; ! 417: register int reg; ! 418: register struct node *regp = p->back; ! 419: ! 420: if (p->forw->op != CBR) goto std; ! 421: if (p->forw->subop != JEQ && p->forw->subop != JNE) goto std; ! 422: splitrand(p); ! 423: if (strncmp(regs[RT2], "$-", 2) != 0) goto std; ! 424: reg = r = isreg(regs[RT1]); ! 425: if (r < 0) goto std; ! 426: if (r < NUSE && uses[r] != 0) goto std; ! 427: if (r >= NUSE && regp->op == MOV && p->subop == regp->subop) ! 428: { ! 429: if (*regp->code != 'r') goto std; ! 430: reg = regp->code[1] - '0'; ! 431: if (isdigit(regp->code[2]) || reg >= NUSE || uses[reg]) ! 432: goto std; ! 433: } ! 434: if (r >= NUSE) goto std; ! 435: if (reg != r) ! 436: sprintf(regs[RT1], "r%d", reg); ! 437: if ((num = getnum(®s[RT2][2])) <= 0 || num > 63) goto std; ! 438: if (num == 1) ! 439: { ! 440: p->op = INC; regs[RT2][0] = '\0'; ! 441: } ! 442: else ! 443: { ! 444: register char *t; ! 445: ! 446: t=regs[RT1];regs[RT1]=regs[RT2];regs[RT2]=t; ! 447: p->op = ADD; p->subop = U(p->subop, OP2); ! 448: for (t = ®s[RT1][2]; t[-1] = *t; t++) ; ! 449: } ! 450: p->pop = 0; newcode(p); ! 451: goto std; ! 452: } ! 453: ! 454: case JBR: case JMP: ! 455: clearuse(); ! 456: if ((p->subop&0xF)==RET) { ! 457: switch((p->subop>>4)&0xF) { ! 458: case 2: uses[1]=p; regs[1][0]= -1; ! 459: case 1: uses[0]=p; regs[0][0]= -1; ! 460: } ! 461: break; ! 462: } ! 463: if (p->ref==0) goto std; /* jmp (r0) */ ! 464: /* fall through */ ! 465: case CBR: ! 466: if (p->ref->ref!=0) { ! 467: for (r=NUSE;--r>=0;) ! 468: if ((1<<r) & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;} ! 469: if ((1<<NUSE) & (int)p->ref->ref) useacc=p; ! 470: } ! 471: break; ! 472: case LNF: ! 473: /* lnf a; addf b ==> ldf b; subf a */ ! 474: { register struct node *pf = p->forw; ! 475: if(pf->op==ADDF && p->subop==pf->subop) { ! 476: p->op = LDF; ! 477: p->pop = 0; ! 478: pf->op = SUBF; ! 479: pf->pop = 0; ! 480: cp1 = p->code; ! 481: p->code = pf->code; ! 482: pf->code = cp1; ! 483: p = pf->forw; ! 484: break; ! 485: }} ! 486: case LDF: case LDFD: case CVLF: /* destroy acc */ ! 487: useacc = 0; ! 488: goto std; ! 489: case STF: ! 490: { register struct node *pf; ! 491: if((pf=flops(p)) != p) { ! 492: p = pf; /* usually p->forw; */ ! 493: break; ! 494: }} ! 495: if(ldmov(p)) { ! 496: p = p->forw; ! 497: break; ! 498: } ! 499: if(useacc == 0) ! 500: useacc = p; ! 501: goto std; ! 502: case ADDF: case MULF: /* commutatives - create clients for flops */ ! 503: /* stf a; ldf b; addf a => stf a; ldf a; addf b */ ! 504: { register struct node *pb = p->back; ! 505: register struct node *pbb = pb->back; ! 506: if(pb->op==LDF && pb->subop==p->subop && ! 507: pbb && pbb->op==STF && pbb->subop==p->subop && ! 508: equstr(pbb->code, p->code)) { ! 509: cp1 = p->code; ! 510: p->code = pb->code; ! 511: pb->code = cp1; ! 512: }} ! 513: /* use acc and regs */ ! 514: case CMPF: case CVFL: case SUBF: case DIVF: ! 515: if(useacc == 0) ! 516: useacc = p; ! 517: goto std; ! 518: case TSTF: ! 519: break; ! 520: case PUSHD: ! 521: if(ldmov(p)) { ! 522: p = p->forw; ! 523: break; ! 524: } ! 525: case CVDF: case NEGF: /* use only acc */ ! 526: case SINF: case COSF: case ATANF: case LOGF: case SQRTF: case EXPF: ! 527: if(useacc == 0) ! 528: useacc = p; ! 529: case EROU: case JSW: ! 530: case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ; ! 531: } ! 532: } ! 533: for (p= &first; p!=0; p=p->forw) ! 534: if (p->op==LABEL || p->op==DLABEL) p->ref=0; /* erase our tracks */ ! 535: } ! 536: ! 537: char * ! 538: byondrd(p) register struct node *p; { ! 539: /* return pointer to register which is "beyond last read/modify operand" */ ! 540: if (has2ops(p)) return(regs[RT3]); ! 541: switch (p->op) { ! 542: case MFPR: ! 543: case PUSHA: ! 544: case TST: case INC: case DEC: case PUSH: ! 545: case LDF: case LNF: case CVLF: case LDFD: ! 546: case ADDF: case SUBF: case MULF: case DIVF: ! 547: case CMPF: ! 548: return(regs[RT2]); ! 549: case MTPR: ! 550: #ifndef EMOD ! 551: case EDIV: ! 552: #endif EMOD ! 553: case CBR: /* must be JBC/JBS */ ! 554: case BIT: case CMP: case CALLS: case CALLF: ! 555: case CMPF2: ! 556: return(regs[RT3]); ! 557: case EMUL: ! 558: case PROBE: ! 559: case MOVBLK: ! 560: case CASE: ! 561: return(regs[RT4]); ! 562: } ! 563: return(lastrand); ! 564: } ! 565: ! 566: struct node * ! 567: bflow(p) ! 568: register struct node *p; ! 569: { ! 570: register char *cp1,*cp2,**preg; ! 571: register int r, fr, dblflg=0; ! 572: int flow= -1; ! 573: struct node *olduse=0, *olduse1=0; ! 574: ! 575: if (p->subop==QUAD || p->subop==DOUBLE || (p->subop&0xF0)==DOUBLE<<4 || ! 576: p->op==EMUL) ! 577: dblflg |= 1; /* double dest */ ! 578: if ((p->subop&0xF)==DOUBLE || p->subop==QUAD) ! 579: dblflg |= 2; /* double src */ ! 580: splitrand(p); ! 581: if (p->op!=PUSH && ! 582: #ifndef EMOD ! 583: p->op!=EDIV && ! 584: #endif EMOD ! 585: p->op!=EMUL && ! 586: p->subop && tempreg(lastrand,r) && uses[r]==p->forw) { ! 587: if (equtype(p->subop,regs[r][0]) || ! 588: ((p->op==CVT || p->op==MOVZ || p->op==CVFL) && ! 589: (regs[r][0]&0xf) && compat((p->subop>>4)&0xf,regs[r][0])) || ! 590: p->op==MOVA && compat(LONG, regs[r][0])) { ! 591: register int r2; ! 592: ! 593: if (regs[r][1]!=0) { /* send directly to destination */ ! 594: if (p->op==INC || p->op==DEC) { ! 595: p->op = (p->op==DEC) ? SUB : ADD; ! 596: /* use 2 now, convert to 3 later */ ! 597: p->subop=(OP2<<4)+(p->subop&0xF); ! 598: p->pop=0; ! 599: cp1=lastrand; cp2=regs[RT2]; ! 600: while (*cp2++= *cp1++) /* copy reg */ ! 601: ; ! 602: cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0; ! 603: } ! 604: cp1=regs[r]+1; cp2=lastrand; ! 605: if (has2ops(p)) { ! 606: /* use 3 operand form of instruction */ ! 607: p->pop=0; ! 608: p->subop += (OP3-OP2)<<4; ! 609: lastrand = cp2 = regs[RT3]; ! 610: } ! 611: while (*cp2++= *cp1++) ! 612: ; ! 613: if (p->op==MOVA && p->forw->op==PUSH) { ! 614: p->op=PUSHA; ! 615: *regs[RT2]=0; p->pop=0; ! 616: } else if ((p->op==MOV || p->op==CVT) && ! 617: p->forw->op==PUSH) { ! 618: p->op=PUSH; p->subop &= 0xF; ! 619: *regs[RT2]=0; p->pop=0; ! 620: } ! 621: delnode(p->forw); ! 622: if (tempreg(lastrand,r2)) ! 623: uses[r2]=uses[r], uses[r]=0; ! 624: redun3(p); ! 625: newcode(p); redunm++; flow=r; ! 626: } else if (p->op==MOV) { /* superfluous fetch */ ! 627: int nmatch; ! 628: char src[C2_ASIZE]; ! 629: movit: ! 630: for (cp2=src, cp1=regs[RT1]; *cp2++= *cp1++;) ! 631: ; ! 632: splitrand(p->forw); ! 633: if (p->forw->op != INC && p->forw->op != DEC) ! 634: lastrand=byondrd(p->forw); ! 635: nmatch=0; ! 636: for (preg=regs+RT1;*preg!=lastrand;preg++) ! 637: if (r==isreg(*preg)) { ! 638: cp2= *preg; cp1=src; ! 639: while (*cp2++= *cp1++) ! 640: ; ! 641: ++nmatch; ! 642: } ! 643: if (nmatch==1) { ! 644: if (has2ops(p->forw) && equstr(src,regs[RT2])) { ! 645: p->forw->pop=0; ! 646: p->forw->subop += (OP3-OP2)<<4; ! 647: cp1=regs[RT3]; ! 648: *cp1++ = 'r'; *cp1++ = r+'0'; *cp1=0; ! 649: } ! 650: delnode(p); ! 651: p=p->forw; ! 652: if (tempreg(src,r2)) ! 653: uses[r2]=uses[r], uses[r]=0; ! 654: redun3(p); ! 655: newcode(p); redunm++; ! 656: return(p); /* avoid stale uses[] data */ ! 657: } else ! 658: splitrand(p); ! 659: } ! 660: } else if (p->op==MOV && (p->forw->op==CVT || p->forw->op==MOVZ) && ! 661: p->forw->subop&0xf && /* if base or index, then forget it */ ! 662: compat(p->subop,p->forw->subop) && !indexa(cp1=regs[RT1])) ! 663: goto movit; ! 664: } ! 665: /* adjust 'lastrand' past any 'read' or 'modify' operands. */ ! 666: lastrand=byondrd(p); ! 667: /* a 'write' clobbers the register. */ ! 668: if (tempreg(lastrand,r) || ! 669: (has2ops(p) && tempreg(regs[RT2],r) && uses[r]==0)) { ! 670: /* ! 671: * Writing a dead register is useless, ! 672: * but watch side effects ! 673: */ ! 674: switch (p->op) { ! 675: #ifndef EMOD ! 676: case EDIV: ! 677: #endif EMOD ! 678: case AOBLEQ: case AOBLSS: ! 679: break; ! 680: default: ! 681: /* ! 682: * If no direct uses, check for ! 683: * use of condition codes ! 684: */ ! 685: if (uses[r]==0 && ((dblflg&1)==0 || uses[r+1]==0)) { ! 686: register struct node *q = p; ! 687: ! 688: while ((q = nonlab(q->forw))->op==JBR && ! 689: q->subop==0) ! 690: q=q->ref; /* cc unused, unchanged */ ! 691: if (q->op!=CBR && q->op!=ADDA && q->op!=SUBA) { ! 692: /* ... and destroyed */ ! 693: preg=regs+RT1; ! 694: while (cp1 = *preg++) { ! 695: if (cp1==lastrand && ! 696: p->op != CLR && ! 697: p->op != CVFL) { ! 698: redunm++; ! 699: delnode(p); ! 700: return(p->forw); ! 701: } ! 702: if (equstr(cp1,lastrand)) ! 703: break; ! 704: } ! 705: } ! 706: } ! 707: flow=r; ! 708: } ! 709: } ! 710: if ((r=flow) >= 0) { ! 711: olduse=uses[r], uses[r]=0; ! 712: *(short *)(regs[r])=0; ! 713: /* if r0 destroyed, dont keep r1 */ ! 714: if (dblflg&1) { ! 715: olduse1=uses[++r], uses[r]=0; ! 716: *(short *)(regs[r])=0; ! 717: } ! 718: } ! 719: /* now look for 'read' or 'modify' (read & write) uses */ ! 720: preg=regs+RT1; ! 721: while (*(cp1= *preg++)) { ! 722: /* check for r */ ! 723: if (lastrand!=cp1 && tempreg(cp1,r)) { ! 724: int isunused; ! 725: if (isunused=(uses[r]==0)) { ! 726: uses[r]=p; ! 727: cp2=regs[r]; *cp2++=p->subop; ! 728: if ((p->op==SHAL || p->op==SHAR || ! 729: p->op==SHL || p->op==SHR) && ! 730: cp1==regs[RT1]) ! 731: cp2[-1] = BYTE; ! 732: if (p->op==CBR && (p->subop==JBC || p->subop==JBS)) ! 733: cp2[-1] = LONG; ! 734: if (p->op==MOVA && cp1==regs[RT2]) ! 735: cp2[-1]=LONG; ! 736: } ! 737: /* ediv/emod's 2nd operand is quad */ ! 738: if (((p->op==EDIV ! 739: #ifdef EMOD ! 740: || p->op==EMOD ! 741: #endif EMOD ! 742: ) && cp1==regs[RT2] || (dblflg&2)) && ! 743: ++r<NUSE && uses[r]==0) { ! 744: if (isunused) ! 745: *cp2=0; ! 746: uses[r]=p; ! 747: cp2=regs[r]; *cp2++=p->subop; ! 748: if (!isunused) ! 749: *cp2=0; ! 750: } ! 751: if (!isunused) ! 752: continue; ! 753: if (p->op==MOV || p->op==PUSH || p->op==CVT || ! 754: p->op==MOVZ || p->op==COM || p->op==NEG || ! 755: p->op==STF) { ! 756: if (p->op!=PUSH) { ! 757: cp1=regs[RT2]; ! 758: if (tempreg(cp1,r)) { ! 759: /* ! 760: * reincarnation!! ! 761: * (as in addl2 r0,r1; ! 762: * movl r1,r0; ret) ! 763: */ ! 764: if (uses[r]==0) ! 765: uses[r]=olduse; ! 766: if ((dblflg&1) && uses[r+1]==0) ! 767: uses[r+1]=olduse1; ! 768: } ! 769: if (p->op!=MOV) ! 770: cp1=0; ! 771: } else ! 772: cp1="-(sp)"; ! 773: if (cp1) ! 774: while (*cp2++= *cp1++) ! 775: ; ! 776: else ! 777: *cp2=0; ! 778: } else ! 779: *cp2=0; ! 780: continue; ! 781: } ! 782: /* check for (r),[r] */ ! 783: do { ! 784: if (*cp1=='(' || *cp1=='[') { /* get register number */ ! 785: char t; ! 786: for (cp2= ++cp1; *++cp1!=')' && *cp1!=']';) ! 787: ; ! 788: t= *cp1; *cp1=0; ! 789: if (tempreg(cp2,r) && ! 790: (uses[r]==0 || uses[r]==p)) { ! 791: uses[r]=p; ! 792: regs[r][0] = ! 793: (*--cp2=='[' ? OPX<<4 : OPB<<4); ! 794: regs[r][1] = '\0'; ! 795: } ! 796: *cp1=t; ! 797: } ! 798: } while (*++cp1); ! 799: } ! 800: #ifdef MOVAFASTER ! 801: /* pushax or movax possibility? */ ! 802: cp1=regs[RT1]; ! 803: if (*cp1++=='$' && isstatic(cp1)) { ! 804: if (p->op==MOV && p->subop==LONG) { ! 805: if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) { ! 806: cp1=p->code; while (*cp1++!=','); p->code= --cp1; ! 807: } ! 808: p->op = MOVA; p->subop = BYTE; ++p->code; p->pop=0; ! 809: } else if (p->op==PUSH && p->subop==LONG) { ! 810: p->op = PUSHA; p->subop = BYTE; ++p->code; p->pop=0; ! 811: } else if (p->op==ADD && p->subop==U(LONG,OP3) ! 812: && 0<=(r=isreg(regs[RT2]))) { ! 813: cp1=cp2=p->code; ++cp1; ! 814: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='['; ! 815: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']'; ! 816: if (!equstr(regs[RT3],"-(sp)")){ p->op = MOVA; p->subop = BYTE;} ! 817: else {p->op = PUSHA; p->subop = BYTE; *cp2=0;} ! 818: if (uses[r]==0) {uses[r]=p; regs[r][0]=OPX<<4;} ! 819: p->pop=0; ! 820: } ! 821: } ! 822: #endif MOVAFASTER ! 823: return (p); ! 824: } ! 825: ! 826: /* try to eliminate STF's */ ! 827: struct node * ! 828: flops(q) ! 829: register struct node *q; ! 830: { ! 831: register struct node *p; ! 832: register int r; ! 833: ! 834: if(q->op!=STF || !tempreg(q->code,r)) ! 835: return(q); ! 836: if(uses[r]) { ! 837: /* see if anyone destroys acc between us */ ! 838: for(p=q->forw; p!=uses[r]; p=p->forw) ! 839: switch(p->op) { ! 840: case LABEL: ! 841: case LDF: case LNF: case CVLF: case LDFD: ! 842: case CVDF: case NEGF: case ADDF: case SUBF: ! 843: case MULF: case DIVF: case SINF: case COSF: ! 844: case ATANF: case LOGF: case SQRTF: case EXPF: ! 845: return(q); ! 846: } ! 847: again: ! 848: if(q->subop == p->subop) ! 849: switch(p->op) { /* do it in the accumulator */ ! 850: case LDF: /* redundant load */ ! 851: delnode(p); nld++; ! 852: p = p->forw; ! 853: break; ! 854: case LNF: /* stf r; lnf r ==> negf */ ! 855: p->op = NEGF; ! 856: p->pop = 0; ! 857: p->code = 0; ! 858: break; ! 859: case CMPF2: /* stf r; cmpf2 r,x ==> cmpf x */ ! 860: { register char *s; ! 861: register struct node *p1=p->forw; ! 862: for(s=p->code; *s!=','; s++); ! 863: *s = 0; ! 864: if(isreg(p->code) == r) ! 865: p->code = s+1; ! 866: else { ! 867: if(p1->op != CBR || isreg(s+1) != r) { ! 868: *s = ','; ! 869: return(q); ! 870: } ! 871: if(p1->subop > JNE) { ! 872: p1->subop ^= 1; ! 873: p1->pop = 0; ! 874: nrevbr++; ! 875: } ! 876: } ! 877: p->op = CMPF; ! 878: p->pop = 0; ! 879: } ! 880: break; ! 881: default: ! 882: return(q); ! 883: } ! 884: else if(p->subop==LONG) { ! 885: switch(p->op) { ! 886: case TST: /* stf r; tstl r ==> tstf */ ! 887: p->op = TSTF; ! 888: p->code = 0; ! 889: break; ! 890: /* send directly to destination */ ! 891: case MOV: /* stf r; movl r,x ==> stf x */ ! 892: case PUSH: /* stf r; pushl r ==> stf -(sp)/pushd */ ! 893: if(q->subop == DOUBLE) { ! 894: register struct node *b = p->back; ! 895: /* assume b's 2nd arg is ok */ ! 896: if(!(b==uses[r+1] && b->op==p->op && b->subop==LONG)) ! 897: return(q); ! 898: delnode(b); redunm++; ! 899: } ! 900: if(p->op==PUSH) { ! 901: if(q->subop == DOUBLE) { ! 902: p->op = PUSHD; ! 903: p->code = 0; ! 904: } else { ! 905: p->op = q->op; ! 906: p->code = copy("-(sp)"); ! 907: } ! 908: } else { ! 909: p->op = q->op; ! 910: while(*p->code++ != ','); ! 911: } ! 912: break; ! 913: default: ! 914: return(q); ! 915: } ! 916: p->pop = 0; ! 917: p->subop = q->subop; ! 918: } else ! 919: return(q); ! 920: uses[r] = 0; ! 921: if(q->subop == DOUBLE) ! 922: uses[r+1] = 0; ! 923: for(p = p->back; p != q && (!uses[r] || !uses[r+1]); p = p->back) { ! 924: int xr; ! 925: ! 926: splitrand(p); ! 927: if((xr=isreg(regs[RT1])) < 0) ! 928: continue; ! 929: if(!uses[r] && xr == r) ! 930: uses[r] = p; ! 931: else if(q->subop == DOUBLE && !uses[r+1] && xr == r+1) ! 932: uses[r+1] = p; ! 933: } ! 934: if(p = uses[r]) ! 935: goto again; ! 936: return(q->forw); /* DON'T re-scan code with dated uses[] */ ! 937: } ! 938: /* it's a store to reg which isnt used elsewhere */ ! 939: if((p=q->forw)->op == CBR) { ! 940: q->op = TSTF; ! 941: q->pop = 0; ! 942: q->code = 0; ! 943: } else { ! 944: delnode(q); nst++; ! 945: if(p->op ==STF || p->op==TSTF || p->op==PUSHD) { ! 946: if(useacc == p) ! 947: useacc = 0; ! 948: return(p->forw); /* so ldmov can be used on p */ ! 949: } ! 950: } ! 951: return(p); ! 952: } ! 953: ! 954: /* try to change load/store sequences to movl */ ! 955: ldmov(q) ! 956: register struct node *q; ! 957: { ! 958: register struct node *p; ! 959: register char *s, *pcod, *cp; ! 960: char *dlsw(); ! 961: ! 962: p = q->back; ! 963: if(!(useacc==0 && (q->op==STF || q->op==TSTF || q->op==PUSHD) ! 964: && ((p->op==LDF && p->subop==q->subop) || (p->op==LDFD && q->subop==DOUBLE)))) ! 965: return(0); ! 966: pcod = p->code; ! 967: cp = p->code; ! 968: /* prepare args for movl/pushl */ ! 969: if(q->op!=TSTF && q->subop==DOUBLE) { ! 970: if(p->op == LDF) { ! 971: if((s = dlsw(p->code)) == NULL) ! 972: return(0); ! 973: ! 974: strcpy(line, s); ! 975: if(q->op == STF) { ! 976: strcat(line, ","); ! 977: if((s = dlsw(q->code)) == NULL) ! 978: return(0); ! 979: strcat(line, s); ! 980: p->op = MOV; ! 981: } else ! 982: p->op = PUSH; ! 983: } else { /* LDFD */ ! 984: if(q->op == STF) { ! 985: if((s = dlsw(q->code)) == NULL) ! 986: return(0); ! 987: } else ! 988: s = "-(sp)"; ! 989: strcpy(line, s); ! 990: p->op = CLR; ! 991: } ! 992: p->pop = 0; ! 993: p->subop = LONG; ! 994: p->code = copy(line); ! 995: } else ! 996: { ! 997: if ((p->op == LDF) && (p->subop == DOUBLE) && ! 998: (indexa(cp))) return(0); ! 999: delnode(p); ! 1000: } ! 1001: strcpy(line, pcod); ! 1002: if(q->op == STF) { /* ldf x; stf y ==> movl x,y */ ! 1003: strcat(line, ","); ! 1004: strcat(line, q->code); ! 1005: q->op = MOV; ! 1006: nst++; ! 1007: } else if(q->op == TSTF) /* ldf x; tstf ==> tstl x */ ! 1008: q->op = TST; ! 1009: else /* ldd x; pushd ==> pushl x+4; pushl x */ ! 1010: q->op = PUSH; ! 1011: q->pop = 0; ! 1012: q->subop = LONG; ! 1013: q->code = copy(line); ! 1014: nld++; ! 1015: return(1); ! 1016: } ! 1017: ! 1018: /* reconstruct the address of l.s.w. of a double operand */ ! 1019: char * ! 1020: dlsw(d) ! 1021: register char *d; ! 1022: { ! 1023: register char *s, *t, *c; ! 1024: register int r; ! 1025: static char lsw[C2_ASIZE]; ! 1026: ! 1027: if(d[0] == '*' || d[0] == '$') ! 1028: return(NULL); ! 1029: if (((strncmp(d, "(r", 2)) == 0) && isdigit(d[2])) ! 1030: return(NULL); ! 1031: t = lsw; ! 1032: if((r=isreg(d)) >= 0) ! 1033: sprintf(t, "r%d", r+1); ! 1034: else { ! 1035: for(s=d; *s && *s!='('; *t++ = *s++) ! 1036: if(*s == '[') ! 1037: return(NULL); ! 1038: if(s!=d) ! 1039: *t++ = '+'; ! 1040: *t++ = '4'; ! 1041: while(*t++ = *s) ! 1042: if(*s++ == '[' ) ! 1043: { ! 1044: return(NULL); ! 1045: } ! 1046: } ! 1047: return(lsw); ! 1048: } ! 1049: checkexpr(p) ! 1050: register char *p; ! 1051: { ! 1052: ! 1053: while(*p && *p != ','){ ! 1054: if ((*p == '+' ) || (*p == '-')) ! 1055: return(1); ! 1056: *p++; ! 1057: } ! 1058: return(0); ! 1059: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.