![[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] / 43BSDReno / libexec / pcc / c2.tahoe|
Return to c22.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / pcc / c2.tahoe |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)c22.c 1.9 (Berkeley/CCI) 5/12/88"; ! 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, p->op!=CVT || r<0); ! 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 && p1->subop == 0 && p1->pop != p2->pop) ! 335: return(0); ! 336: if (p1->op != NIL && ord(p1->op) < ord(MOV)) ! 337: return(0); ! 338: switch (p1->op) { ! 339: case EROU: case JSW: case TEXT: case DATA: ! 340: case BSS: case ALIGN: case WGEN: case END: ! 341: /* sufficient? */ ! 342: return(0); ! 343: } ! 344: if (p1->op==MOVA && p1->labno!=p2->labno) return(0); ! 345: cp1 = p1->code; ! 346: cp2 = p2->code; ! 347: if (cp1==0 && cp2==0) ! 348: return(1); ! 349: if (cp1==0 || cp2==0) ! 350: return(0); ! 351: while (*cp1 == *cp2++) ! 352: if (*cp1++ == 0) ! 353: return(1); ! 354: return(0); ! 355: } ! 356: ! 357: delnode(p) register struct node *p; { ! 358: p->back->forw = p->forw; ! 359: p->forw->back = p->back; ! 360: } ! 361: ! 362: decref(p) ! 363: register struct node *p; ! 364: { ! 365: if (p && --p->refc <= 0) { ! 366: nrlab++; nchange++; ! 367: delnode(p); ! 368: } ! 369: } ! 370: ! 371: struct node * ! 372: nonlab(ap) ! 373: struct node *ap; ! 374: { ! 375: register struct node *p; ! 376: ! 377: p = ap; ! 378: while (p && p->op==LABEL) ! 379: p = p->forw; ! 380: return(p); ! 381: } ! 382: ! 383: clearuse() { ! 384: register struct node **i; ! 385: for (i=uses+NREG; i>uses;) *--i=0; ! 386: useacc = 0; ! 387: } ! 388: ! 389: clearreg() { ! 390: register char **i; ! 391: for (i=regs+NREG+1; i>regs;){ **--i=0; **i=0; } ! 392: conloc[0] = 0; ccloc[0] = 0; ! 393: } ! 394: ! 395: savereg(ai, s, type) ! 396: register char *s; ! 397: { ! 398: register char *p, *sp; ! 399: ! 400: sp = p = regs[ai]; ! 401: /* if any indexing, must be parameter or local */ ! 402: /* indirection (as in "*-4(fp)") is ok, however */ ! 403: *p++ = type; ! 404: if (*s=='*' || *s=='$') ! 405: *p++ = *s++; ! 406: if (natural(s)) ! 407: strcpy(p, s); ! 408: else {*sp = 0; return;} ! 409: } ! 410: ! 411: dest(s,type, ccflg) ! 412: register char *s; ! 413: { ! 414: register int i; ! 415: ! 416: if ((i = isreg(s)) >= 0) { ! 417: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */ ! 418: if (DOUBLE==(type&0xF) || DOUBLE==((type>>4)&0xF) || type==QUAD) ! 419: *(short *)(regs[i+1]) = 0; ! 420: } ! 421: for (i=NREG; --i>=0;) ! 422: if (regs[i][1]=='*' && equstr(s, regs[i]+2)) ! 423: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */ ! 424: while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */ ! 425: *(short *)(regs[i]) = 0; ! 426: ! 427: if (!natural(s)) {/* wild store, everything except constants vanishes */ ! 428: for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0; ! 429: conloc[0] = 0; ccloc[0] = 0; ! 430: } else { ! 431: if(ccflg)setcc(s,type); /* natural destinations set condition codes */ ! 432: if (equstr(s, conloc)) ! 433: conloc[0] = 0; ! 434: } ! 435: } ! 436: ! 437: splitrand(p) struct node *p; { ! 438: /* separate operands at commas, set up 'regs' and 'lastrand' */ ! 439: register char *p1, *p2; register char **preg; ! 440: ! 441: preg=regs+RT1; ! 442: if (p1=p->code) while (*p1) { ! 443: lastrand=p2= *preg++; ! 444: while (*p1) if (','==(*p2++= *p1++)) {--p2; break;} ! 445: *p2=0; ! 446: } ! 447: while (preg<(regs+RT1+5)) *(*preg++)=0; ! 448: } ! 449: ! 450: compat(have, want) ! 451: register int have, want; ! 452: { ! 453: register int hsrc, hdst; ! 454: extern int bitsize[]; ! 455: ! 456: if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */ ! 457: hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc; ! 458: if (want>=QUAD) ! 459: return(bitsize[hdst]==bitsize[want] && bitsize[hsrc]==bitsize[want]); ! 460: return(hsrc==want && hdst>=want && hdst<QUAD); ! 461: } ! 462: ! 463: equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));} ! 464: ! 465: findrand(as, type) ! 466: char *as; ! 467: { ! 468: register char **i; ! 469: for (i = regs+NREG; --i>=regs;) { ! 470: if (**i && equstr(*i+1, as) && compat(**i,type)) ! 471: return(i-regs); ! 472: } ! 473: return(-1); ! 474: } ! 475: ! 476: isreg(s) ! 477: register char *s; ! 478: { ! 479: if (*s++!='r' || !isdigit(*s++)) return(-1); ! 480: if (*s==0) return(*--s-'0'); ! 481: if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0'); ! 482: return(-1); ! 483: } ! 484: ! 485: /* ! 486: check() ! 487: { ! 488: register struct node *p, *lp; ! 489: ! 490: lp = &first; ! 491: for (p=first.forw; p!=0; p = p->forw) { ! 492: if (p->back != lp) ! 493: abort(-1); ! 494: lp = p; ! 495: } ! 496: } ! 497: */ ! 498: ! 499: newcode(p) struct node *p; { ! 500: register char *p1,*p2,**preg; ! 501: ! 502: preg=regs+RT1; p2=line; ! 503: while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';} ! 504: *--p2=0; ! 505: p->code=copy(line); ! 506: } ! 507: ! 508: repladdr(p) ! 509: struct node *p; ! 510: { ! 511: register int r; ! 512: register char *p1; ! 513: register char **preg; ! 514: register int nrepl; ! 515: ! 516: preg=regs+RT1; nrepl=0; ! 517: while (lastrand!=(p1= *preg++)) ! 518: if (0<=(r=findrand(p1,p->subop))) { ! 519: *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0; ! 520: nchange++; nrepl++; nsaddr++; ! 521: } ! 522: if (nrepl) newcode(p); ! 523: } ! 524: ! 525: /* conditional branches which are never/always taken */ ! 526: reduncbr(p) ! 527: register struct node *p; ! 528: { ! 529: register struct node *p1; ! 530: register char *ap1, *ap2; ! 531: ! 532: p1 = p->back; ! 533: if (p1->op==CMP) { ! 534: splitrand(p1); ! 535: ap1 = findcon(regs[RT1], p1->subop); ! 536: ap2 = findcon(regs[RT2], p1->subop); ! 537: } else { ! 538: if(!ccloc[0]) ! 539: return; ! 540: ap1 = findcon(ccloc+1, ccloc[0]); ! 541: ap2 = "$0"; ! 542: } ! 543: switch (compare(p->subop, ap1, ap2)) { ! 544: case 0: /* branch never taken */ ! 545: delnode(p); ! 546: nredunj++; ! 547: nchange++; ! 548: decref(p->ref); ! 549: if(p->forw->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 550: delnode(p1); ! 551: nrtst++; ! 552: } ! 553: break; ! 554: case 1: /* branch always taken */ ! 555: p->op = JBR; ! 556: p->subop = 0; ! 557: p->pop = 0; ! 558: nchange++; ! 559: if(nonlab(p->ref)->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 560: delnode(p1); ! 561: nrtst++; ! 562: } ! 563: } ! 564: } ! 565: ! 566: /* a jump to a redundant compare (start of a 'for') */ ! 567: redunbr(p) ! 568: register struct node *p; ! 569: { ! 570: register struct node *p1; ! 571: register char *ap1, *ap2; ! 572: ! 573: if ((p1 = p->ref) == 0) ! 574: return; ! 575: p1 = nonlab(p1); ! 576: if (p1->op==TST || p1->op==CMP) ! 577: splitrand(p1); ! 578: else ! 579: return; ! 580: if (p1->forw->op==CBR) { ! 581: ap1 = findcon(regs[RT1], p1->subop); ! 582: if (p1->op==TST) ! 583: ap2 = "$0"; ! 584: else ! 585: ap2 = findcon(regs[RT2], p1->subop); ! 586: p1 = p1->forw; ! 587: if (compare(p1->subop, ap1, ap2) > 0) { ! 588: nredunj++; ! 589: nchange++; ! 590: decref(p->ref); ! 591: p->ref = p1->ref; ! 592: p->labno = p1->labno; ! 593: #ifdef COPYCODE ! 594: if (p->labno == 0) ! 595: p->code = p1->code; ! 596: if (p->ref) ! 597: #endif ! 598: p->ref->refc++; ! 599: } ! 600: } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) && ! 601: equtype(ccloc[0],p1->subop)) { ! 602: p1=insertl(p1->forw); decref(p->ref); p->ref=p1; ! 603: p->labno=p1->labno; ! 604: nrtst++; nchange++; ! 605: } ! 606: } ! 607: ! 608: char * ! 609: findcon(p, type) ! 610: register char *p; ! 611: { ! 612: register int r; ! 613: ! 614: if (*p=='$') ! 615: return(p); ! 616: if ((r = isreg(p)) >= 0 && compat(regs[r][0],type)) ! 617: return(regs[r]+1); ! 618: if (equstr(p, conloc) && equtype(conloc[0], type)) ! 619: return(conval+1); ! 620: return(p); ! 621: } ! 622: ! 623: /* compare constants: 0 - branch taken; 1 - not taken; -1 - don't know */ ! 624: compare(op, acp1, acp2) ! 625: char *acp1, *acp2; ! 626: { ! 627: register char *cp1, *cp2; ! 628: register int n1, n2, sign; ! 629: ! 630: cp1 = acp1; ! 631: cp2 = acp2; ! 632: if (*cp1++ != '$' || *cp2++ != '$') ! 633: return(-1); ! 634: n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;} ! 635: while (isdigit(*cp1)) {n1 *= 10; n1 += *cp1++ - '0';} ! 636: n1 *= sign; ! 637: n2 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;} ! 638: while (isdigit(*cp2)) {n2 *= 10; n2 += *cp2++ - '0';} ! 639: n2 *= sign; ! 640: if (*cp1=='+') ! 641: cp1++; ! 642: if (*cp2=='+') ! 643: cp2++; ! 644: do { ! 645: if (*cp1++ != *cp2) ! 646: return(-1); ! 647: } while (*cp2++); ! 648: switch(op) { ! 649: ! 650: case JEQ: ! 651: return(n1 == n2); ! 652: case JNE: ! 653: return(n1 != n2); ! 654: case JLE: ! 655: return(n1 <= n2); ! 656: case JGE: ! 657: return(n1 >= n2); ! 658: case JLT: ! 659: return(n1 < n2); ! 660: case JGT: ! 661: return(n1 > n2); ! 662: case JLO: ! 663: return((unsigned)n1 < (unsigned)n2); ! 664: case JHI: ! 665: return((unsigned)n1 > (unsigned)n2); ! 666: case JLOS: ! 667: return((unsigned)n1 <= (unsigned)n2); ! 668: case JHIS: ! 669: return((unsigned)n1 >= (unsigned)n2); ! 670: } ! 671: return(-1); ! 672: } ! 673: ! 674: setcon(cv, cl, type) ! 675: register char *cv, *cl; ! 676: { ! 677: register char *p; ! 678: ! 679: if (*cv != '$') ! 680: return; ! 681: if (!natural(cl)) ! 682: return; ! 683: p = conloc; ! 684: while (*p++ = *cl++); ! 685: p = conval; ! 686: *p++ = type; ! 687: while (*p++ = *cv++); ! 688: } ! 689: ! 690: setcc(ap,type) ! 691: char *ap; ! 692: { ! 693: register char *p, *p1; ! 694: ! 695: p = ap; ! 696: if (!natural(p)) { ! 697: ccloc[0] = 0; ! 698: return; ! 699: } ! 700: p1 = ccloc; ! 701: *p1++ = type; ! 702: while (*p1++ = *p++); ! 703: } ! 704: ! 705: indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */ ! 706: while (*p) if (*p++=='[') return(1); ! 707: return(0); ! 708: } ! 709: ! 710: natural(p) ! 711: register char *p; ! 712: {/* 1->simple local, parameter, global, or register; 0->otherwise */ ! 713: ! 714: if (*p=='*' || *p=='(' || *p=='$') ! 715: return(0); ! 716: while (*p++); ! 717: p--; ! 718: if (*--p==']' || *p==')' && ! 719: !(*(p-2)=='f' || fortflg && (*--p=='1' || *p=='2') && *--p=='1')) ! 720: return(0); ! 721: return(1); ! 722: } ! 723: ! 724: /* ! 725: ** Tell if an argument is most likely static. ! 726: */ ! 727: ! 728: isstatic(cp) ! 729: register char *cp; ! 730: { ! 731: if (*cp == '_' || *cp == 'L') ! 732: return (1); ! 733: return (0); ! 734: } ! 735: ! 736: ! 737: checkaobdisp(p) ! 738: register struct node *p; ! 739: { ! 740: register struct node *q; ! 741: register int i; ! 742: ! 743: ! 744: if (!aobflag) return(1); ! 745: /* backward search */ ! 746: i = 0; ! 747: q = p; ! 748: while (i++ < MAXAOBDISP && ((q= q->back) !=&first)) ! 749: { ! 750: if (p->ref == q) ! 751: return(1); ! 752: } ! 753: ! 754: /* forward search */ ! 755: i = 0; ! 756: q = p; ! 757: while (i++ < MAXAOBDISP && ((q= q->forw) !=0)) ! 758: { ! 759: if (p->ref == q) ! 760: return(1); ! 761: } ! 762: return(0); ! 763: } ! 764: ! 765: ! 766: struct intleavetab intltab[] = { ! 767: ADDF, FLOAT, 1, ! 768: ADDF, DOUBLE, 1, ! 769: SUBF, FLOAT, 1, ! 770: SUBF, DOUBLE, 1, ! 771: MULF, FLOAT, 1, ! 772: MULF, DOUBLE, 1, ! 773: DIVF, FLOAT, 1, ! 774: DIVF, DOUBLE, 1, ! 775: SINF, FLOAT, 1, ! 776: COSF, FLOAT, 1, ! 777: ATANF, FLOAT, 1, ! 778: LOGF, FLOAT, 1, ! 779: SQRTF, FLOAT, 1, ! 780: EXPF, FLOAT, 1, ! 781: LDF, FLOAT, 0, ! 782: LDF, DOUBLE, 0, ! 783: LNF, FLOAT, 0, ! 784: LNF, DOUBLE, 0, ! 785: STF, FLOAT, 0, ! 786: CMPF, FLOAT, 0, ! 787: CMPF, DOUBLE, 0, ! 788: CMPF2, FLOAT, 0, ! 789: TSTF, FLOAT, 0, ! 790: TSTF, DOUBLE, 0, ! 791: PUSHD, DOUBLE, 0, ! 792: CVLF, U(LONG,FLOAT), 0, ! 793: CVFL, U(FLOAT,LONG), 0, ! 794: LDFD, U(FLOAT,DOUBLE),0, ! 795: CVDF, U(DOUBLE,FLOAT),0, ! 796: NEGF, FLOAT, 0, ! 797: NIL, 0, 0}; ! 798: ! 799: interleave() ! 800: { ! 801: register struct node *p, *p1; ! 802: ! 803: register struct intleavetab *t; ! 804: register int r; ! 805: int count; ! 806: for (p= first.forw; p!=0; p = p->forw){ ! 807: count = 0; ! 808: for (t =intltab; t->op != NIL; t++){ ! 809: if (t->op == p->op && t->subop == p->subop){ ! 810: count = t->intleavect; ! 811: break; ! 812: } ! 813: } ! 814: if (count < 1) continue; ! 815: p1 = p->forw; ! 816: clearuse(); ! 817: clearreg(); ! 818: while ((p1 != 0) && (p1->op != CBR) && ! 819: (p1->subop == FLOAT || p1->subop == DOUBLE || ! 820: ((p1->subop&0xF0)==DOUBLE<<4) || ((p1->subop&0xF)==DOUBLE )|| ! 821: ((p1->subop&0xF0)==FLOAT<<4) || (p1->subop&0xF)==FLOAT)) ! 822: { ! 823: if (((r = isreg(p1->code)) >= 0)){ ! 824: uses[r] = p1; ! 825: if ((p1->subop == DOUBLE) || ((p->subop&0xF0)==DOUBLE<<4) || ! 826: ((p->subop&0xF)==DOUBLE)) ! 827: uses[r+1] = p1; ! 828: } ! 829: else checkreg(p1,p1->code); ! 830: p1 = p1->forw; ! 831: ! 832: } ! 833: if (p1 == 0) return; ! 834: if (!(sideeffect(p, p1))) ! 835: insertblk(p,p1); ! 836: } ! 837: ! 838: } ! 839: ! 840: ! 841: insertblk(p, p1) ! 842: struct node *p, *p1; ! 843: { ! 844: p1->back->forw = p1->forw; ! 845: p1->forw->back = p1->back; ! 846: p1->forw = p->forw; ! 847: p->forw->back = p1; ! 848: p->forw = p1; ! 849: p1->back = p; ! 850: } ! 851: ! 852: OpCode termop[] = { ! 853: JBR, CBR, JMP, LABEL, DLABEL, EROU, JSW, TST, CMP, BIT, ! 854: CALLF, CALLS, CASE, AOBLEQ, AOBLSS, CMPF, CMPF2, TSTF, MOVBLK, MFPR, ! 855: MTPR, PROBE, MOVO, TEXT, DATA, BSS, ALIGN, END, LGEN, SET, ! 856: LCOMM, COMM, NIL ! 857: }; ! 858: ! 859: sideeffect(p,p1) ! 860: struct node *p, *p1; ! 861: { ! 862: register struct node *q; ! 863: register int r; ! 864: register OpCode *t; ! 865: register char *cp; ! 866: int i; ! 867: ! 868: if (p1->op == NIL) return(1); /* special instructions */ ! 869: ! 870: for (t = termop; *t!=NIL; t++){ ! 871: if (*t == p1->op) return(1); ! 872: } ! 873: if ((p1->forw != NULL) && (p1->forw->op == CBR)) ! 874: return(1); ! 875: splitrand(p1); ! 876: r = isreg(lastrand); ! 877: if (uses[r] && r >= 0 ) return(1); ! 878: if ((p1->op == EDIV) && (r = isreg(regs[RT3]) >= 0) && ! 879: (uses[r])) return(1); ! 880: ! 881: for (q = p1->back ; q!=p; q=q->back) ! 882: { ! 883: if ((p1->op == PUSH || p1->op == PUSHA) && ! 884: (q->op == PUSHD || q->op == PUSH || q->op == PUSHA)) ! 885: return(1); /* keep args in order */ ! 886: if (((i = strlen(q->code)) >= 5 && /* cvdl -(sp); pushl r0*/ ! 887: (strcmp(q->code+i-5,"-(sp)") == 0 )) || ! 888: (strcmp(lastrand,"-(sp)") == 0)) return(1); ! 889: if (equstr(q->code, lastrand)) ! 890: return(1); ! 891: if (q->op == STF || q->op == CVFL || q->op == CVLF) ! 892: { ! 893: if (equstr(q->code, regs[RT1])) return(1); ! 894: if (has3ops(p1) || p1->op == EMUL || p1->op == EDIV) ! 895: if (equstr(q->code, regs[RT2])) ! 896: return(1); ! 897: /* handle the case std -56(fp) pushl -60(fp) pushl ! 898: -56(fp); ! 899: */ ! 900: if ((p1->forw != NULL) && (q->op == STF) && ! 901: (q->subop == DOUBLE)){ ! 902: if (!strncmp(q->code,p1->forw->code,strlen(q->code))) ! 903: return(1); ! 904: } ! 905: } ! 906: } ! 907: return(0); ! 908: } ! 909: checkreg(p,s) ! 910: struct node *p; ! 911: char *s; ! 912: { ! 913: char *cp2; ! 914: register int r; ! 915: /* check for (r),[r] */ ! 916: do if (*s=='(' || *s=='[') {/* get register number */ ! 917: char t; ! 918: cp2= ++s; while (*++s!=')' && *s!=']'); t= *s; *s=0; ! 919: if ((r=isreg(cp2)) >= 0) { ! 920: uses[r]=p; ! 921: } ! 922: *s=t; ! 923: } while (*++s); ! 924: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.