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