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