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