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