![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / c2|
Return to c21.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / c2 |
1.1 ! root 1: /* ! 2: * C object code improver-- second part ! 3: */ ! 4: ! 5: #include "c2.h" ! 6: #include <stdio.h> ! 7: #include <ctype.h> ! 8: ! 9: #define NUSE 6 ! 10: int ioflag; ! 11: int bitsize[4] = {0,8,16,32}; /* index by type codes */ ! 12: struct node *uses[NUSE]; /* for backwards flow analysis */ ! 13: char *lastrand; /* last operand of instruction */ ! 14: struct node *bflow(); ! 15: ! 16: redun3(p) register struct node *p; { ! 17: /* check for 3 addr instr which should be 2 addr */ ! 18: if (OP3==((p->subop>>4)&0xF)) { ! 19: if (equstr(regs[RT1],regs[RT3]) ! 20: && (p->op==ADD || p->op==MUL || p->op==AND || p->op==OR || p->op==XOR)) { ! 21: register char *t=regs[RT1]; regs[RT1]=regs[RT2]; regs[RT2]=t; ! 22: } ! 23: if (equstr(regs[RT2],regs[RT3])) { ! 24: p->subop=(p->subop&0xF)|(OP2<<4); p->pop=0; ! 25: lastrand=regs[RT2]; *regs[RT3]=0; return(1); ! 26: } ! 27: } return(0); ! 28: } ! 29: ! 30: bmove() { ! 31: register struct node *p, *lastp; register char *cp1,*cp2; register int r; ! 32: refcount(); ! 33: for (p=lastp= &first; 0!=(p=p->forw); lastp=p); ! 34: clearreg(); clearuse(); ! 35: for (p=lastp; p!= &first; p=p->back) { ! 36: if (debug) { ! 37: printf("Uses:\n"); ! 38: for (r=NUSE;--r>=0;) if (uses[r]) ! 39: printf("%d: %s\n",r,uses[r]->code? uses[r]->code:""); ! 40: printf("-\n"); ! 41: } ! 42: r=(p->subop>>4)&0xF; ! 43: splitrand(p); ! 44: if (OP3==r && 0!=redun3(p)) {newcode(p); redunm++;} ! 45: /* ops that do nothing */ ! 46: if(p->op==MOV && equstr(regs[RT1], regs[RT2])) ! 47: if(p->forw->op!=CBR) { ! 48: delnode(p); redunm++; continue; ! 49: } else { ! 50: p->op=TST; p->pop=0; ! 51: while(*p->code++ != ','); ! 52: redunm++; ! 53: } ! 54: else if((cp1=p->code, *cp1++)=='$' && ! 55: (*cp1=='0' || *cp1=='1' || *cp1++=='-' && *cp1=='1') && cp1[1]==',') { ! 56: switch((p->code[1]<<8)|p->op) { ! 57: case (('0'<<8)|ADD): ! 58: case (('0'<<8)|SUB): ! 59: case (('-'<<8)|AND): ! 60: case (('0'<<8)|OR): ! 61: case (('0'<<8)|XOR): ! 62: case (('1'<<8)|MUL): ! 63: case (('1'<<8)|DIV): ! 64: case (('0'<<8)|SHAL): ! 65: case (('0'<<8)|SHAR): ! 66: case (('0'<<8)|SHL): ! 67: case (('0'<<8)|SHR): ! 68: if(r == OP2) { ! 69: if(p->forw->op!=CBR) { ! 70: delnode(p); redunm++; continue; ! 71: } else { ! 72: p->op=TST; p->subop&=0xF; p->pop=0; ! 73: while(*p->code++ != ','); ! 74: redunm++; ! 75: } ! 76: } else { /* OP3 or shift */ ! 77: p->op=MOV; p->subop&=0xF; p->pop=0; ! 78: while(*p->code++ != ','); ! 79: p = p->forw; redunm++; continue; ! 80: } ! 81: break; ! 82: case (('0'<<8)|MUL): ! 83: case (('0'<<8)|AND): ! 84: p->op=CLR; p->subop&=0xF; p->pop=0; ! 85: while(*p->code++ != ','); ! 86: if(r == OP3) ! 87: while(*p->code++ != ','); ! 88: redunm++; ! 89: } ! 90: } ! 91: switch (p->op) { ! 92: case LABEL: case DLABEL: ! 93: for (r=NUSE; --r>=0;) ! 94: if (uses[r]) p->ref=(struct node *) (((int)p->ref)|(1<<r)); ! 95: break; ! 96: case CALLS: ! 97: case CALLF: ! 98: clearuse(); goto std; ! 99: case 0: ! 100: clearuse(); break; ! 101: case CVT: ! 102: { long n; ! 103: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code; ! 104: if (*cp1++!='$') goto std; splitrand(p); ! 105: n = getnum(®s[RT1][1]); ! 106: if(r==BYTE && (n<-128 || n>127)) goto std; ! 107: if(r==WORD && (n<-32768 || n>32767)) goto std; ! 108: p->op = MOV; p->subop = r; p->pop = 0; nchange++; ! 109: } goto std; ! 110: ! 111: case SUB: ! 112: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code; ! 113: if (*cp1++!='$') goto std; splitrand(p); ! 114: #ifdef MOVAFASTER ! 115: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */ ! 116: char buf[C2_ASIZE]; cp2=buf; *cp2++='-'; ! 117: cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2; ! 118: cp1="(fp),"; while (*cp2++= *cp1++); --cp2; ! 119: cp1=regs[RT3]; while (*cp2++= *cp1++); ! 120: p->code=copy(buf); p->op = MOVA; p->subop = BYTE; p->pop=0; ! 121: } else ! 122: #endif MOVAFASTER ! 123: if (*cp1++=='-' && 0<=(r=getnum(cp1))) { ! 124: p->op=ADD; p->pop=0; *--cp1='$'; p->code=cp1; ! 125: } goto std; ! 126: case ADD: ! 127: if ((p->subop&0xF)!=LONG) goto std; cp1=p->code; ! 128: if (*cp1++!='$') goto std; splitrand(p); ! 129: if (isstatic(cp1) && (r=isreg(regs[RT2]))>=0 && r<NUSE && uses[r]==p->forw) ! 130: { ! 131: /* address comp: ! 132: ** addl2 $_foo,r0 \ movab _foo[r0],bar ! 133: ** movl r0,bar / ! 134: */ ! 135: register struct node *pnext = p->forw; ! 136: char buf[C2_ASIZE]; ! 137: ! 138: if (pnext->op == MOV && pnext->subop == LONG) ! 139: { ! 140: cp1 = ®s[RT1][1]; cp2 = &buf[0]; ! 141: while (*cp2++ = *cp1++) ; cp2--; ! 142: splitrand(pnext); ! 143: if (r == isreg(regs[RT1])) ! 144: { ! 145: delnode(p); p = pnext; ! 146: p->op = MOVA; p->subop = BYTE; ! 147: p->pop = 0; ! 148: cp1 = regs[RT1]; *cp2++ = '['; ! 149: while (*cp2++ = *cp1++) ; cp2--; ! 150: *cp2++ = ']'; *cp2++ = ','; ! 151: cp1 = regs[RT2]; ! 152: while (*cp2++ = *cp1++) ; ! 153: p->code = copy(buf); ! 154: } ! 155: } ! 156: } ! 157: else ! 158: #ifdef MOVAFASTER ! 159: if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */ ! 160: cp2=cp1-1; cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2; ! 161: cp1="(fp)"; while (*cp2++= *cp1++); *--cp2=','; ! 162: p->op = MOVA; p->subop = BYTE; p->pop=0; ! 163: } else ! 164: #endif MOVAFASTER ! 165: if (*cp1++=='-' && 0<=(r=getnum(cp1))) { ! 166: p->op=SUB; p->pop=0; *--cp1='$'; p->code=cp1; ! 167: } ! 168: /* fall thru ... */ ! 169: case CASE: ! 170: default: std: ! 171: p=bflow(p); break; ! 172: ! 173: case MUL: ! 174: /* ! 175: ** Change multiplication ! 176: ** by constant powers of 2 to shifts. ! 177: */ ! 178: splitrand(p); ! 179: if (regs[RT1][0] != '$' || regs[RT1][1] == '-') goto std; ! 180: if ((r = ispow2(getnum(®s[RT1][1]))) <= 0) goto std; ! 181: /* mull2 $2,x */ ! 182: if(r == 1 && p->subop == U(LONG, OP2)) { ! 183: strcpy(regs[RT1], regs[RT2]); ! 184: p->op = ADD; p->pop = 0; newcode(p); nchange++; ! 185: goto std; ! 186: } ! 187: if (p->subop == U(LONG,OP2)) ! 188: strcpy(regs[RT3], regs[RT2]); ! 189: sprintf(regs[RT1], "$%d", r); ! 190: p->op = SHL; p->subop = LONG; ! 191: p->pop = 0; newcode(p); nchange++; ! 192: goto std; ! 193: ! 194: case SHAL: ! 195: case SHL: ! 196: { ! 197: /* bit tests: ! 198: ** shll A,$1,rC \ ! 199: ** bitl B,rC > jbc A,B,D ! 200: ** jeql D / ! 201: ** ! 202: ** address comp: ! 203: ** shll $1,bar,r0 \ movl bar,r0 ! 204: ** movab _foo[r0] / movaw _foo[r0] ! 205: ** ! 206: ** shll $2,r0,r0 \ moval _foo[r0] ! 207: ** movab _foo[r0] / ! 208: */ ! 209: register struct node *pf; ! 210: register struct node *pn; ! 211: register int shfrom, shto; ! 212: long shcnt; ! 213: char *regfrom; ! 214: ! 215: splitrand(p); ! 216: if (regs[RT1][0] != '$') { ! 217: if (isreg(regs[RT1]) < 0) goto std; /* alignment */ ! 218: if (regs[RT2][0] != '$') goto std; ! 219: if (getnum(®s[RT2][1]) != 1) goto std; ! 220: r = isreg(regs[RT3]); ! 221: if (r < 0 || r >= NUSE) goto std; ! 222: if ((pf = p->forw)->op != BIT && pf->op!=AND) goto std; ! 223: if (uses[r] && uses[r] != pf) goto std; ! 224: splitrand(pf); ! 225: if (r == isreg(regs[RT1])) cp2 = regs[RT2]; ! 226: else if (r == isreg(regs[RT2])) cp2 = regs[RT1]; ! 227: else goto std; ! 228: if(*cp2 == '$') goto std; ! 229: if ((pn = pf->forw)->op != CBR) goto std; ! 230: if (pn->subop != JEQ && pn->subop != JNE) goto std; ! 231: delnode(p); delnode(pf); ! 232: pn->subop = (pn->subop == JEQ) ? JBC : JBS; ! 233: for(cp1=p->code; *cp1++!=',';); ! 234: while (*cp1++= *cp2++); ! 235: pn->code = p->code; pn->pop = NULL; ! 236: uses[r] = NULL; ! 237: nbj++; nchange++; ! 238: p = pn; goto std; ! 239: } ! 240: if ((shcnt = getnum(®s[RT1][1])) < 1 || shcnt > 2) goto std; ! 241: if ((shfrom = isreg(regs[RT2])) >= 0) ! 242: regfrom = copy(regs[RT2]); ! 243: if ((shto = isreg(regs[RT3])) >= 0 && shto<NUSE) ! 244: { ! 245: int regnum; ! 246: ! 247: if (uses[shto] != (pf = p->forw)) goto ashadd; ! 248: if (pf->op != MOVA && pf->op != PUSHA) goto ashadd; ! 249: if (pf->subop != BYTE) goto ashadd; ! 250: splitrand(pf); ! 251: if (!indexa(regs[RT1])) goto std; ! 252: cp2 = regs[RT1]; ! 253: if(!isstatic(cp2)) goto std; ! 254: while (*cp2++ != '[') ; ! 255: if (*cp2++ != 'r' || !isdigit(*cp2)) goto std; ! 256: regnum = *cp2++ - '0'; ! 257: if (isdigit(*cp2)) ! 258: { ! 259: if (cp2[1] != ']') goto std; ! 260: regnum *= 10; regnum += *cp2 - '0'; ! 261: } ! 262: if (regnum != shto) goto std; ! 263: if (shfrom >= 0) /* shll $N,r*,r0 */ ! 264: { ! 265: delnode(p); ! 266: p = pf; ! 267: if (shfrom != shto) ! 268: { ! 269: uses[shto] = NULL; splitrand(pf); ! 270: cp2=regs[RT1]; while (*cp2++!='['); ! 271: cp1=regfrom; while (*cp2++= *cp1++); ! 272: cp2[-1] = ']'; *cp2 = 0; ! 273: newcode(pf); ! 274: } ! 275: } ! 276: else ! 277: { ! 278: p->op = MOV; splitrand(p); ! 279: strcpy(regs[RT1], regs[RT2]); ! 280: strcpy(regs[RT2], regs[RT3]); ! 281: regs[RT3][0] = '\0'; ! 282: p->pop = 0; newcode(p); ! 283: } ! 284: switch (shcnt) ! 285: { ! 286: case 1: pf->subop = WORD; break; ! 287: case 2: pf->subop = LONG; break; ! 288: } ! 289: redunm++; nsaddr++; nchange++; ! 290: } ! 291: goto std; ! 292: ashadd: ! 293: /* at this point, RT2 and RT3 are guaranteed to be simple regs*/ ! 294: if (shcnt == 1) { ! 295: /* ! 296: ** quickie: ! 297: ** shll $1,A,A > addl2 A,A ! 298: ** shll $1,A,B > addl3 A,A,B ! 299: */ ! 300: p->op = ADD; ! 301: strcpy(regs[RT1], regs[RT2]); ! 302: if(equstr(regs[RT2], regs[RT3])) { ! 303: p->subop = U(LONG,OP2); ! 304: regs[RT3][0] = '\0'; ! 305: } else ! 306: p->subop = U(LONG,OP3); ! 307: p->pop = 0; ! 308: newcode(p); nchange++; ! 309: } ! 310: goto std; ! 311: } ! 312: ! 313: case SHAR: ! 314: case SHR: ! 315: { ! 316: /* bit tests: ! 317: ** shrl A,B,rC \ ! 318: ** bitl $1,rC > jbc A,B,D ! 319: ** jeql D / ! 320: */ ! 321: register struct node *pf; /* forward node */ ! 322: register struct node *pn; /* next node (after pf) */ ! 323: register int extreg; /* reg extracted to */ ! 324: ! 325: splitrand(p); ! 326: if (isreg(regs[RT1]) < 0) goto std; /* alignment */ ! 327: extreg = isreg(regs[RT3]); ! 328: if (extreg < 0 || extreg >= NUSE) goto std; ! 329: if ((pf = p->forw)->op != BIT) goto std; ! 330: if (uses[extreg] && uses[extreg] != pf) goto std; ! 331: splitrand(pf); ! 332: if (regs[RT1][0] != '$') goto std; ! 333: if (getnum(®s[RT1][1]) != 1) goto std; ! 334: if (extreg != isreg(regs[RT2])) goto std; ! 335: if ((pn = pf->forw)->op != CBR) goto std; ! 336: if (pn->subop != JEQ && pn->subop != JNE) goto std; ! 337: delnode(p); delnode(pf); ! 338: pn->subop = (pn->subop == JEQ) ? JBC : JBS; ! 339: for(cp1=p->code; *cp1++!=',';); ! 340: while (*cp1!=',') cp1++; *cp1='\0'; ! 341: pn->code = p->code; pn->pop = NULL; ! 342: uses[extreg] = NULL; nbj++; ! 343: nchange++; ! 344: p = pn; goto std; ! 345: } ! 346: ! 347: case AND: ! 348: { ! 349: /* unsigned conversion: ! 350: ** cvtbl A,B; andl2 $255,B > movzbl A,B ! 351: ** ! 352: ** also byte- and word-size fields: ! 353: ** shrl $(3-n)*8,A,B; andl2 $255,B > movzbl n+A,B ! 354: ** shrl $(1-n)*16,A,B; andl2 $65535,B > movzwl n+A,B ! 355: */ ! 356: char src[C2_ASIZE]; ! 357: register f; /* field length */ ! 358: register struct node *pb = p->back; /* backward node */ ! 359: ! 360: if (p->subop != U(LONG,OP2)) ! 361: goto std; ! 362: splitrand(p); cp1=regs[RT1]; ! 363: if (*cp1++!='$' || (f=getnum(cp1))!=0xff && f!=0xffff) ! 364: goto std; ! 365: f = f==0xff ? 8 : 16; ! 366: if (pb->op!=CVT && pb->op!=MOVZ && pb->op!=SHAR && pb->op!=SHR) ! 367: goto std; ! 368: /* save source of ANDL in 'src' */ ! 369: strcpy(src, regs[RT2]); ! 370: splitrand(pb); ! 371: if (!equstr(src,lastrand)) ! 372: goto std; ! 373: if (pb->op==CVT || pb->op==MOVZ) { ! 374: if (!(bitsize[pb->subop&0xF]==f ! 375: && bitsize[pb->subop>>4]>=f)) /* good CVT */ ! 376: goto std; ! 377: strcpy(src, regs[RT1]); ! 378: } else { ! 379: register int boff; /* bit offset */ ! 380: ! 381: if (regs[RT1][0] != '$') goto std; ! 382: if ((boff = getnum(®s[RT1][1])) < 0) goto std; ! 383: if (isreg(regs[RT2])>=0 || !natural(regs[RT2])) goto std; ! 384: if ((boff & (f-1)) != 0) goto std; ! 385: boff = (32-boff-f) / 8; ! 386: if (boff == 0) ! 387: strcpy(src, regs[RT2]); ! 388: else ! 389: sprintf(src, "%d%s%s", boff, regs[RT2][0]=='(' ? "":"+", ! 390: regs[RT2]); ! 391: } ! 392: delnode(pb); ! 393: p->op = MOVZ; ! 394: p->subop = U((f==8 ? BYTE : WORD), LONG); ! 395: sprintf(line,"%s,%s",src,lastrand); ! 396: p->pop=0; ! 397: p->code = copy(line); ! 398: nchange++; ! 399: goto std; ! 400: } ! 401: ! 402: case CMP: ! 403: { ! 404: /* comparison to -63 to -1: ! 405: ** cmpl r0,$-1 > incl r0 ! 406: ** jeql ... ! 407: ** ! 408: ** cmpl r0,$-63 > addl2 $63,r0 ! 409: ** jeql ... ! 410: */ ! 411: register int num; ! 412: register int reg; ! 413: register struct node *regp = p->back; ! 414: ! 415: if (p->forw->op != CBR) goto std; ! 416: if (p->forw->subop != JEQ && p->forw->subop != JNE) goto std; ! 417: splitrand(p); ! 418: if (strncmp(regs[RT2], "$-", 2) != 0) goto std; ! 419: reg = r = isreg(regs[RT1]); ! 420: if (r < 0) goto std; ! 421: if (r < NUSE && uses[r] != 0) goto std; ! 422: if (r >= NUSE && regp->op == MOV && p->subop == regp->subop) ! 423: { ! 424: if (*regp->code != 'r') goto std; ! 425: reg = regp->code[1] - '0'; ! 426: if (isdigit(regp->code[2]) || reg >= NUSE || uses[reg]) ! 427: goto std; ! 428: } ! 429: if (r >= NUSE) goto std; ! 430: if (reg != r) ! 431: sprintf(regs[RT1], "r%d", reg); ! 432: if ((num = getnum(®s[RT2][2])) <= 0 || num > 63) goto std; ! 433: if (num == 1) ! 434: { ! 435: p->op = INC; regs[RT2][0] = '\0'; ! 436: } ! 437: else ! 438: { ! 439: register char *t; ! 440: ! 441: t=regs[RT1];regs[RT1]=regs[RT2];regs[RT2]=t; ! 442: p->op = ADD; p->subop = U(p->subop, OP2); ! 443: for (t = ®s[RT1][2]; t[-1] = *t; t++) ; ! 444: } ! 445: p->pop = 0; newcode(p); ! 446: nchange++; ! 447: goto std; ! 448: } ! 449: ! 450: case JBR: case JMP: ! 451: clearuse(); ! 452: if (p->subop==RET) { ! 453: uses[0]=p; regs[0][0]= -1; ! 454: uses[1]=p; regs[1][0]= -1; ! 455: break; ! 456: } ! 457: if (p->ref==0) goto std; /* jmp (r0) */ ! 458: /* fall through */ ! 459: case CBR: ! 460: if (p->ref->ref!=0) for (r=NUSE;--r>=0;) ! 461: if ((1<<r) & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;} ! 462: case EROU: case JSW: ! 463: case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ; ! 464: } ! 465: } ! 466: for (p= &first; p!=0; p=p->forw) ! 467: if (p->op==LABEL || p->op==DLABEL) p->ref=0; /* erase our tracks */ ! 468: } ! 469: ! 470: rmove() ! 471: { ! 472: register struct node *p; ! 473: register int r, r1; ! 474: ! 475: clearreg(); ! 476: for (p=first.forw; p!=0; p = p->forw) { ! 477: if (debug) { ! 478: printf("Regs:\n"); ! 479: for (r=0; r<NREG; r++) ! 480: if (regs[r][0]) { ! 481: r1=regs[r][0]; ! 482: printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1); ! 483: } ! 484: printf("-\n"); ! 485: } ! 486: switch (p->op) { ! 487: ! 488: case CVT: ! 489: case MOVZ: ! 490: splitrand(p); ! 491: repladdr(p); ! 492: r = isreg(regs[RT1]); ! 493: r1 = isreg(regs[RT2]); ! 494: dest(regs[RT2],p->subop, 1); ! 495: if (r>=0 && r1>=0) { ! 496: p->op = MOV; p->subop = LONG; ! 497: p->pop = 0; ! 498: nchange++; ! 499: goto case_mov; ! 500: } ! 501: if(p->op == CVT) { ! 502: if (r1>=0) savereg(r1, regs[RT1], p->subop); ! 503: } else ! 504: ccloc[0] = 0; ! 505: break; ! 506: ! 507: case MOV: ! 508: case_mov: ! 509: splitrand(p); ! 510: if ((r = findrand(regs[RT1],p->subop)) >= 0) { ! 511: if (r == isreg(regs[RT2])) ! 512: if(p->forw->op!=CBR) { ! 513: delnode(p); redunm++; nchange++; break; ! 514: } else { ! 515: p->op=TST; p->pop=0; ! 516: while(*p->code++ != ','); ! 517: redunm++; nchange++; ! 518: goto case_tst; ! 519: } ! 520: } ! 521: repladdr(p); ! 522: r = isreg(regs[RT1]); ! 523: r1 = isreg(regs[RT2]); ! 524: dest(regs[RT2],p->subop, 1); ! 525: if (r>=0) { ! 526: if (r1>=0) { ! 527: if (r == r1 && p->forw->op!=CBR) { ! 528: delnode(p); redunm++; nchange++; break; ! 529: } ! 530: if(regs[r][0]) ! 531: savereg(r1, regs[r]+1, p->subop); ! 532: } else savereg(r, regs[RT2], p->subop); ! 533: } else if (r1>=0) savereg(r1, regs[RT1], p->subop); ! 534: else setcon(regs[RT1], regs[RT2], p->subop); ! 535: break; ! 536: ! 537: /* .rx,.wx or .rx,.rx,.wx */ ! 538: case ADD: ! 539: case SUB: ! 540: case AND: ! 541: case OR: ! 542: case XOR: ! 543: case MUL: ! 544: case DIV: ! 545: case SHAL: ! 546: case SHAR: ! 547: case SHL: ! 548: case SHR: ! 549: case ADDA: ! 550: case SUBA: ! 551: /* .rx,.wx */ ! 552: case MFPR: ! 553: case COM: ! 554: case NEG: ! 555: splitrand(p); ! 556: repladdr(p); ! 557: dest(lastrand,p->subop, p->op!=ADDA && p->op!=SUBA); ! 558: break; ! 559: ! 560: /* .mx or .wx */ ! 561: case CLR: ! 562: case INC: ! 563: case DEC: ! 564: splitrand(p); ! 565: dest(lastrand,p->subop, 1); ! 566: if (p->op==CLR) ! 567: if ((r = isreg(regs[RT1])) >= 0) ! 568: savereg(r, "$0", p->subop); ! 569: else ! 570: setcon("$0", regs[RT1], p->subop); ! 571: break; ! 572: ! 573: /* .rx */ ! 574: case TST: ! 575: case_tst: ! 576: case PUSH: ! 577: splitrand(p); ! 578: lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */ ! 579: repladdr(p); ! 580: lastrand=regs[RT1]; ! 581: if (p->op==TST && equstr(lastrand, ccloc+1) ! 582: && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))) { ! 583: delnode(p); nrtst++; nchange++; break; ! 584: } ! 585: if (p->op==PUSH && p->subop!=LONG && ! 586: (isreg(lastrand)>=0 || *lastrand=='$')) { ! 587: p->subop = LONG; ! 588: p->pop = 0; ! 589: nchange++; ! 590: } ! 591: setcc(lastrand,p->subop); ! 592: break; ! 593: ! 594: /* .rx,.rx,.rx */ ! 595: case PROBE: ! 596: case CASE: ! 597: /* .rx,.rx */ ! 598: case MTPR: ! 599: case CALLS: ! 600: case CALLF: ! 601: case CMP: ! 602: case BIT: ! 603: splitrand(p); ! 604: /* fool repladdr into doing right number of operands */ ! 605: if (p->op==CASE || p->op==PROBE) ! 606: lastrand=regs[RT4]; ! 607: else lastrand=regs[RT3]; ! 608: if (p->op==CALLF || p->op==CALLS) clearreg(); ! 609: else repladdr(p); ! 610: ccloc[0]=0; break; ! 611: ! 612: /* .rx,.rx,.wx,.wx */ ! 613: case EDIV: ! 614: splitrand(p); ! 615: lastrand = regs[RT3]; ! 616: repladdr(p); ! 617: dest(regs[RT3], p->subop, 1); ! 618: dest(regs[RT4], p->subop, 0); ! 619: break; ! 620: ! 621: case CBR: ! 622: if (p->subop>=JBC) { ! 623: splitrand(p); ! 624: lastrand=regs[RT3]; /* 2 operands can be optimized */ ! 625: repladdr(p); ! 626: ccloc[0] = 0; ! 627: } else ! 628: reduncbr(p); ! 629: break; ! 630: ! 631: case JBR: ! 632: redunbr(p); ! 633: ! 634: default: ! 635: clearreg(); ! 636: } ! 637: } ! 638: } ! 639: ! 640: char * ! 641: byondrd(p) register struct node *p; { ! 642: /* return pointer to register which is "beyond last read/modify operand" */ ! 643: if (OP2==(p->subop>>4)) return(regs[RT3]); ! 644: switch (p->op) { ! 645: case MFPR: ! 646: case PUSHA: ! 647: case TST: case INC: case DEC: case PUSH: return(regs[RT2]); ! 648: case CBR: /* must be JBC/JBS */ ! 649: case MTPR: case EDIV: ! 650: case BIT: case CMP: case CALLS: case CALLF: return(regs[RT3]); ! 651: case PROBE: ! 652: case MOVBLK: ! 653: case CASE: return(regs[RT4]); ! 654: } ! 655: return(lastrand); ! 656: } ! 657: ! 658: struct node * ! 659: bflow(p) ! 660: register struct node *p; ! 661: { ! 662: register char *cp1,*cp2,**preg; register int r; ! 663: ! 664: int flow= -1; ! 665: struct node *olduse=0; ! 666: splitrand(p); ! 667: if (p->op!=PUSH && p->op!=EDIV && p->subop && 0<=(r=isreg(lastrand)) ! 668: && r<NUSE && uses[r]==p->forw) { ! 669: if (equtype(p->subop,regs[r][0]) ! 670: || ((p->op==CVT || p->op==MOVZ) ! 671: && 0xf®s[r][0] && compat(0xf&(p->subop>>4),regs[r][0])) ! 672: || p->op==MOVA && compat(LONG, regs[r][0])) { ! 673: register int r2; ! 674: if (regs[r][1]!=0) {/* send directly to destination */ ! 675: if (p->op==INC || p->op==DEC) { ! 676: if (p->op==DEC) p->op=SUB; else p->op=ADD; ! 677: p->subop=(OP2<<4)+(p->subop&0xF); /* use 2 now, convert to 3 later */ ! 678: p->pop=0; ! 679: cp1=lastrand; cp2=regs[RT2]; while (*cp2++= *cp1++); /* copy reg */ ! 680: cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0; ! 681: } ! 682: cp1=regs[r]+1; cp2=lastrand; ! 683: if (OP2==(p->subop>>4)) {/* use 3 operand form of instruction */ ! 684: p->pop=0; ! 685: p->subop += (OP3-OP2)<<4; lastrand=cp2=regs[RT3]; ! 686: } ! 687: while (*cp2++= *cp1++); ! 688: if (p->op==MOVA && p->forw->op==PUSH) { ! 689: p->op=PUSHA; ! 690: *regs[RT2]=0; p->pop=0; ! 691: } else if ((p->op==MOV || p->op==CVT) && p->forw->op==PUSH) { ! 692: p->op=PUSH; p->subop &= 0xF; ! 693: *regs[RT2]=0; p->pop=0; ! 694: } ! 695: delnode(p->forw); ! 696: if (0<=(r2=isreg(lastrand)) && r2<NUSE) { ! 697: uses[r2]=uses[r]; uses[r]=0; ! 698: } ! 699: redun3(p); ! 700: newcode(p); redunm++; flow=r; ! 701: } else if (p->op==MOV) { ! 702: /* superfluous fetch */ ! 703: int nmatch; ! 704: char src[C2_ASIZE]; ! 705: movit: ! 706: cp2=src; cp1=regs[RT1]; while (*cp2++= *cp1++); ! 707: splitrand(p->forw); ! 708: if (p->forw->op != INC && p->forw->op != DEC) ! 709: lastrand=byondrd(p->forw); ! 710: nmatch=0; ! 711: for (preg=regs+RT1;*preg!=lastrand;preg++) ! 712: if (r==isreg(*preg)) { ! 713: cp2= *preg; cp1=src; while (*cp2++= *cp1++); ++nmatch; ! 714: } ! 715: if (nmatch==1) { ! 716: if (OP2==(p->forw->subop>>4) && equstr(src,regs[RT2])) { ! 717: p->forw->pop=0; ! 718: p->forw->subop += (OP3-OP2)<<4; cp1=regs[RT3]; ! 719: *cp1++='r'; *cp1++=r+'0'; *cp1=0; ! 720: } ! 721: delnode(p); p=p->forw; ! 722: if (0<=(r2=isreg(src)) && r2<NUSE) { ! 723: uses[r2]=uses[r]; uses[r]=0; ! 724: } ! 725: redun3(p); ! 726: newcode(p); redunm++; flow=r; ! 727: } else splitrand(p); ! 728: } ! 729: } else if (p->op==MOV && (p->forw->op==CVT || p->forw->op==MOVZ) ! 730: && p->forw->subop&0xf /* if base or index, then forget it */ ! 731: && compat(p->subop,p->forw->subop) && !indexa(cp1=regs[RT1])) ! 732: goto movit; ! 733: } ! 734: /* adjust 'lastrand' past any 'read' or 'modify' operands. */ ! 735: lastrand=byondrd(p); ! 736: /* a 'write' clobbers the register. */ ! 737: if (0<=(r=isreg(lastrand)) && r<NUSE ! 738: || OP2==(p->subop>>4) && 0<=(r=isreg(regs[RT2])) && r<NUSE && uses[r]==0) { ! 739: /* writing a dead register is useless, but watch side effects */ ! 740: switch (p->op) { ! 741: case AOBLEQ: case AOBLSS: case EDIV: break; ! 742: default: ! 743: if (uses[r]==0) {/* no direct uses, check for use of condition codes */ ! 744: register struct node *q=p; ! 745: while ((q=nonlab(q->forw))->op==JBR && q->subop==0) q=q->ref; /* cc unused, unchanged */ ! 746: if (q->op!=CBR && q->op!=ADDA && q->op!=SUBA) {/* ... and destroyed */ ! 747: preg=regs+RT1; ! 748: while (cp1= *preg++) { ! 749: if (cp1==lastrand) {redunm++; delnode(p); return(p->forw);} ! 750: if (equstr(cp1,lastrand)) break; ! 751: } ! 752: } ! 753: } ! 754: flow=r; ! 755: } ! 756: } ! 757: if (0<=(r=flow)) {olduse=uses[r]; uses[r]=0; *(short *)(regs[r])=0;} ! 758: /* now look for 'read' or 'modify' (read & write) uses */ ! 759: preg=regs+RT1; ! 760: while (*(cp1= *preg++)) { ! 761: /* check for r */ ! 762: if (lastrand!=cp1 && 0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0) { ! 763: uses[r]=p; cp2=regs[r]; *cp2++=p->subop; ! 764: if((p->op==SHAL || p->op==SHAR || p->op==SHL || p->op==SHR) ! 765: && cp1==regs[RT1]) cp2[-1]=BYTE; ! 766: if(p->op==CBR && (p->subop==JBC || p->subop==JBS)) cp2[-1]=LONG; ! 767: if(p->op==MOVA && cp1==regs[RT2]) cp2[-1]=LONG; ! 768: if(p->op==MOV || p->op==PUSH || p->op==CVT || p->op==MOVZ || p->op==COM || p->op==NEG) { ! 769: if (p->op==PUSH) cp1="-(sp)"; ! 770: else { ! 771: cp1=regs[RT2]; ! 772: if (0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0) ! 773: uses[r]=olduse; /* reincarnation!! */ ! 774: /* as in addl2 r0,r1; movl r1,r0; ret */ ! 775: if (p->op!=MOV) cp1=0; ! 776: } ! 777: if (cp1) while (*cp2++= *cp1++); ! 778: else *cp2=0; ! 779: } else *cp2=0; ! 780: continue; ! 781: } ! 782: /* check for (r),[r] */ ! 783: do if (*cp1=='(' || *cp1=='[') {/* get register number */ ! 784: char t; ! 785: cp2= ++cp1; while (*++cp1!=')' && *cp1!=']'); t= *cp1; *cp1=0; ! 786: if (0<=(r=isreg(cp2)) && r<NUSE && (uses[r]==0 || uses[r]==p)) { ! 787: uses[r]=p; regs[r][0]=(*--cp2=='[' ? OPX<<4 : OPB<<4); ! 788: } ! 789: *cp1=t; ! 790: } while (*++cp1); ! 791: } ! 792: /* ediv's 2nd operand is quad */ ! 793: if(p->op==EDIV && 0<=(r=isreg(regs[RT2])) && ++r<NUSE && uses[r]==0) { ! 794: uses[r]=p; cp2=regs[r]; *cp2++=p->subop; ! 795: *cp2=0; ! 796: } ! 797: #ifdef MOVAFASTER ! 798: /* pushax or movax possibility? */ ! 799: cp1=regs[RT1]; ! 800: if (*cp1++=='$' && isstatic(cp1)) { ! 801: if (p->op==MOV && p->subop==LONG) { ! 802: if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) { ! 803: cp1=p->code; while (*cp1++!=','); p->code= --cp1; ! 804: } ! 805: p->op = MOVA; p->subop = BYTE; ++p->code; p->pop=0; ! 806: } else if (p->op==PUSH && p->subop==LONG) { ! 807: p->op = PUSHA; p->subop = BYTE; ++p->code; p->pop=0; ! 808: } else if (p->op==ADD && p->subop==U(LONG,OP3) ! 809: && 0<=(r=isreg(regs[RT2]))) { ! 810: cp1=cp2=p->code; ++cp1; ! 811: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='['; ! 812: do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']'; ! 813: if (!equstr(regs[RT3],"-(sp)")){ p->op = MOVA; p->subop = BYTE;} ! 814: else {p->op = PUSHA; p->subop = BYTE; *cp2=0;} ! 815: if (uses[r]==0) {uses[r]=p; regs[r][0]=OPX<<4;} ! 816: p->pop=0; ! 817: } ! 818: } ! 819: #endif MOVAFASTER ! 820: return(p); ! 821: } ! 822: ! 823: jumpsw() ! 824: { ! 825: register struct node *p, *p1, *pt; ! 826: register t, nj; ! 827: ! 828: t = 0; ! 829: nj = 0; ! 830: for (p=first.forw; p!=0; p = p->forw) ! 831: p->seq = ++t; ! 832: for (p=first.forw; p!=0; p = p1) { ! 833: p1 = p->forw; ! 834: if (p->op == CBR && p1->op==JBR && p->ref && p1->ref ! 835: && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) { ! 836: if (p->ref==p1->ref) ! 837: continue; ! 838: p->subop = revbr[p->subop]; ! 839: p->pop=0; ! 840: pt = p1->ref; ! 841: p1->ref = p->ref; ! 842: p->ref = pt; ! 843: t = p1->labno; ! 844: p1->labno = p->labno; ! 845: p->labno = t; ! 846: #ifdef COPYCODE ! 847: if (p->labno == 0) { ! 848: pt = (struct node *)p1->code; p1->code = p->code; p->code = (char *)pt; ! 849: } ! 850: #endif ! 851: nrevbr++; ! 852: nj++; ! 853: } ! 854: } ! 855: return(nj); ! 856: } ! 857: ! 858: addaob() ! 859: { ! 860: register struct node *p, *p1, *p2, *p3; ! 861: ! 862: for (p = &first; (p1 = p->forw)!=0; p = p1) { ! 863: if (p->op==INC && p->subop==LONG) { ! 864: if (p1->op==LABEL && p1->refc==1 && p1->forw->op==CMP && p1->forw->subop==LONG ! 865: && (p2=p1->forw->forw)->op==CBR && p2->subop==JLE ! 866: && (p3=p2->ref->back)->op==JBR && p3->subop==0 && p3->ref==p1 ! 867: && p3->forw->op==LABEL && p3->forw==p2->ref) { ! 868: /* change INC LAB: CMP to LAB: INC CMP */ ! 869: p->back->forw=p1; p1->back=p->back; ! 870: p->forw=p1->forw; p1->forw->back=p; ! 871: p->back=p1; p1->forw=p; ! 872: p1=p->forw; ! 873: /* adjust beginning value by 1 */ ! 874: p2=alloc(sizeof first); p2->op = DEC; p2->subop = LONG; ! 875: p2->pop=0; ! 876: p2->forw=p3; p2->back=p3->back; p3->back->forw=p2; ! 877: p3->back=p2; p2->code=p->code; p2->labno=0; ! 878: } ! 879: if (p1->op==CMP && p1->subop==LONG && ! 880: (p2=p1->forw)->op==CBR && p2->forw->op!=CBR) { ! 881: register char *cp1,*cp2; ! 882: splitrand(p1); if (!equstr(p->code,regs[RT1])) continue; ! 883: if (p2->subop==JLE || p2->subop==JLT) { ! 884: if (p2->subop==JLE) p->op = AOBLEQ; else p->op = AOBLSS; p->subop = 0; ! 885: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */ ! 886: cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */ ! 887: p->pop=0; newcode(p); ! 888: p->labno = p2->labno; delnode(p2); delnode(p1); naob++; ! 889: } ! 890: } ! 891: } ! 892: } ! 893: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.