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