![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c22.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / c2 / c2.tahoe / save2|
Return to c22.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / c2 / c2.tahoe / save2 |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "%W% (Berkeley/CCI) %G%"; ! 3: #endif ! 4: ! 5: /* ! 6: * C object code improver-- third part ! 7: */ ! 8: ! 9: #include "c2.h" ! 10: #include <stdio.h> ! 11: #include <ctype.h> ! 12: ! 13: rmove() ! 14: { ! 15: register struct node *p; ! 16: register int r, r1; ! 17: ! 18: clearreg(); ! 19: for (p=first.forw; p!=0; p = p->forw) { ! 20: if (debug) { ! 21: printf("Regs: "); ! 22: for (r=0; r<=NREG; r++) ! 23: if (regs[r][0]) { ! 24: r1=regs[r][0]; ! 25: printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1); ! 26: } ! 27: printf("-\n"); ! 28: } ! 29: switch (p->op) { ! 30: ! 31: case CVT: ! 32: case MOVZ: ! 33: splitrand(p); ! 34: repladdr(p); ! 35: r = isreg(regs[RT1]); ! 36: r1 = isreg(regs[RT2]); ! 37: dest(regs[RT2],p->subop, 1); ! 38: if (r>=0 && r1>=0) { ! 39: p->op = MOV; p->subop = LONG; ! 40: p->pop = 0; ! 41: nchange++; ! 42: goto case_mov; ! 43: } ! 44: if(p->op == CVT) { ! 45: if (r1>=0) savereg(r1, regs[RT1], p->subop); ! 46: } else ! 47: ccloc[0] = 0; ! 48: break; ! 49: ! 50: case MOV: ! 51: case_mov: ! 52: splitrand(p); ! 53: if ((r = findrand(regs[RT1],p->subop)) >= 0) { ! 54: if (r == isreg(regs[RT2])) ! 55: if(p->forw->op!=CBR) { ! 56: delnode(p); redunm++; nchange++; break; ! 57: } else { ! 58: p->op=TST; p->pop=0; ! 59: while(*p->code++ != ','); ! 60: redunm++; nchange++; ! 61: goto case_tst; ! 62: } ! 63: } ! 64: repladdr(p); ! 65: r = isreg(regs[RT1]); ! 66: r1 = isreg(regs[RT2]); ! 67: dest(regs[RT2],p->subop, 1); ! 68: if ((regs[ACC][0]) && equstr(regs[RT2],regs[ACC]+1)) ! 69: *(short *)(regs[ACC]) = 0; ! 70: if (r>=0) { ! 71: if (r1>=0) { ! 72: if (r == r1 && p->forw->op!=CBR) { ! 73: delnode(p); redunm++; nchange++; ! 74: break; ! 75: } ! 76: if(regs[r][0]) ! 77: savereg(r1, regs[r]+1, p->subop); ! 78: } else ! 79: savereg(r, regs[RT2], p->subop); ! 80: } else if (r1>=0) ! 81: savereg(r1, regs[RT1], p->subop); ! 82: else ! 83: setcon(regs[RT1], regs[RT2], p->subop); ! 84: break; ! 85: ! 86: /* .rx,.wx or .rx,.rx,.wx */ ! 87: case ADD: ! 88: case SUB: ! 89: case AND: ! 90: case OR: ! 91: case XOR: ! 92: case MUL: ! 93: case DIV: ! 94: #ifdef EMOD ! 95: case EDIV: ! 96: case EMOD: ! 97: #endif EMOD ! 98: case SHAL: ! 99: case SHAR: ! 100: case SHL: ! 101: case SHR: ! 102: case ADDA: ! 103: case SUBA: ! 104: /* .rx,.wx */ ! 105: case MFPR: ! 106: case COM: ! 107: case NEG: ! 108: splitrand(p); ! 109: repladdr(p); ! 110: dest(lastrand,p->subop, p->op!=ADDA && p->op!=SUBA); ! 111: break; ! 112: ! 113: /* .mx or .wx */ ! 114: case STF: ! 115: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 116: delnode(p); ! 117: nst++; nchange++; break; ! 118: } ! 119: savereg(ACC, p->code, p->subop); ! 120: case INC: ! 121: case DEC: ! 122: case CVFL: ! 123: dest(p->code,p->subop, 1); ! 124: break; ! 125: ! 126: case CLR: ! 127: dest(p->code,p->subop, 1); ! 128: if ((regs[ACC][0]) && equstr(p->code,regs[ACC]+1)) ! 129: *(short *)(regs[ACC]) = 0; ! 130: if ((r = isreg(p->code)) < 0) ! 131: setcon("$0", p->code, p->subop); ! 132: else ! 133: savereg(r, "$0", p->subop); ! 134: break; ! 135: ! 136: /* .rx */ ! 137: case LDF: ! 138: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 139: delnode(p); ! 140: nld++; nchange++; break; ! 141: } ! 142: savereg(ACC, p->code, p->subop); ! 143: goto case_tst; ! 144: case LNF: ! 145: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 146: p->op = NEGF; p->pop = 0; p->code = 0; ! 147: regs[ACC][0] = 0; ! 148: break; ! 149: } ! 150: case CVLF: ! 151: case LDFD: ! 152: case ADDF: ! 153: case SUBF: ! 154: case MULF: ! 155: case DIVF: ! 156: regs[ACC][0] = 0; ! 157: case TST: ! 158: case_tst: ! 159: case PUSH: ! 160: splitrand(p); ! 161: lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */ ! 162: repladdr(p); ! 163: lastrand=regs[RT1]; ! 164: if (p->op==TST && equstr(lastrand, ccloc+1) ! 165: && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))) { ! 166: delnode(p); nrtst++; nchange++; break; ! 167: } ! 168: if (p->op==PUSH && p->subop!=LONG && ! 169: (isreg(lastrand)>=0 || *lastrand=='$')) { ! 170: p->subop = LONG; ! 171: p->pop = 0; ! 172: nchange++; ! 173: } ! 174: if (p->op==TST || p->op==PUSH) ! 175: setcc(lastrand,p->subop); ! 176: break; ! 177: ! 178: /* .rx,.rx,.rx */ ! 179: case PROBE: ! 180: case CASE: ! 181: /* .rx,.rx */ ! 182: case MTPR: ! 183: case CALLS: ! 184: case CALLF: ! 185: case CMP: ! 186: case BIT: ! 187: case CMPF: ! 188: case CMPF2: ! 189: splitrand(p); ! 190: /* fool repladdr into doing right number of operands */ ! 191: lastrand=byondrd(p); ! 192: if (p->op==CALLF || p->op==CALLS) clearreg(); ! 193: else repladdr(p); ! 194: case TSTF: ! 195: ccloc[0]=0; ! 196: case PUSHD: ! 197: break; ! 198: ! 199: /* acc only */ ! 200: case CVDF: ! 201: case NEGF: ! 202: case SINF: ! 203: case COSF: ! 204: case ATANF: ! 205: case LOGF: ! 206: case SQRTF: ! 207: case EXPF: ! 208: regs[ACC][0] = 0; ! 209: break; ! 210: ! 211: #ifndef EMOD ! 212: /* .rx,.rx,.wx,.wx */ ! 213: case EDIV: ! 214: splitrand(p); ! 215: lastrand = regs[RT3]; ! 216: repladdr(p); ! 217: dest(regs[RT3], p->subop, 1); ! 218: dest(regs[RT4], p->subop, 0); ! 219: break; ! 220: #endif EMOD ! 221: ! 222: /* .rx,.rx,.rx,wx */ ! 223: case EMUL: ! 224: splitrand(p); ! 225: lastrand = regs[RT4]; ! 226: repladdr(p); ! 227: dest(regs[RT4],QUAD, 1); /* fourth operand is a quad */ ! 228: break; ! 229: case CBR: ! 230: if (p->subop>=JBC) { ! 231: splitrand(p); ! 232: lastrand=regs[RT3]; /* 2 operands can be optimized */ ! 233: repladdr(p); ! 234: ccloc[0] = 0; ! 235: } else ! 236: reduncbr(p); ! 237: break; ! 238: ! 239: case JBR: ! 240: redunbr(p); ! 241: ! 242: default: ! 243: clearreg(); ! 244: } ! 245: } ! 246: } ! 247: ! 248: jumpsw() ! 249: { ! 250: register struct node *p, *p1, *pt; ! 251: register int t, nj; ! 252: ! 253: t = 0; ! 254: nj = 0; ! 255: for (p=first.forw; p!=0; p = p->forw) ! 256: p->seq = ++t; ! 257: for (p=first.forw; p!=0; p = p1) { ! 258: p1 = p->forw; ! 259: if (p->op == CBR && p1->op==JBR && p->ref && p1->ref ! 260: && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) { ! 261: if (p->ref==p1->ref) ! 262: continue; ! 263: p->subop = revbr[p->subop]; ! 264: p->pop=0; ! 265: pt = p1->ref; ! 266: p1->ref = p->ref; ! 267: p->ref = pt; ! 268: t = p1->labno; ! 269: p1->labno = p->labno; ! 270: p->labno = t; ! 271: #ifdef COPYCODE ! 272: if (p->labno == 0) { ! 273: pt = (struct node *)p1->code; p1->code = p->code; p->code = (char *)pt; ! 274: } ! 275: #endif ! 276: nrevbr++; ! 277: nj++; ! 278: } ! 279: } ! 280: return(nj); ! 281: } ! 282: ! 283: addaob() ! 284: { ! 285: register struct node *p, *p1, *p2, *p3; ! 286: ! 287: for (p = &first; (p1 = p->forw)!=0; p = p1) { ! 288: if (p->op==INC && p->subop==LONG) { ! 289: if (p1->op==LABEL && p1->refc==1 && p1->forw->op==CMP && p1->forw->subop==LONG ! 290: && (p2=p1->forw->forw)->op==CBR && p2->subop==JLE ! 291: && (p3=p2->ref->back)->op==JBR && p3->subop==0 && p3->ref==p1 ! 292: && p3->forw->op==LABEL && p3->forw==p2->ref) { ! 293: /* change INC LAB: CMP to LAB: INC CMP */ ! 294: p->back->forw=p1; p1->back=p->back; ! 295: p->forw=p1->forw; p1->forw->back=p; ! 296: p->back=p1; p1->forw=p; ! 297: p1=p->forw; ! 298: /* adjust beginning value by 1 */ ! 299: p2=alloc(sizeof first); p2->op = DEC; p2->subop = LONG; ! 300: p2->pop=0; ! 301: p2->forw=p3; p2->back=p3->back; p3->back->forw=p2; ! 302: p3->back=p2; p2->code=p->code; p2->labno=0; ! 303: } ! 304: if (p1->op==CMP && p1->subop==LONG && ! 305: (p2=p1->forw)->op==CBR && p2->forw->op!=CBR) { ! 306: register char *cp1,*cp2; ! 307: splitrand(p1); if (!equstr(p->code,regs[RT1])) continue; ! 308: if ((p2->subop==JLE || p2->subop==JLT) && ! 309: checkaobdisp(p2)){ ! 310: if (p2->subop==JLE) p->op = AOBLEQ; else p->op = AOBLSS; p->subop = 0; ! 311: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */ ! 312: cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */ ! 313: p->pop=0; newcode(p); ! 314: p->labno = p2->labno; delnode(p2); delnode(p1); naob++; ! 315: } ! 316: } ! 317: } ! 318: } ! 319: } ! 320: ! 321: ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */ ! 322: register int log; ! 323: if (n==0 || n&(n-1)) return(-1); log=0; ! 324: for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);} ! 325: } ! 326: ! 327: equop(p1, p2) ! 328: register struct node *p1, *p2; ! 329: { ! 330: register char *cp1, *cp2; ! 331: ! 332: if (p1->op != p2->op || p1->subop != p2->subop) ! 333: return(0); ! 334: if (p1->op != NIL && ord(p1->op) < ord(MOV)) ! 335: return(0); ! 336: if (p1->op==MOVA && p1->labno!=p2->labno) return(0); ! 337: cp1 = p1->code; ! 338: cp2 = p2->code; ! 339: if (cp1==0 && cp2==0) ! 340: return(1); ! 341: if (cp1==0 || cp2==0) ! 342: return(0); ! 343: while (*cp1 == *cp2++) ! 344: if (*cp1++ == 0) ! 345: return(1); ! 346: return(0); ! 347: } ! 348: ! 349: delnode(p) register struct node *p; { ! 350: p->back->forw = p->forw; ! 351: p->forw->back = p->back; ! 352: } ! 353: ! 354: decref(p) ! 355: register struct node *p; ! 356: { ! 357: if (p && --p->refc <= 0) { ! 358: nrlab++; nchange++; ! 359: delnode(p); ! 360: } ! 361: } ! 362: ! 363: struct node * ! 364: nonlab(ap) ! 365: struct node *ap; ! 366: { ! 367: register struct node *p; ! 368: ! 369: p = ap; ! 370: while (p && p->op==LABEL) ! 371: p = p->forw; ! 372: return(p); ! 373: } ! 374: ! 375: clearuse() { ! 376: register struct node **i; ! 377: register short *p; ! 378: for (i=uses+NREG; i>uses;) *--i=0; ! 379: useacc = 0; ! 380: for (p=usecnt+NUSE; p>usecnt;) *--p=0; ! 381: } ! 382: ! 383: clearreg() { ! 384: register char **i; ! 385: for (i=regs+NREG+1; i>regs;){ **--i=0; **i=0; } ! 386: conloc[0] = 0; ccloc[0] = 0; ! 387: } ! 388: ! 389: savereg(ai, s, type) ! 390: register char *s; ! 391: { ! 392: register char *p, *sp; ! 393: ! 394: sp = p = regs[ai]; ! 395: /* if any indexing, must be parameter or local */ ! 396: /* indirection (as in "*-4(fp)") is ok, however */ ! 397: *p++ = type; ! 398: if (*s=='*' || *s=='$') ! 399: *p++ = *s++; ! 400: if (natural(s)) ! 401: strcpy(p, s); ! 402: else {*sp = 0; return;} ! 403: } ! 404: ! 405: dest(s,type, ccflg) ! 406: register char *s; ! 407: { ! 408: register int i; ! 409: ! 410: if ((i = isreg(s)) >= 0) { ! 411: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */ ! 412: if (DOUBLE==(type&0xF) || DOUBLE==((type>>4)&0xF) || type==QUAD) ! 413: *(short *)(regs[i+1]) = 0; ! 414: } ! 415: for (i=NREG; --i>=0;) ! 416: if (regs[i][1]=='*' && equstr(s, regs[i]+2)) ! 417: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */ ! 418: while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */ ! 419: *(short *)(regs[i]) = 0; ! 420: ! 421: if (!natural(s)) {/* wild store, everything except constants vanishes */ ! 422: for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0; ! 423: conloc[0] = 0; ccloc[0] = 0; ! 424: } else { ! 425: if(ccflg)setcc(s,type); /* natural destinations set condition codes */ ! 426: if (equstr(s, conloc)) ! 427: conloc[0] = 0; ! 428: } ! 429: } ! 430: ! 431: splitrand(p) struct node *p; { ! 432: /* separate operands at commas, set up 'regs' and 'lastrand' */ ! 433: register char *p1, *p2; register char **preg; ! 434: ! 435: preg=regs+RT1; ! 436: if (p1=p->code) while (*p1) { ! 437: lastrand=p2= *preg++; ! 438: while (*p1) if (','==(*p2++= *p1++)) {--p2; break;} ! 439: *p2=0; ! 440: } ! 441: while (preg<(regs+RT1+5)) *(*preg++)=0; ! 442: } ! 443: ! 444: compat(have, want) ! 445: register int have, want; ! 446: { ! 447: register int hsrc, hdst; ! 448: extern int bitsize[]; ! 449: ! 450: if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */ ! 451: hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc; ! 452: if (want>=QUAD) ! 453: return(bitsize[hdst]==bitsize[want] && bitsize[hsrc]==bitsize[want]); ! 454: return(hsrc==want && hdst>=want && hdst<QUAD); ! 455: } ! 456: ! 457: equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));} ! 458: ! 459: findrand(as, type) ! 460: char *as; ! 461: { ! 462: register char **i; ! 463: for (i = regs+NREG; --i>=regs;) { ! 464: if (**i && equstr(*i+1, as) && compat(**i,type)) ! 465: return(i-regs); ! 466: } ! 467: return(-1); ! 468: } ! 469: ! 470: isreg(s) ! 471: register char *s; ! 472: { ! 473: if (*s++!='r' || !isdigit(*s++)) return(-1); ! 474: if (*s==0) return(*--s-'0'); ! 475: if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0'); ! 476: return(-1); ! 477: } ! 478: ! 479: /* ! 480: check() ! 481: { ! 482: register struct node *p, *lp; ! 483: ! 484: lp = &first; ! 485: for (p=first.forw; p!=0; p = p->forw) { ! 486: if (p->back != lp) ! 487: abort(-1); ! 488: lp = p; ! 489: } ! 490: } ! 491: */ ! 492: ! 493: newcode(p) struct node *p; { ! 494: register char *p1,*p2,**preg; ! 495: ! 496: preg=regs+RT1; p2=line; ! 497: while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';} ! 498: *--p2=0; ! 499: p->code=copy(line); ! 500: } ! 501: ! 502: repladdr(p) ! 503: struct node *p; ! 504: { ! 505: register int r; ! 506: register char *p1; ! 507: register char **preg; ! 508: register int nrepl; ! 509: ! 510: preg=regs+RT1; nrepl=0; ! 511: while (lastrand!=(p1= *preg++)) ! 512: if (0<=(r=findrand(p1,p->subop))) { ! 513: *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0; ! 514: nchange++; nrepl++; nsaddr++; ! 515: } ! 516: if (nrepl) newcode(p); ! 517: } ! 518: ! 519: /* conditional branches which are never/always taken */ ! 520: reduncbr(p) ! 521: register struct node *p; ! 522: { ! 523: register struct node *p1; ! 524: register char *ap1, *ap2; ! 525: ! 526: p1 = p->back; ! 527: if (p1->op==CMP) { ! 528: splitrand(p1); ! 529: ap1 = findcon(regs[RT1], p1->subop); ! 530: ap2 = findcon(regs[RT2], p1->subop); ! 531: } else { ! 532: if(!ccloc[0]) ! 533: return; ! 534: ap1 = findcon(ccloc+1, ccloc[0]); ! 535: ap2 = "$0"; ! 536: } ! 537: switch (compare(p->subop, ap1, ap2)) { ! 538: case 0: /* branch never taken */ ! 539: delnode(p); ! 540: nredunj++; ! 541: nchange++; ! 542: decref(p->ref); ! 543: if(p->forw->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 544: delnode(p1); ! 545: nrtst++; ! 546: } ! 547: break; ! 548: case 1: /* branch always taken */ ! 549: p->op = JBR; ! 550: p->subop = 0; ! 551: p->pop = 0; ! 552: nchange++; ! 553: if(nonlab(p->ref)->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 554: delnode(p1); ! 555: nrtst++; ! 556: } ! 557: } ! 558: } ! 559: ! 560: /* a jump to a redundant compare (start of a 'for') */ ! 561: redunbr(p) ! 562: register struct node *p; ! 563: { ! 564: register struct node *p1; ! 565: register char *ap1, *ap2; ! 566: ! 567: if ((p1 = p->ref) == 0) ! 568: return; ! 569: p1 = nonlab(p1); ! 570: if (p1->op==TST || p1->op==CMP) ! 571: splitrand(p1); ! 572: else ! 573: return; ! 574: if (p1->forw->op==CBR) { ! 575: ap1 = findcon(regs[RT1], p1->subop); ! 576: if (p1->op==TST) ! 577: ap2 = "$0"; ! 578: else ! 579: ap2 = findcon(regs[RT2], p1->subop); ! 580: p1 = p1->forw; ! 581: if (compare(p1->subop, ap1, ap2) > 0) { ! 582: nredunj++; ! 583: nchange++; ! 584: decref(p->ref); ! 585: p->ref = p1->ref; ! 586: p->labno = p1->labno; ! 587: #ifdef COPYCODE ! 588: if (p->labno == 0) ! 589: p->code = p1->code; ! 590: if (p->ref) ! 591: #endif ! 592: p->ref->refc++; ! 593: } ! 594: } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) && ! 595: equtype(ccloc[0],p1->subop)) { ! 596: p1=insertl(p1->forw); decref(p->ref); p->ref=p1; ! 597: nrtst++; nchange++; ! 598: } ! 599: } ! 600: ! 601: char * ! 602: findcon(p, type) ! 603: register char *p; ! 604: { ! 605: register int r; ! 606: ! 607: if (*p=='$') ! 608: return(p); ! 609: if ((r = isreg(p)) >= 0 && compat(regs[r][0],type)) ! 610: return(regs[r]+1); ! 611: if (equstr(p, conloc) && equtype(conloc[0], type)) ! 612: return(conval+1); ! 613: return(p); ! 614: } ! 615: ! 616: /* compare constants: 0 - branch taken; 1 - not taken; -1 - don't know */ ! 617: compare(op, acp1, acp2) ! 618: char *acp1, *acp2; ! 619: { ! 620: register char *cp1, *cp2; ! 621: register int n1, n2, sign; ! 622: ! 623: cp1 = acp1; ! 624: cp2 = acp2; ! 625: if (*cp1++ != '$' || *cp2++ != '$') ! 626: return(-1); ! 627: n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;} ! 628: while (isdigit(*cp1)) {n1 *= 10; n1 += *cp1++ - '0';} ! 629: n1 *= sign; ! 630: n2 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;} ! 631: while (isdigit(*cp2)) {n2 *= 10; n2 += *cp2++ - '0';} ! 632: n2 *= sign; ! 633: if (*cp1=='+') ! 634: cp1++; ! 635: if (*cp2=='+') ! 636: cp2++; ! 637: do { ! 638: if (*cp1++ != *cp2) ! 639: return(-1); ! 640: } while (*cp2++); ! 641: switch(op) { ! 642: ! 643: case JEQ: ! 644: return(n1 == n2); ! 645: case JNE: ! 646: return(n1 != n2); ! 647: case JLE: ! 648: return(n1 <= n2); ! 649: case JGE: ! 650: return(n1 >= n2); ! 651: case JLT: ! 652: return(n1 < n2); ! 653: case JGT: ! 654: return(n1 > n2); ! 655: case JLO: ! 656: return((unsigned)n1 < (unsigned)n2); ! 657: case JHI: ! 658: return((unsigned)n1 > (unsigned)n2); ! 659: case JLOS: ! 660: return((unsigned)n1 <= (unsigned)n2); ! 661: case JHIS: ! 662: return((unsigned)n1 >= (unsigned)n2); ! 663: } ! 664: return(-1); ! 665: } ! 666: ! 667: setcon(cv, cl, type) ! 668: register char *cv, *cl; ! 669: { ! 670: register char *p; ! 671: ! 672: if (*cv != '$') ! 673: return; ! 674: if (!natural(cl)) ! 675: return; ! 676: p = conloc; ! 677: while (*p++ = *cl++); ! 678: p = conval; ! 679: *p++ = type; ! 680: while (*p++ = *cv++); ! 681: } ! 682: ! 683: setcc(ap,type) ! 684: char *ap; ! 685: { ! 686: register char *p, *p1; ! 687: ! 688: p = ap; ! 689: if (!natural(p)) { ! 690: ccloc[0] = 0; ! 691: return; ! 692: } ! 693: p1 = ccloc; ! 694: *p1++ = type; ! 695: while (*p1++ = *p++); ! 696: } ! 697: ! 698: indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */ ! 699: while (*p) if (*p++=='[') return(1); ! 700: return(0); ! 701: } ! 702: ! 703: natural(p) ! 704: register char *p; ! 705: {/* 1->simple local, parameter, global, or register; 0->otherwise */ ! 706: ! 707: if (*p=='*' || *p=='(' || *p=='$') ! 708: return(0); ! 709: while (*p++); ! 710: p--; ! 711: if (*--p==']' || *p==')' && ! 712: !(*(p-2)=='f' || fortflg && (*--p=='1' || *p=='2') && *--p=='1')) ! 713: return(0); ! 714: return(1); ! 715: } ! 716: ! 717: /* ! 718: ** Tell if an argument is most likely static. ! 719: */ ! 720: ! 721: isstatic(cp) ! 722: register char *cp; ! 723: { ! 724: if (*cp == '_' || *cp == 'L') ! 725: return (1); ! 726: return (0); ! 727: } ! 728: ! 729: ! 730: checkaobdisp(p) ! 731: register struct node *p; ! 732: { ! 733: register struct node *q; ! 734: register int i; ! 735: ! 736: ! 737: if (!aobflag) return(1); ! 738: /* backward search */ ! 739: i = 0; ! 740: q = p; ! 741: while (i++ < MAXAOBDISP && ((q= q->back) !=&first)) ! 742: { ! 743: if (p->ref == q) ! 744: return(1); ! 745: } ! 746: ! 747: /* forward search */ ! 748: i = 0; ! 749: q = p; ! 750: while (i++ < MAXAOBDISP && ((q= q->forw) !=0)) ! 751: { ! 752: if (p->ref == q) ! 753: return(1); ! 754: } ! 755: return(0); ! 756: } ! 757: ! 758: ! 759: struct intleavetab intltab[] = { ! 760: ADDF, FLOAT, 1, ! 761: ADDF, DOUBLE, 1, ! 762: SUBF, FLOAT, 1, ! 763: SUBF, DOUBLE, 1, ! 764: MULF, FLOAT, 1, ! 765: MULF, DOUBLE, 1, ! 766: DIVF, FLOAT, 1, ! 767: DIVF, DOUBLE, 1, ! 768: SINF, FLOAT, 1, ! 769: COSF, FLOAT, 1, ! 770: ATANF, FLOAT, 1, ! 771: LOGF, FLOAT, 1, ! 772: SQRTF, FLOAT, 1, ! 773: EXPF, FLOAT, 1, ! 774: LDF, FLOAT, 0, ! 775: LDF, DOUBLE, 0, ! 776: LNF, FLOAT, 0, ! 777: LNF, DOUBLE, 0, ! 778: STF, FLOAT, 0, ! 779: CMPF, FLOAT, 0, ! 780: CMPF, DOUBLE, 0, ! 781: CMPF2, FLOAT, 0, ! 782: TSTF, FLOAT, 0, ! 783: TSTF, DOUBLE, 0, ! 784: PUSHD, DOUBLE, 0, ! 785: CVLF, U(LONG,FLOAT), 0, ! 786: CVFL, U(FLOAT,LONG), 0, ! 787: LDFD, U(FLOAT,DOUBLE),0, ! 788: CVDF, U(DOUBLE,FLOAT),0, ! 789: NEGF, FLOAT, 0, ! 790: NIL, 0, 0}; ! 791: ! 792: interleave() ! 793: { ! 794: register struct node *p, *p1; ! 795: ! 796: register struct intleavetab *t; ! 797: register int r; ! 798: int count; ! 799: for (p= first.forw; p!=0; p = p->forw){ ! 800: count = 0; ! 801: for (t =intltab; t->op != NIL; t++){ ! 802: if (t->op == p->op && t->subop == p->subop){ ! 803: count = t->intleavect; ! 804: break; ! 805: } ! 806: } ! 807: if (count < 1) continue; ! 808: p1 = p->forw; ! 809: clearuse(); ! 810: clearreg(); ! 811: while ((p1 != 0) && (p1->op != CBR) && ! 812: (p1->subop == FLOAT || p1->subop == DOUBLE || ! 813: ((p1->subop&0xF0)==DOUBLE<<4) || ((p1->subop&0xF)==DOUBLE )|| ! 814: ((p1->subop&0xF0)==FLOAT<<4) || (p1->subop&0xF)==FLOAT)) ! 815: { ! 816: if (((r = isreg(p1->code)) >= 0)){ ! 817: uses[r] = p1; ! 818: if ((p1->subop == DOUBLE) || ((p->subop&0xF0)==DOUBLE<<4) || ! 819: ((p->subop&0xF)==DOUBLE)) ! 820: uses[r+1] = p1; ! 821: } ! 822: else checkreg(p1,p1->code); ! 823: p1 = p1->forw; ! 824: ! 825: } ! 826: if (p1 == 0) return; ! 827: if (!(sideeffect(p, p1))) ! 828: insertblk(p,p1); ! 829: } ! 830: ! 831: } ! 832: ! 833: ! 834: insertblk(p, p1) ! 835: struct node *p, *p1; ! 836: { ! 837: p1->back->forw = p1->forw; ! 838: p1->forw->back = p1->back; ! 839: p1->forw = p->forw; ! 840: p->forw->back = p1; ! 841: p->forw = p1; ! 842: p1->back = p; ! 843: } ! 844: ! 845: OpCode termop[] = { ! 846: JBR, CBR, JMP, LABEL, DLABEL, EROU, JSW, TST, CMP, BIT, ! 847: CALLF, CALLS, CASE, AOBLEQ, AOBLSS, CMPF, CMPF2, TSTF, MOVBLK, MFPR, ! 848: MTPR, PROBE, MOVO, TEXT, DATA, BSS, ALIGN, END, LGEN, SET, ! 849: LCOMM, COMM, NIL ! 850: }; ! 851: ! 852: sideeffect(p,p1) ! 853: struct node *p, *p1; ! 854: { ! 855: register struct node *q; ! 856: register int r; ! 857: register OpCode *t; ! 858: register char *cp; ! 859: int i; ! 860: ! 861: if (p1->op == NIL) return(1); /* special instructions */ ! 862: ! 863: for (t = termop; *t!=NIL; t++){ ! 864: if (*t == p1->op) return(1); ! 865: } ! 866: if ((p1->forw != NULL) && (p1->forw->op == CBR)) ! 867: return(1); ! 868: splitrand(p1); ! 869: r = isreg(lastrand); ! 870: if (uses[r] && r >= 0 ) return(1); ! 871: if ((p1->op == EDIV) && (r = isreg(regs[RT3]) >= 0) && ! 872: (uses[r])) return(1); ! 873: ! 874: for (q = p1->back ; q!=p; q=q->back) ! 875: { ! 876: if ((p1->op == PUSH || p1->op == PUSHA) && ! 877: (q->op == PUSHD || q->op == PUSH || q->op == PUSHA)) ! 878: return(1); /* keep args in order */ ! 879: if (((i = strlen(q->code)) >= 5 && /* cvdl -(sp); pushl r0*/ ! 880: (strcmp(q->code+i-5,"-(sp)") == 0 )) || ! 881: (strcmp(lastrand,"-(sp)") == 0)) return(1); ! 882: if (equstr(q->code, lastrand)) ! 883: return(1); ! 884: if (q->op == STF || q->op == CVFL || q->op == CVLF) ! 885: { ! 886: if (equstr(q->code, regs[RT1])) return(1); ! 887: if (has3ops(p1) || p1->op == EMUL || p1->op == EDIV) ! 888: if (equstr(q->code, regs[RT2])) ! 889: return(1); ! 890: /* handle the case std -56(fp) pushl -60(fp) pushl ! 891: -56(fp); ! 892: */ ! 893: if ((p1->forw != NULL) && (q->op == STF) && ! 894: (q->subop == DOUBLE)){ ! 895: if (!strncmp(q->code,p1->forw->code,strlen(q->code))) ! 896: return(1); ! 897: } ! 898: } ! 899: } ! 900: return(0); ! 901: } ! 902: checkreg(p,s) ! 903: struct node *p; ! 904: char *s; ! 905: { ! 906: char *cp2; ! 907: register int r; ! 908: /* check for (r),[r] */ ! 909: do if (*s=='(' || *s=='[') {/* get register number */ ! 910: char t; ! 911: cp2= ++s; while (*++s!=')' && *s!=']'); t= *s; *s=0; ! 912: if ((r=isreg(cp2)) >= 0) { ! 913: uses[r]=p; ! 914: } ! 915: *s=t; ! 916: } while (*++s); ! 917: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.