![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c20.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 c20.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / pcc / c2.tahoe |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)c20.c 1.5 (Berkeley/CCI) 6/6/87"; ! 3: #endif ! 4: ! 5: /* ! 6: * C object code improver ! 7: */ ! 8: ! 9: #include "c2.h" ! 10: #include <stdio.h> ! 11: #include <ctype.h> ! 12: ! 13: char _sibuf[BUFSIZ], _sobuf[BUFSIZ]; ! 14: int ioflag; ! 15: int isn = 2000000; ! 16: struct optab *oplook(); ! 17: struct optab *getline(); ! 18: long lgensym[10] = ! 19: {100000L,200000L,300000L,400000L,500000L,600000L,700000L,800000L,900000L,1000000L}; ! 20: ! 21: /* VARARGS1 */ ! 22: error(s1, s2) ! 23: char *s1, *s2; ! 24: { ! 25: fprintf(stderr, s1, s2); ! 26: exit(1); ! 27: } ! 28: ! 29: struct node * ! 30: alloc(an) ! 31: { ! 32: register int n; ! 33: register char *p; ! 34: ! 35: n = an; ! 36: n+=sizeof(char *)-1; ! 37: n &= ~(sizeof(char *)-1); ! 38: if (lasta+n >= lastr) { ! 39: if (sbrk(2000) == -1) ! 40: error("Optimizer: out of space\n"); ! 41: lastr += 2000; ! 42: } ! 43: p = lasta; ! 44: lasta += n; ! 45: return((struct node *)p); ! 46: } ! 47: ! 48: main(argc, argv) ! 49: char **argv; ! 50: { ! 51: register int niter, maxiter, isend; ! 52: int nflag,infound; ! 53: ! 54: nflag = 0; infound=0; argc--; argv++; ! 55: while (argc>0) {/* get flags */ ! 56: if (**argv=='-') { ! 57: switch ((*argv)[1]) { ! 58: case 'a': aobflag++; break; ! 59: case 'n': nflag++; break; ! 60: case 'd': debug++; break; ! 61: case 'f': fortflg++; break; ! 62: } ! 63: } else if (infound==0) { ! 64: if (freopen(*argv, "r", stdin) ==NULL) ! 65: error("C2: can't find %s\n", *argv); ! 66: ++infound; ! 67: } else if (freopen(*argv, "w", stdout) ==NULL) ! 68: error("C2: can't create %s\n", *argv); ! 69: argc--; argv++; ! 70: } ! 71: setbuf(stdin,_sibuf); ! 72: setbuf(stdout,_sobuf); ! 73: lasta = lastr = (char *)sbrk(2); ! 74: opsetup(); ! 75: lasta = firstr = lastr = (char *)alloc(0); ! 76: maxiter = 0; ! 77: do { ! 78: isend = input(); ! 79: niter = 0; ! 80: bmove(); ! 81: do { ! 82: refcount(); ! 83: do { ! 84: iterate(); ! 85: clearreg(); ! 86: niter++; ! 87: } while (nchange); ! 88: comjump(); ! 89: rmove(); ! 90: } while (nchange || jumpsw()); ! 91: addaob(); ! 92: interleave(); ! 93: output(); ! 94: if (niter > maxiter) ! 95: maxiter = niter; ! 96: lasta = firstr; ! 97: } while (isend); ! 98: if (nflag) { ! 99: score("iterations", maxiter); ! 100: score("jumps to jumps", nbrbr); ! 101: score("inst. after jumps", iaftbr); ! 102: score("jumps to .+1", njp1); ! 103: score("redundant labels", nrlab); ! 104: score("cross-jumps", nxjump); ! 105: score("code motions", ncmot); ! 106: score("branches reversed", nrevbr); ! 107: score("redundant moves", redunm); ! 108: score("simplified addresses", nsaddr); ! 109: score("loops inverted", loopiv); ! 110: score("redundant jumps", nredunj); ! 111: score("common seqs before jmp's", ncomj); ! 112: score("skips over jumps", nskip); ! 113: score("aob's added", naob); ! 114: score("redundant tst's", nrtst); ! 115: score("jump on bit", nbj); ! 116: score("redundant accumulator stores", nst); ! 117: score("redundant accumulator loads", nld); ! 118: score("K core", ((unsigned)lastr+01777) >> 10); ! 119: } ! 120: putc('\n',stdout); ! 121: fflush(stdout); exit(0); ! 122: } ! 123: ! 124: score(s, n) ! 125: char *s; ! 126: { ! 127: if(n > 0) ! 128: fprintf(stderr, "%d %s\n", n, s); ! 129: } ! 130: ! 131: input() ! 132: { ! 133: register struct node *p, *lastp; ! 134: register struct optab *op; register char *cp1; ! 135: static struct optab F77JSW = {".long", JSW, 1}; ! 136: ! 137: lastp = &first; ! 138: for (;;) { ! 139: top: ! 140: op = getline(); ! 141: if (debug && op==0) fprintf(stderr,"? %s\n",line); ! 142: switch (op->opcod) { ! 143: ! 144: case LABEL: ! 145: p = alloc(sizeof first); ! 146: if (isdigit(line[0]) && (p->labno=locdef(line)) || ! 147: (line[0] == 'L') && (p->labno=getnum(line+1))) { ! 148: p->op = LABEL; p->subop = 0; ! 149: if (p->labno<100000L && isn<=p->labno) isn=1+p->labno; ! 150: p->code = 0; ! 151: } else { ! 152: p->op = DLABEL; p->subop = 0; ! 153: p->labno = 0; ! 154: p->code = copy(line); ! 155: } ! 156: break; ! 157: ! 158: case LGEN: ! 159: if (*curlp!='L' && !locuse(curlp)) goto std; ! 160: op= &F77JSW; ! 161: case JBR: ! 162: if (op->opcod==JBR && (op->subopcod&0xF)==RET) goto std; ! 163: case CBR: ! 164: case JMP: ! 165: case JSW: ! 166: case AOBLEQ: case AOBLSS: ! 167: p = alloc(sizeof first); ! 168: p->op = op->opcod; p->subop = op->subopcod; ! 169: p->code=0; cp1=curlp; ! 170: if ((!isdigit(*cp1) || 0==(p->labno=locuse(cp1))) && ! 171: (*cp1!='L' || 0==(p->labno = getnum(cp1+1)))) {/* jbs, etc.? */ ! 172: while (*cp1++); while (*--cp1!=',' && cp1!=curlp); ! 173: if (cp1==curlp || ! 174: (!isdigit(*++cp1) || 0==(p->labno=locuse(cp1))) && ! 175: (*cp1!='L' || 0==(p->labno=getnum(cp1+1)))) ! 176: p->labno = 0; ! 177: else *--cp1=0; ! 178: p->code = copy(curlp); ! 179: } ! 180: if (isn<=p->labno) isn=1+p->labno; ! 181: break; ! 182: ! 183: case MOVA: ! 184: p=alloc(sizeof first); ! 185: p->op = op->opcod; p->subop = op->subopcod; ! 186: p->code=0; cp1=curlp+1; ! 187: if (cp1[-1]=='L' || isdigit(cp1[-1])) { ! 188: while (*cp1++!=','); *--cp1=0; ! 189: if (0!=(p->labno=locuse(curlp)) || ! 190: 0!=(p->labno=getnum(curlp+1))) p->code=copy(cp1+1); ! 191: else {*cp1=','; p->code=copy(curlp);} ! 192: } else {p->code=copy(--cp1); p->labno=0;} ! 193: break; ! 194: ! 195: case MOV: ! 196: p=alloc(sizeof first); ! 197: p->op = op->opcod; p->subop = op->subopcod; ! 198: p->code = copy(curlp); ! 199: p->labno = 0; ! 200: cp1=curlp+1; ! 201: if ((cp1[-1]=='$') && (cp1[0] == 'L')) { ! 202: while (*cp1++!=','); *--cp1 =0; ! 203: p->labno = getnum(curlp+2); ! 204: } ! 205: break; ! 206: case MOVBLK: /* used implicitly */ ! 207: curlp = "(r0),(r1),(r2)"; ! 208: goto std; ! 209: ! 210: case SET: ! 211: case COMM: ! 212: case LCOMM: ! 213: printf("%s\n",line); goto top; ! 214: ! 215: case BSS: ! 216: case DATA: ! 217: for (;;) { ! 218: printf("%s%c",line,(op->opcod==LABEL ? ':' : '\n')); ! 219: if (op->opcod==TEXT) goto top; ! 220: if (END==(op=getline())->opcod) {/* dangling .data is bad for you */ ! 221: printf(".text\n"); ! 222: break; ! 223: } ! 224: } ! 225: ! 226: std: ! 227: default: ! 228: p = alloc(sizeof first); ! 229: p->op = op->opcod; p->subop = op->subopcod; ! 230: p->labno = 0; ! 231: p->code = copy(curlp); ! 232: break; ! 233: ! 234: } ! 235: p->forw = 0; ! 236: p->back = lastp; ! 237: p->pop = op; ! 238: lastp->forw = p; ! 239: lastp = p; ! 240: p->ref = 0; ! 241: if (p->op==CASE) { ! 242: char *lp; int ncase; ! 243: lp=curlp; while (*lp++); while (*--lp!='$'); ncase=getnum(lp+1); ! 244: if (ALIGN!=(getline())->opcod || LABEL!=(getline())->opcod) caserr(); ! 245: do { ! 246: if (WGEN!=(getline())->opcod) caserr(); ! 247: p = alloc(sizeof first); ! 248: p->op = JSW; p->subop = 0; ! 249: p->code = 0; ! 250: lp=curlp; while(*lp++!='-'); *--lp=0; p->labno=getnum(curlp+1); ! 251: if (isn<=p->labno) isn=1+p->labno; ! 252: p->forw = 0; p->back = lastp; lastp->forw = p; lastp = p; ! 253: p->ref = 0; p->pop=0; ! 254: } while (--ncase>=0); ! 255: } ! 256: if (op->opcod==EROU) ! 257: return(1); ! 258: if (op->opcod==END) ! 259: return(0); ! 260: } ! 261: } ! 262: ! 263: caserr() ! 264: { ! 265: error("C2: improper casel instruction\n"); ! 266: } ! 267: ! 268: struct optab * ! 269: getline() ! 270: { ! 271: register char *lp; ! 272: register int c; ! 273: static struct optab OPLABEL={"",LABEL,0}; ! 274: static struct optab OPEND={"",END,0}; ! 275: ! 276: lp = line; ! 277: again: ! 278: while (EOF!=(c=getchar()) && isspace(c)); ! 279: if (c=='#') { ! 280: while((c=getchar()) != '\n'); ! 281: goto again; ! 282: } ! 283: while (EOF!=c) { ! 284: if (c==':') { ! 285: *lp++ = 0; ! 286: return(&OPLABEL); ! 287: } ! 288: if (c=='\n') { ! 289: *lp++ = 0; ! 290: return(oplook()); ! 291: } ! 292: if (c=='"') ! 293: do { ! 294: if (c=='\\') { ! 295: *lp++ = c; ! 296: c = getchar(); ! 297: } ! 298: *lp++ = c; ! 299: c = getchar(); ! 300: } while(c!='"'); ! 301: *lp++ = c; ! 302: c = getchar(); ! 303: } ! 304: *lp++ = 0; ! 305: return(&OPEND); ! 306: } ! 307: ! 308: long ! 309: getnum(p) ! 310: register char *p; ! 311: { ! 312: register int c, neg, n; ! 313: ! 314: n = 0; neg=0; if (*p=='-') {++neg; ++p;} ! 315: while (isdigit(c = *p++)) { ! 316: c -= '0'; n *= 10; if (neg) n -= c; else n += c; ! 317: } ! 318: if (*--p != 0) ! 319: return(0); ! 320: return(n); ! 321: } ! 322: ! 323: locuse(p) ! 324: register char *p; ! 325: { ! 326: ! 327: if (!isdigit(p[0]) || p[1] != 'f' && p[1] != 'b' || p[2]) return(0); ! 328: return (lgensym[p[0] - '0'] - (p[1] == 'b')); ! 329: } ! 330: ! 331: locdef(p) ! 332: register char *p; ! 333: { ! 334: ! 335: if (!isdigit(p[0]) || p[1]) return(0); ! 336: return (lgensym[p[0] - '0']++); ! 337: } ! 338: ! 339: output() ! 340: { ! 341: register struct node *t; ! 342: int casebas; ! 343: ! 344: t = &first; ! 345: while (t = t->forw) switch (t->op) { ! 346: ! 347: case END: ! 348: fflush(stdout); ! 349: return; ! 350: ! 351: case LABEL: ! 352: printf("L%d:", t->labno); ! 353: continue; ! 354: ! 355: case DLABEL: ! 356: printf("%s:", t->code); ! 357: continue; ! 358: ! 359: case CASE: ! 360: casebas=0; ! 361: ! 362: default: std: ! 363: if (t->pop==0) {/* must find it */ ! 364: register struct optab *p; ! 365: for (p=optab; p->opstring[0]; ++p) ! 366: if (p->opcod==t->op && p->subopcod==t->subop) { ! 367: t->pop=p; break;} ! 368: } ! 369: printf("%s", t->pop->opstring); ! 370: if (t->code) printf("\t%s", t->code); ! 371: if (t->op != MOV ) { ! 372: if (t->labno!=0) printf("%cL%d\n", ! 373: (t->code ? ',' : '\t'), ! 374: t->labno); ! 375: ! 376: else printf("\n"); ! 377: } ! 378: else printf("\n"); ! 379: continue; ! 380: ! 381: case MOVA: ! 382: if (t->labno==0) goto std; ! 383: printf("mova%c\tL%d,%s\n","bwlq"[t->subop-BYTE],t->labno,t->code); ! 384: continue; ! 385: ! 386: case MOVBLK: ! 387: t->code = 0; ! 388: goto std; ! 389: ! 390: case JSW: ! 391: if (t->subop!=0) {/* F77JSW */ ! 392: printf(".long\tL%d\n",t->labno); continue; ! 393: } ! 394: if (casebas==0) printf(".align 1\nL%d:\n",casebas=isn++); ! 395: printf(".word L%d-L%d\n", t->labno, casebas); ! 396: continue; ! 397: ! 398: } ! 399: } ! 400: ! 401: char * ! 402: copy(ap) ! 403: char *ap; ! 404: { ! 405: register char *p, *np, *onp; ! 406: register int n; ! 407: ! 408: p = ap; ! 409: n = 0; ! 410: if (*p==0) ! 411: return(0); ! 412: do ! 413: n++; ! 414: while (*p++); ! 415: onp = np = (char *)alloc(n); ! 416: p = ap; ! 417: while (*np++ = *p++); ! 418: return(onp); ! 419: } ! 420: ! 421: #define OPHS 560 ! 422: struct optab *ophash[OPHS]; ! 423: ! 424: opsetup() ! 425: { ! 426: register struct optab *optp, **ophp; ! 427: register int i,t; ! 428: ! 429: for(i=RT1+5;--i>=0;) regs[i]=(char *)alloc(C2_ASIZE); ! 430: for (optp = optab; optp->opstring[0]; optp++) { ! 431: t=7; i=0; while (--t>=0) i+= i+optp->opstring[t]; ! 432: ophp = &ophash[i % OPHS]; ! 433: while (*ophp++) { ! 434: /* fprintf(stderr,"\ncollision: %d %s %s", ! 435: /* ophp-1-ophash,optp->opstring,(*(ophp-1))->opstring); ! 436: */ ! 437: if (ophp > &ophash[OPHS]) ! 438: ophp = ophash; ! 439: } ! 440: *--ophp = optp; ! 441: } ! 442: } ! 443: ! 444: struct optab * ! 445: oplook() ! 446: { ! 447: register struct optab *optp,**ophp; ! 448: register char *p,*p2; ! 449: register int t; ! 450: char tempop[20]; ! 451: static struct optab OPNULL={"",NIL,0}; ! 452: ! 453: for (p=line, p2=tempop; *p && !isspace(*p); *p2++= *p++); *p2=0; p2=p; ! 454: while (isspace(*p2)) ++p2; curlp=p2; ! 455: t=0; while(--p>=line) t += t+*p; ophp = &ophash[t % OPHS]; ! 456: while (optp = *ophp) { ! 457: if (equstr(tempop,optp->opstring)) return(optp); ! 458: if ((++ophp) >= &ophash[OPHS]) ophp = ophash; ! 459: } ! 460: curlp = line; ! 461: return(&OPNULL); ! 462: } ! 463: ! 464: refcount() ! 465: { ! 466: register struct node *p, *lp, *np; ! 467: struct node *labhash[LABHS]; ! 468: register struct node **hp; ! 469: ! 470: for (hp = labhash; hp < &labhash[LABHS];) ! 471: *hp++ = 0; ! 472: for (p = first.forw; p!=0; p = p->forw) ! 473: if (p->op==LABEL) { ! 474: labhash[p->labno % LABHS] = p; ! 475: p->refc = 0; ! 476: } ! 477: for (p = first.forw; p!=0; p = p->forw) { ! 478: if (p->op==JBR && p->subop==0 || p->op==CBR || p->op==JSW || p->op==JMP ! 479: || p->op==AOBLEQ || p->op==AOBLSS ! 480: || (p->op==MOVA && p->labno!=0) ! 481: || (p->op==MOV && p->labno!=0)){ ! 482: p->ref = 0; ! 483: lp = labhash[p->labno % LABHS]; ! 484: if (lp==0 || p->labno!=lp->labno) ! 485: for (lp = first.forw; lp!=0; lp = lp->forw) { ! 486: if (lp->op==LABEL && p->labno==lp->labno) ! 487: break; ! 488: } ! 489: if (lp) { ! 490: np = nonlab(lp)->back; ! 491: if (np!=lp) { ! 492: p->labno = np->labno; ! 493: lp = np; ! 494: } ! 495: p->ref = lp; ! 496: lp->refc++; ! 497: } ! 498: } ! 499: } ! 500: for (p = first.forw; p!=0; p = p->forw) ! 501: if (p->op==LABEL && p->refc==0 ! 502: && (lp = nonlab(p))->op && lp->op!=JSW) ! 503: decref(p); ! 504: } ! 505: ! 506: iterate() ! 507: { ! 508: register struct node *p, *rp, *p1; ! 509: ! 510: nchange = 0; ! 511: for (p = first.forw; p!=0; p = p->forw) { ! 512: if ((p->op==JBR||p->op==CBR||p->op==JSW) && p->ref) { ! 513: rp = nonlab(p->ref); ! 514: if (rp->op==JBR && rp->labno && p->labno!=rp->labno) { ! 515: nbrbr++; ! 516: p->labno = rp->labno; ! 517: decref(p->ref); ! 518: rp->ref->refc++; ! 519: p->ref = rp->ref; ! 520: nchange++; ! 521: } ! 522: } ! 523: if (p->op==CBR && (p1 = p->forw)->op==JBR && p1->subop==0 ! 524: #ifdef COPYCODE ! 525: && p->ref ! 526: #endif ! 527: ) {/* RET problems */ ! 528: rp = p->ref; ! 529: do ! 530: rp = rp->back; ! 531: while (rp->op==LABEL); ! 532: if (rp==p1) { ! 533: decref(p->ref); ! 534: p->ref = p1->ref; ! 535: p->labno = p1->labno; ! 536: #ifdef COPYCODE ! 537: if (p->labno == 0) ! 538: p->code = p1->code; ! 539: #endif ! 540: p1->forw->back = p; ! 541: p->forw = p1->forw; ! 542: p->subop = revbr[p->subop]; ! 543: p->pop=0; ! 544: nchange++; ! 545: nskip++; ! 546: } ! 547: } ! 548: if (p->op==JBR || p->op==JMP) { ! 549: while ((p1=p->forw)!=0 && p1->op!=LABEL && p1->op!=DLABEL ! 550: && p1->op!=EROU && p1->op!=END ! 551: && p1->op!=ALIGN ! 552: && p1->op!=NIL && p1->op!=DATA) { ! 553: nchange++; ! 554: iaftbr++; ! 555: if (p1->ref) ! 556: decref(p1->ref); ! 557: p->forw = p1->forw; ! 558: p->forw->back = p; ! 559: } ! 560: rp = p->forw; ! 561: while (rp && rp->op==LABEL) { ! 562: if (p->ref == rp) { ! 563: p->back->forw = p->forw; ! 564: p->forw->back = p->back; ! 565: p = p->back; ! 566: decref(rp); ! 567: nchange++; ! 568: njp1++; ! 569: break; ! 570: } ! 571: rp = rp->forw; ! 572: } ! 573: xjump(p); ! 574: p = codemove(p); ! 575: } ! 576: } ! 577: } ! 578: ! 579: xjump(p1) ! 580: register struct node *p1; ! 581: { ! 582: register struct node *p2, *p3; ! 583: ! 584: if ((p2 = p1->ref)==0) ! 585: return; ! 586: for (;;) { ! 587: while ((p1 = p1->back) && p1->op==LABEL); ! 588: while ((p2 = p2->back) && p2->op==LABEL); ! 589: if (!equop(p1, p2) || p1==p2) ! 590: return; ! 591: p3 = insertl(p2); ! 592: p1->op = JBR; p1->subop = 0; ! 593: p1->pop=0; ! 594: p1->ref = p3; ! 595: p1->labno = p3->labno; ! 596: p1->code = 0; ! 597: nxjump++; ! 598: nchange++; ! 599: } ! 600: } ! 601: ! 602: struct node * ! 603: insertl(op) ! 604: register struct node *op; ! 605: { ! 606: register struct node *lp; ! 607: ! 608: if (op->op == LABEL) { ! 609: op->refc++; ! 610: return(op); ! 611: } ! 612: if (op->back->op == LABEL) { ! 613: op = op->back; ! 614: op->refc++; ! 615: return(op); ! 616: } ! 617: lp = alloc(sizeof first); ! 618: lp->op = LABEL; lp->subop = 0; ! 619: lp->labno = isn++; ! 620: lp->ref = 0; ! 621: lp->code = 0; ! 622: lp->refc = 1; ! 623: lp->back = op->back; ! 624: lp->forw = op; ! 625: op->back->forw = lp; ! 626: op->back = lp; ! 627: return(lp); ! 628: } ! 629: ! 630: struct node * ! 631: codemove(ap) ! 632: struct node *ap; ! 633: { ! 634: register struct node *p1, *p2, *p3; ! 635: register struct node *t, *tl; ! 636: register int n; ! 637: ! 638: p1 = ap; ! 639: if (p1->op!=JBR || (p2 = p1->ref)==0 || p2==p1->forw) ! 640: return(p1); ! 641: while (p2->op == LABEL) ! 642: if ((p2 = p2->back) == 0) ! 643: return(p1); ! 644: if (p2->op!=JBR && p2->op!=JMP) ! 645: goto ivloop; ! 646: p2 = p2->forw; ! 647: p3 = p1->ref; ! 648: while (p3) { ! 649: if (p3->op==JBR || p3->op==JMP) { ! 650: if (p1==p3) ! 651: return(p1); ! 652: ncmot++; ! 653: nchange++; ! 654: p1->back->forw = p2; ! 655: p1->forw->back = p3; ! 656: p2->back->forw = p3->forw; ! 657: p3->forw->back = p2->back; ! 658: p2->back = p1->back; ! 659: p3->forw = p1->forw; ! 660: decref(p1->ref); ! 661: return(p2); ! 662: } else ! 663: p3 = p3->forw; ! 664: } ! 665: return(p1); ! 666: ivloop: ! 667: if (p1->forw->op!=LABEL) ! 668: return(p1); ! 669: p3 = p2 = p2->forw; ! 670: n = 16; ! 671: do { ! 672: if ((p3 = p3->forw) == 0 || p3==p1 || --n==0) ! 673: return(p1); ! 674: } while (p3->op!=CBR || p3->labno!=p1->forw->labno); ! 675: do ! 676: if ((p1 = p1->back) == 0) ! 677: return(ap); ! 678: while (p1!=p3); ! 679: p1 = ap; ! 680: tl = insertl(p1); ! 681: p3->subop = revbr[p3->subop]; ! 682: p3->pop=0; ! 683: decref(p3->ref); ! 684: p2->back->forw = p1; ! 685: p3->forw->back = p1; ! 686: p1->back->forw = p2; ! 687: p1->forw->back = p3; ! 688: t = p1->back; ! 689: p1->back = p2->back; ! 690: p2->back = t; ! 691: t = p1->forw; ! 692: p1->forw = p3->forw; ! 693: p3->forw = t; ! 694: p2 = insertl(p1->forw); ! 695: p3->labno = p2->labno; ! 696: #ifdef COPYCODE ! 697: if (p3->labno == 0) ! 698: p3->code = p2->code; ! 699: #endif ! 700: p3->ref = p2; ! 701: decref(tl); ! 702: if (tl->refc<=0) ! 703: nrlab--; ! 704: loopiv++; ! 705: nchange++; ! 706: return(p3); ! 707: } ! 708: ! 709: comjump() ! 710: { ! 711: register struct node *p1, *p2, *p3; ! 712: ! 713: for (p1 = first.forw; p1!=0; p1 = p1->forw) ! 714: if (p1->op==JBR && ((p2 = p1->ref) && p2->refc > 1 ! 715: || (p1->subop&0xF)==RET)) ! 716: for (p3 = p1->forw; p3!=0; p3 = p3->forw) ! 717: if (p3->op==JBR && p3->ref == p2) ! 718: backjmp(p1, p3); ! 719: } ! 720: ! 721: backjmp(ap1, ap2) ! 722: struct node *ap1, *ap2; ! 723: { ! 724: register struct node *p1, *p2, *p3; ! 725: ! 726: p1 = ap1; ! 727: p2 = ap2; ! 728: for(;;) { ! 729: while ((p1 = p1->back) && p1->op==LABEL); ! 730: p2 = p2->back; ! 731: if (equop(p1, p2)) { ! 732: p3 = insertl(p1); ! 733: p2->back->forw = p2->forw; ! 734: p2->forw->back = p2->back; ! 735: p2 = p2->forw; ! 736: decref(p2->ref); ! 737: p2->op = JBR; p2->subop = 0; /* to handle RET */ ! 738: p2->pop=0; ! 739: p2->labno = p3->labno; ! 740: #ifdef COPYCODE ! 741: p2->code = 0; ! 742: #endif ! 743: p2->ref = p3; ! 744: nchange++; ! 745: ncomj++; ! 746: } else ! 747: return; ! 748: } ! 749: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.