![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reader.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / mip|
Return to reader.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / mip |
1.1 root 1: # include "mfile2"
2:
3: /* some storage declarations */
4:
5: # ifndef ONEPASS
6: NODE node[TREESZ];
7: char filename[100] = ""; /* the name of the file */
8: int ftnno; /* number of current function */
9: int lineno;
10: # else
11: # define NOMAIN
12: #endif
13:
14: int nrecur;
15: int lflag;
16: extern int Wflag;
17: int edebug = 0;
18: int xdebug = 0;
19: int udebug = 0;
20:
21: OFFSZ tmpoff; /* offset for first temporary, in bits for current block */
22: OFFSZ maxoff; /* maximum temporary offset over all blocks in current ftn, in bits */
23: int maxtreg;
24:
25: NODE *stotree;
26: int stocook;
27:
28: OFFSZ baseoff = 0;
29: OFFSZ maxtemp = 0;
30:
31: p2init( argc, argv ) char *argv[];{
32: /* set the values of the pass 2 arguments */
33:
34: register int c;
35: register char *cp;
36: register files;
37:
38: allo0(); /* free all regs */
39: files = 0;
40:
41: for( c=1; c<argc; ++c ){
42: if( *(cp=argv[c]) == '-' ){
43: while( *++cp ){
44: switch( *cp ){
45:
46: case 'X': /* pass1 flags */
47: while( *++cp ) { /* VOID */ }
48: --cp;
49: break;
50:
51: case 'l': /* linenos */
52: ++lflag;
53: break;
54:
55: case 'W': /*Shut up warning: etc. */
56: ++Wflag;
57: break;
58:
59: case 'e': /* expressions */
60: ++edebug;
61: break;
62:
63: case 'o': /* orders */
64: ++odebug;
65: break;
66:
67: case 'r': /* register allocation */
68: ++rdebug;
69: break;
70:
71: case 'a': /* rallo */
72: ++radebug;
73: break;
74:
75: case 't': /* ttype calls */
76: ++tdebug;
77: break;
78:
79: case 's': /* shapes */
80: ++sdebug;
81: break;
82:
83: case 'u': /* Sethi-Ullman testing (machine dependent) */
84: ++udebug;
85: break;
86:
87: case 'x': /* general machine-dependent debugging flag */
88: ++xdebug;
89: break;
90:
91: default:
92: cerror( "bad option: %c", *cp );
93: }
94: }
95: }
96: else files = 1; /* assumed to be a filename */
97: }
98:
99: mkdope();
100: setrew();
101: return( files );
102:
103: }
104:
105: # ifndef NOMAIN
106:
107: mainp2( argc, argv ) char *argv[]; {
108: register files;
109: register temp;
110: register c;
111: register char *cp;
112: register NODE *p;
113:
114: files = p2init( argc, argv );
115: tinit();
116:
117: reread:
118:
119: if( files ){
120: while( files < argc && argv[files][0] == '-' ) {
121: ++files;
122: }
123: if( files > argc ) return( nerrors );
124: freopen( argv[files], "r", stdin );
125: }
126: while( (c=getchar()) > 0 ) switch( c ){
127: case ')':
128: /* copy line unchanged */
129: while( (c=getchar()) > 0 ){
130: PUTCHAR(c);
131: if( c == '\n' ) break;
132: }
133: continue;
134:
135: case '[':
136: /* beginning of a block */
137: temp = rdin(10); /* ftnno */
138: tmpoff = baseoff = rdin(10); /* autooff for block gives max offset of autos in block */
139: maxtreg = rdin(10);
140: if( getchar() != '\n' ) cerror( "intermediate file format error");
141:
142: if( temp != ftnno ){ /* beginning of function */
143: maxoff = baseoff;
144: ftnno = temp;
145: maxtemp = 0;
146: }
147: else {
148: if( baseoff > maxoff ) maxoff = baseoff;
149: /* maxoff at end of ftn is max of autos and temps
150: over all blocks in the function */
151: }
152: setregs();
153: continue;
154:
155: case ']': /* end of block */
156: SETOFF( maxoff, ALSTACK );
157: eobl2();
158: while( (c=getchar()) != '\n' ){
159: if( c <= 0 ) cerror( "intermediate file format eof" );
160: }
161: continue;
162:
163: case '.':
164: /* compile code for an expression */
165: lineno = rdin( 10 );
166: for( cp=filename; (*cp=getchar()) != '\n'; ++cp ) ; /* VOID, reads filename */
167: *cp = '\0';
168: if( lflag ) lineid( lineno, filename );
169:
170: tmpoff = baseoff; /* expression at top level reuses temps */
171: p = eread();
172:
173: if( edebug ) fwalk( p, eprint, 0 );
174:
175: # ifdef MYREADER
176: MYREADER(p); /* do your own laundering of the input */
177: # endif
178:
179: nrecur = 0;
180: delay( p ); /* expression statement throws out results */
181: reclaim( p, RNULL, 0 );
182:
183: allchk();
184: tcheck();
185: continue;
186:
187: default:
188: cerror( "intermediate file format error" );
189:
190: }
191:
192: /* EOF */
193: if( files ) goto reread;
194: return(nerrors);
195:
196: }
197:
198: # endif
199:
200: # ifdef ONEPASS
201:
202: p2compile( p ) NODE *p; {
203:
204: if( lflag ) lineid( lineno, filename );
205: tmpoff = baseoff; /* expression at top level reuses temps */
206: /* generate code for the tree p */
207: if( edebug ) fwalk( p, eprint, 0 );
208:
209: # ifdef MYREADER
210: MYREADER(p); /* do your own laundering of the input */
211: # endif
212: nrecur = 0;
213: delay( p ); /* do the code generation */
214: reclaim( p, RNULL, 0 );
215: allchk();
216: /* can't do tcheck here; some stuff (e.g., attributes) may be around from first pass */
217: /* first pass will do it... */
218: }
219:
220: p2bbeg( aoff, myreg ) {
221: static int myftn = -1;
222: tmpoff = baseoff = aoff;
223: maxtreg = myreg;
224: if( myftn != ftnno ){ /* beginning of function */
225: maxoff = baseoff;
226: myftn = ftnno;
227: maxtemp = 0;
228: }
229: else {
230: if( baseoff > maxoff ) maxoff = baseoff;
231: /* maxoff at end of ftn is max of autos and temps over all blocks */
232: }
233: setregs();
234: }
235:
236: p2bend(){
237: SETOFF( maxoff, ALSTACK );
238: eobl2();
239: }
240:
241: # endif
242:
243: NODE *deltrees[DELAYS];
244: int deli;
245:
246: delay( p ) register NODE *p; {
247: /* look in all legal places for COMOP's and ++ and -- ops to delay */
248: /* note; don't delay ++ and -- within calls or things like
249: /* getchar (in their macro forms) will start behaving strangely */
250: register i;
251:
252: /* look for visible COMOPS, and rewrite repeatedly */
253:
254: while( delay1( p ) ) { /* VOID */ }
255:
256: /* look for visible, delayable ++ and -- */
257:
258: deli = 0;
259: delay2( p );
260: codgen( p, FOREFF ); /* do what is left */
261: for( i = 0; i<deli; ++i ) codgen( deltrees[i], FOREFF ); /* do the rest */
262: }
263:
264: delay1( p ) register NODE *p; { /* look for COMOPS */
265: register o, ty;
266:
267: o = p->op;
268: ty = optype( o );
269: if( ty == LTYPE ) return( 0 );
270: else if( ty == UTYPE ) return( delay1( p->left ) );
271:
272: switch( o ){
273:
274: case QUEST:
275: case ANDAND:
276: case OROR:
277: /* don't look on RHS */
278: return( delay1(p->left ) );
279:
280: case COMOP: /* the meat of the routine */
281: delay( p->left ); /* completely evaluate the LHS */
282: /* rewrite the COMOP */
283: { register NODE *q;
284: q = p->right;
285: ncopy( p, p->right );
286: q->op = FREE;
287: }
288: return( 1 );
289: }
290:
291: return( delay1(p->left) || delay1(p->right ) );
292: }
293:
294: delay2( p ) register NODE *p; {
295:
296: /* look for delayable ++ and -- operators */
297:
298: register o, ty;
299: o = p->op;
300: ty = optype( o );
301:
302: switch( o ){
303:
304: case NOT:
305: case QUEST:
306: case ANDAND:
307: case OROR:
308: case CALL:
309: case UNARY CALL:
310: case STCALL:
311: case UNARY STCALL:
312: case FORTCALL:
313: case UNARY FORTCALL:
314: case COMOP:
315: case CBRANCH:
316: /* for the moment, don7t delay past a conditional context, or
317: /* inside of a call */
318: return;
319:
320: case UNARY MUL:
321: /* if *p++, do not rewrite */
322: if( autoincr( p ) ) return;
323: break;
324:
325: case INCR:
326: case DECR:
327: if( deltest( p ) ){
328: if( deli < DELAYS ){
329: register NODE *q;
330: deltrees[deli++] = tcopy(p);
331: q = p->left;
332: p->right->op = FREE; /* zap constant */
333: ncopy( p, q );
334: q->op = FREE;
335: return;
336: }
337: }
338:
339: }
340:
341: if( ty == BITYPE ) delay2( p->right );
342: if( ty != LTYPE ) delay2( p->left );
343: }
344:
345: codgen( p, cookie ) NODE *p; {
346:
347: /* generate the code for p;
348: order may call codgen recursively */
349: /* cookie is used to describe the context */
350:
351: for(;;){
352: canon(p); /* creats OREG from * if possible and does sucomp */
353: stotree = NIL;
354: if( edebug ){
355: printf( "store called on:\n" );
356: fwalk( p, eprint, 0 );
357: }
358: store(p);
359: if( stotree==NIL ) break;
360:
361: /* because it's minimal, can do w.o. stores */
362:
363: order( stotree, stocook );
364: }
365:
366: order( p, cookie );
367:
368: }
369:
370: char *cnames[] = {
371: "SANY",
372: "SAREG",
373: "STAREG",
374: "SBREG",
375: "STBREG",
376: "SCC",
377: "SNAME",
378: "SCON",
379: "SFLD",
380: "SOREG",
381: "STARNM",
382: "STARREG",
383: "INTEMP",
384: "FORARG",
385: "SWADD",
386: 0,
387: };
388:
389: prcook( cookie ){
390:
391: /* print a nice-looking description of cookie */
392:
393: int i, flag;
394:
395: if( cookie & SPECIAL ){
396: if( cookie == SZERO ) printf( "SZERO" );
397: else if( cookie == SONE ) printf( "SONE" );
398: else if( cookie == SMONE ) printf( "SMONE" );
399: else printf( "SPECIAL+%d", cookie & ~SPECIAL );
400: return;
401: }
402:
403: flag = 0;
404: for( i=0; cnames[i]; ++i ){
405: if( cookie & (1<<i) ){
406: if( flag ) printf( "|" );
407: ++flag;
408: printf( cnames[i] );
409: }
410: }
411:
412: }
413:
414: int odebug = 0;
415:
416: order(p,cook) NODE *p; {
417:
418: register o, ty, m;
419: int m1;
420: int cookie;
421: NODE *p1, *p2;
422:
423: /* by this time, p should be able to be generated without stores;
424: the only question is how */
425:
426: again:
427:
428: cookie = cook;
429: rcount();
430: canon(p);
431: rallo( p, p->rall );
432:
433: if( odebug ){
434: printf( "order( %o, ", p );
435: prcook( cookie );
436: printf( " )\n" );
437: fwalk( p, eprint, 0 );
438: }
439:
440: o = p->op;
441: ty = optype(o);
442:
443: /* first of all, for most ops, see if it is in the table */
444:
445: /* look for ops */
446:
447: switch( m = p->op ){
448:
449: default:
450: /* look for op in table */
451: for(;;){
452: if( (m = match( p, cookie ) ) == MDONE ) goto cleanup;
453: else if( m == MNOPE ){
454: if( !(cookie = nextcook( p, cookie ) ) ) goto nomat;
455: continue;
456: }
457: else break;
458: }
459: break;
460:
461: case COMOP:
462: case FORCE:
463: case CBRANCH:
464: case QUEST:
465: case ANDAND:
466: case OROR:
467: case NOT:
468: case UNARY CALL:
469: case CALL:
470: case UNARY STCALL:
471: case STCALL:
472: case UNARY FORTCALL:
473: case FORTCALL:
474: /* don't even go near the table... */
475: ;
476:
477: }
478: /* get here to do rewriting if no match or
479: fall through from above for hard ops */
480:
481: p1 = p->left;
482: if( ty == BITYPE ) p2 = p->right;
483: else p2 = NIL;
484:
485: if( odebug ){
486: printf( "order( %o, ", p );
487: prcook( cook );
488: printf( " ), cookie " );
489: prcook( cookie );
490: printf( ", rewrite %s\n", opst[m] );
491: }
492: switch( m ){
493: default:
494: nomat:
495: cerror( "no table entry for op %s", opst[p->op] );
496:
497: case COMOP:
498: codgen( p1, FOREFF );
499: p2->rall = p->rall;
500: codgen( p2, cookie );
501: ncopy( p, p2 );
502: p2->op = FREE;
503: goto cleanup;
504:
505: case FORCE:
506: /* recurse, letting the work be done by rallo */
507: p = p->left;
508: cook = INTAREG|INTBREG;
509: goto again;
510:
511: case CBRANCH:
512: o = p2->lval;
513: cbranch( p1, -1, o );
514: p2->op = FREE;
515: p->op = FREE;
516: return;
517:
518: case QUEST:
519: cbranch( p1, -1, m=getlab() );
520: p2->left->rall = p->rall;
521: codgen( p2->left, INTAREG|INTBREG );
522: /* force right to compute result into same reg used by left */
523: p2->right->rall = p2->left->rval|MUSTDO;
524: reclaim( p2->left, RNULL, 0 );
525: cbgen( 0, m1 = getlab(), 'I' );
526: deflab( m );
527: codgen( p2->right, INTAREG|INTBREG );
528: deflab( m1 );
529: p->op = REG; /* set up node describing result */
530: p->lval = 0;
531: p->rval = p2->right->rval;
532: p->type = p2->right->type;
533: tfree( p2->right );
534: p2->op = FREE;
535: goto cleanup;
536:
537: case ANDAND:
538: case OROR:
539: case NOT: /* logical operators */
540: /* if here, must be a logical operator for 0-1 value */
541: cbranch( p, -1, m=getlab() );
542: p->op = CCODES;
543: p->label = m;
544: order( p, INTAREG );
545: goto cleanup;
546:
547: case FLD: /* fields of funny type */
548: if ( p1->op == UNARY MUL ){
549: offstar( p1->left );
550: goto again;
551: }
552:
553: case UNARY MINUS:
554: order( p1, INBREG|INAREG );
555: goto again;
556:
557: case NAME:
558: /* all leaves end up here ... */
559: if( o == REG ) goto nomat;
560: order( p, INTAREG|INTBREG );
561: goto again;
562:
563: case INIT:
564: uerror( "illegal initialization" );
565: return;
566:
567: case UNARY FORTCALL:
568: p->right = NIL;
569: case FORTCALL:
570: o = p->op = UNARY FORTCALL;
571: if( genfcall( p, cookie ) ) goto nomat;
572: goto cleanup;
573:
574: case UNARY CALL:
575: p->right = NIL;
576: case CALL:
577: o = p->op = UNARY CALL;
578: if( gencall( p, cookie ) ) goto nomat;
579: goto cleanup;
580:
581: case UNARY STCALL:
582: p->right = NIL;
583: case STCALL:
584: o = p->op = UNARY STCALL;
585: if( genscall( p, cookie ) ) goto nomat;
586: goto cleanup;
587:
588: /* if arguments are passed in register, care must be taken that reclaim
589: /* not throw away the register which now has the result... */
590:
591: case UNARY MUL:
592: if( cook == FOREFF ){
593: /* do nothing */
594: order( p->left, FOREFF );
595: p->op = FREE;
596: return;
597: }
598: offstar( p->left );
599: canon(p);
600: if( canaddr(p) && cook != INTEMP ) goto cleanup;
601: goto again;
602:
603: case INCR: /* INCR and DECR */
604: if( setincr(p) ) goto again;
605:
606: /* x++ becomes (x += 1) -1; */
607:
608: if( cook & FOREFF ){ /* result not needed so inc or dec and be done with it */
609: /* x++ => x += 1 */
610: p->op = (p->op==INCR)?ASG PLUS:ASG MINUS;
611: goto again;
612: }
613:
614: p1 = tcopy(p);
615: reclaim( p->left, RNULL, 0 );
616: p->left = p1;
617: p1->op = (p->op==INCR)?ASG PLUS:ASG MINUS;
618: p->op = (p->op==INCR)?MINUS:PLUS;
619: goto again;
620:
621: case STASG:
622: if( setstr( p ) ) goto again;
623: goto nomat;
624:
625: case ASG PLUS: /* and other assignment ops */
626: if( setasop(p) ) goto again;
627:
628: /* there are assumed to be no side effects in LHS */
629:
630: p2 = tcopy(p);
631: p->op = ASSIGN;
632: reclaim( p->right, RNULL, 0 );
633: p->right = p2;
634: canon(p);
635: rallo( p, p->rall );
636:
637: if( odebug ) fwalk( p, eprint, 0 );
638:
639: order( p2->left, INTBREG|INTAREG );
640: order( p2, INTBREG|INTAREG );
641: goto again;
642:
643: case ASSIGN:
644: if( setasg( p ) ) goto again;
645: goto nomat;
646:
647:
648: case BITYPE:
649: if( setbin( p ) ) goto again;
650: /* try to replace binary ops by =ops */
651: switch(o){
652:
653: case PLUS:
654: case MINUS:
655: case MUL:
656: case DIV:
657: case MOD:
658: case AND:
659: case OR:
660: case ER:
661: case LS:
662: case RS:
663: p->op = ASG o;
664: goto again;
665: }
666: goto nomat;
667:
668: }
669:
670: cleanup:
671:
672: /* if it is not yet in the right state, put it there */
673:
674: if( cook & FOREFF ){
675: reclaim( p, RNULL, 0 );
676: return;
677: }
678:
679: if( p->op==FREE ) return;
680:
681: if( tshape( p, cook ) ) return;
682:
683: if( (m=match(p,cook) ) == MDONE ) return;
684:
685: /* we are in bad shape, try one last chance */
686: if( lastchance( p, cook ) ) goto again;
687:
688: goto nomat;
689: }
690:
691: int callflag;
692: int fregs;
693:
694: store( p ) register NODE *p; {
695:
696: /* find a subtree of p which should be stored */
697:
698: register o, ty;
699:
700: o = p->op;
701: ty = optype(o);
702:
703: if( ty == LTYPE ) return;
704:
705: switch( o ){
706:
707: case UNARY CALL:
708: case UNARY FORTCALL:
709: case UNARY STCALL:
710: ++callflag;
711: break;
712:
713: case UNARY MUL:
714: if( asgop(p->left->op) ) stoasg( p->left, UNARY MUL );
715: break;
716:
717: case CALL:
718: case FORTCALL:
719: case STCALL:
720: store( p->left );
721: stoarg( p->right, o );
722: ++callflag;
723: return;
724:
725: case COMOP:
726: markcall( p->right );
727: if( p->right->su > fregs ) SETSTO( p, INTEMP );
728: store( p->left );
729: return;
730:
731: case ANDAND:
732: case OROR:
733: case QUEST:
734: markcall( p->right );
735: if( p->right->su > fregs ) SETSTO( p, INTEMP );
736: case CBRANCH: /* to prevent complicated expressions on the LHS from being stored */
737: case NOT:
738: constore( p->left );
739: return;
740:
741: }
742:
743: if( ty == UTYPE ){
744: store( p->left );
745: return;
746: }
747:
748: if( asgop( p->right->op ) ) stoasg( p->right, o );
749:
750: if( p->su>fregs ){ /* must store */
751: mkadrs( p ); /* set up stotree and stocook to subtree
752: that must be stored */
753: }
754:
755: store( p->right );
756: store( p->left );
757: }
758:
759: constore( p ) register NODE *p; {
760:
761: /* store conditional expressions */
762: /* the point is, avoid storing expressions in conditional
763: conditional context, since the evaluation order is predetermined */
764:
765: switch( p->op ) {
766:
767: case ANDAND:
768: case OROR:
769: case QUEST:
770: markcall( p->right );
771: case NOT:
772: constore( p->left );
773: return;
774:
775: }
776:
777: store( p );
778: }
779:
780: markcall( p ) register NODE *p; { /* mark off calls below the current node */
781:
782: again:
783: switch( p->op ){
784:
785: case UNARY CALL:
786: case UNARY STCALL:
787: case UNARY FORTCALL:
788: case CALL:
789: case STCALL:
790: case FORTCALL:
791: ++callflag;
792: return;
793:
794: }
795:
796: switch( optype( p->op ) ){
797:
798: case BITYPE:
799: markcall( p->right );
800: case UTYPE:
801: p = p->left;
802: /* eliminate recursion (aren't I clever...) */
803: goto again;
804: case LTYPE:
805: return;
806: }
807:
808: }
809:
810: stoarg( p, calltype ) register NODE *p; {
811: /* arrange to store the args */
812:
813: if( p->op == CM ){
814: stoarg( p->left, calltype );
815: p = p->right ;
816: }
817: if( calltype == CALL ){
818: STOARG(p);
819: }
820: else if( calltype == STCALL ){
821: STOSTARG(p);
822: }
823: else {
824: STOFARG(p);
825: }
826: callflag = 0;
827: store(p);
828: # ifndef NESTCALLS
829: if( callflag ){ /* prevent two calls from being active at once */
830: SETSTO(p,INTEMP);
831: store(p); /* do again to preserve bottom up nature.... */
832: }
833: #endif
834: }
835:
836: int negrel[] = { NE, EQ, GT, GE, LT, LE, UGT, UGE, ULT, ULE } ; /* negatives of relationals */
837:
838: cbranch( p, true, false ) NODE *p; {
839: /* evaluate p for truth value, and branch to true or false
840: /* accordingly: label <0 means fall through */
841:
842: register o, lab, flab, tlab;
843:
844: lab = -1;
845:
846: switch( o=p->op ){
847:
848: case ULE:
849: case ULT:
850: case UGE:
851: case UGT:
852: case EQ:
853: case NE:
854: case LE:
855: case LT:
856: case GE:
857: case GT:
858: if( true < 0 ){
859: o = p->op = negrel[ o-EQ ];
860: true = false;
861: false = -1;
862: }
863: #ifndef NOOPT
864: if( p->right->op == ICON && p->right->lval == 0 && p->right->name[0] == '\0' ){
865: switch( o ){
866:
867: case UGT:
868: case ULE:
869: o = p->op = (o==UGT)?NE:EQ;
870: case EQ:
871: case NE:
872: case LE:
873: case LT:
874: case GE:
875: case GT:
876: if( logop(p->left->op) ){
877: /* strange situation: e.g., (a!=0) == 0 */
878: /* must prevent reference to p->left->lable, so get 0/1 */
879: /* we could optimize, but why bother */
880: codgen( p->left, INAREG|INBREG );
881: }
882: codgen( p->left, FORCC );
883: cbgen( o, true, 'I' );
884: break;
885:
886: case UGE:
887: cbgen( 0, true, 'I' ); /* unconditional branch */
888: case ULT:
889: ; /* do nothing for LT */
890: }
891: }
892: else
893: #endif
894: {
895: p->label = true;
896: codgen( p, FORCC );
897: }
898: if( false>=0 ) cbgen( 0, false, 'I' );
899: reclaim( p, RNULL, 0 );
900: return;
901:
902: case ANDAND:
903: lab = false<0 ? getlab() : false ;
904: cbranch( p->left, -1, lab );
905: cbranch( p->right, true, false );
906: if( false < 0 ) deflab( lab );
907: p->op = FREE;
908: return;
909:
910: case OROR:
911: lab = true<0 ? getlab() : true;
912: cbranch( p->left, lab, -1 );
913: cbranch( p->right, true, false );
914: if( true < 0 ) deflab( lab );
915: p->op = FREE;
916: return;
917:
918: case NOT:
919: cbranch( p->left, false, true );
920: p->op = FREE;
921: break;
922:
923: case COMOP:
924: codgen( p->left, FOREFF );
925: p->op = FREE;
926: cbranch( p->right, true, false );
927: return;
928:
929: case QUEST:
930: flab = false<0 ? getlab() : false;
931: tlab = true<0 ? getlab() : true;
932: cbranch( p->left, -1, lab = getlab() );
933: cbranch( p->right->left, tlab, flab );
934: deflab( lab );
935: cbranch( p->right->right, true, false );
936: if( true < 0 ) deflab( tlab);
937: if( false < 0 ) deflab( flab );
938: p->right->op = FREE;
939: p->op = FREE;
940: return;
941:
942: case ICON:
943: if( p->type != FLOAT && p->type != DOUBLE ){
944:
945: if( p->lval || p->name[0] ){
946: /* addresses of C objects are never 0 */
947: if( true>=0 ) cbgen( 0, true, 'I' );
948: }
949: else if( false>=0 ) cbgen( 0, false, 'I' );
950: p->op = FREE;
951: return;
952: }
953: /* fall through to default with other strange constants */
954:
955: default:
956: /* get condition codes */
957: codgen( p, FORCC );
958: if( true >= 0 ) cbgen( NE, true, 'I' );
959: if( false >= 0 ) cbgen( true >= 0 ? 0 : EQ, false, 'I' );
960: reclaim( p, RNULL, 0 );
961: return;
962:
963: }
964:
965: }
966:
967: rcount(){ /* count recursions */
968: if( ++nrecur > NRECUR ){
969: cerror( "expression causes compiler loop: try simplifying" );
970: }
971:
972: }
973:
974: eprint( p, down, a, b ) NODE *p; int *a, *b; {
975:
976: *a = *b = down+1;
977: while( down >= 2 ){
978: printf( "\t" );
979: down -= 2;
980: }
981: if( down-- ) printf( " " );
982:
983:
984: printf( "%o) %s", p, opst[p->op] );
985: switch( p->op ) { /* special cases */
986:
987: case REG:
988: printf( " %s", rnames[p->rval] );
989: break;
990:
991: case ICON:
992: case NAME:
993: case OREG:
994: printf( " " );
995: adrput( p );
996: break;
997:
998: case STCALL:
999: case UNARY STCALL:
1000: case STARG:
1001: case STASG:
1002: printf( " size=%d", p->stsize );
1003: printf( " align=%d", p->stalign );
1004: break;
1005: }
1006:
1007: printf( ", " );
1008: tprint( p->type );
1009: printf( ", " );
1010: if( p->rall == NOPREF ) printf( "NOPREF" );
1011: else {
1012: if( p->rall & MUSTDO ) printf( "MUSTDO " );
1013: else printf( "PREF " );
1014: printf( "%s", rnames[p->rall&~MUSTDO]);
1015: }
1016: printf( ", SU= %d\n", p->su );
1017:
1018: }
1019:
1020: # ifndef NOMAIN
1021: NODE *
1022: eread(){
1023:
1024: /* call eread recursively to get subtrees, if any */
1025:
1026: register NODE *p;
1027: register i, c;
1028: register char *pc;
1029: register j;
1030:
1031: i = rdin( 10 );
1032:
1033: p = talloc();
1034:
1035: p->op = i;
1036:
1037: i = optype(i);
1038:
1039: if( i == LTYPE ) p->lval = rdin( 10 );
1040: if( i != BITYPE ) p->rval = rdin( 10 );
1041:
1042: p->type = rdin(8 );
1043: p->rall = NOPREF; /* register allocation information */
1044:
1045: if( p->op == STASG || p->op == STARG || p->op == STCALL || p->op == UNARY STCALL ){
1046: p->stsize = (rdin( 10 ) + (SZCHAR-1) )/SZCHAR;
1047: p->stalign = rdin(10) / SZCHAR;
1048: if( getchar() != '\n' ) cerror( "illegal \n" );
1049: }
1050: else { /* usual case */
1051: if( p->op == REG ) rbusy( p->rval, p->type ); /* non usually, but sometimes justified */
1052: for( pc=p->name,j=0; ( c = getchar() ) != '\n'; ++j ){
1053: if( j < NCHNAM ) *pc++ = c;
1054: }
1055: if( j < NCHNAM ) *pc = '\0';
1056: }
1057:
1058: /* now, recursively read descendents, if any */
1059:
1060: if( i != LTYPE ) p->left = eread();
1061: if( i == BITYPE ) p->right = eread();
1062:
1063: return( p );
1064:
1065: }
1066:
1067: CONSZ
1068: rdin( base ){
1069: register sign, c;
1070: CONSZ val;
1071:
1072: sign = 1;
1073: val = 0;
1074:
1075: while( (c=getchar()) > 0 ) {
1076: if( c == '-' ){
1077: if( val != 0 ) cerror( "illegal -");
1078: sign = -sign;
1079: continue;
1080: }
1081: if( c == '\t' ) break;
1082: if( c>='0' && c<='9' ) {
1083: val *= base;
1084: if( sign > 0 )
1085: val += c-'0';
1086: else
1087: val -= c-'0';
1088: continue;
1089: }
1090: cerror( "illegal character `%c' on intermediate file", c );
1091: break;
1092: }
1093:
1094: if( c <= 0 ) {
1095: cerror( "unexpected EOF");
1096: }
1097: return( val );
1098: }
1099: # endif
1100:
1101: #ifndef FIELDOPS
1102: /* do this if there is no special hardware support for fields */
1103:
1104: ffld( p, down, down1, down2 ) NODE *p; int *down1, *down2; {
1105: /* look for fields that are not in an lvalue context, and rewrite them... */
1106: register NODE *shp;
1107: register s, o, v, ty;
1108:
1109: *down1 = asgop( p->op );
1110: *down2 = 0;
1111:
1112: if( !down && p->op == FLD ){ /* rewrite the node */
1113:
1114: if( !rewfld(p) ) return;
1115:
1116: ty = (szty(p->type) == 2)? LONG: INT;
1117: v = p->rval;
1118: s = UPKFSZ(v);
1119: # ifdef RTOLBYTES
1120: o = UPKFOFF(v); /* amount to shift */
1121: # else
1122: o = szty(p->type)*SZINT - s - UPKFOFF(v); /* amount to shift */
1123: #endif
1124:
1125: /* make & mask part */
1126:
1127: p->left->type = ty;
1128:
1129: p->op = AND;
1130: p->right = talloc();
1131: p->right->op = ICON;
1132: p->right->rall = NOPREF;
1133: p->right->type = ty;
1134: p->right->lval = 1;
1135: p->right->rval = 0;
1136: p->right->name[0] = '\0';
1137: p->right->lval <<= s;
1138: p->right->lval--;
1139:
1140: /* now, if a shift is needed, do it */
1141:
1142: if( o != 0 ){
1143: shp = talloc();
1144: shp->op = RS;
1145: shp->rall = NOPREF;
1146: shp->type = ty;
1147: shp->left = p->left;
1148: shp->right = talloc();
1149: shp->right->op = ICON;
1150: shp->right->rall = NOPREF;
1151: shp->right->type = ty;
1152: shp->right->rval = 0;
1153: shp->right->lval = o; /* amount to shift */
1154: shp->right->name[0] = '\0';
1155: p->left = shp;
1156: /* whew! */
1157: }
1158: }
1159: }
1160: #endif
1161:
1162: oreg2( p ) register NODE *p; {
1163:
1164: /* look for situations where we can turn * into OREG */
1165:
1166: NODE *q;
1167: register i;
1168: register r;
1169: register char *cp;
1170: register NODE *ql, *qr;
1171: CONSZ temp;
1172:
1173: if( p->op == UNARY MUL ){
1174: q = p->left;
1175: if( q->op == REG ){
1176: temp = q->lval;
1177: r = q->rval;
1178: cp = q->name;
1179: goto ormake;
1180: }
1181:
1182: if( q->op != PLUS && q->op != MINUS ) return;
1183: ql = q->left;
1184: qr = q->right;
1185:
1186: #ifdef R2REGS
1187:
1188: /* look for doubly indexed expressions */
1189:
1190: if( q->op == PLUS) {
1191: if( (r=base(ql))>=0 && (i=offset(qr, tlen(p)))>=0) {
1192: makeor2(p, ql, r, i);
1193: return;
1194: } else if( (r=base(qr))>=0 && (i=offset(ql, tlen(p)))>=0) {
1195: makeor2(p, qr, r, i);
1196: return;
1197: }
1198: }
1199:
1200:
1201: #endif
1202:
1203: if( (q->op==PLUS || q->op==MINUS) && qr->op == ICON &&
1204: ql->op==REG && szty(qr->type)==1) {
1205: temp = qr->lval;
1206: if( q->op == MINUS ) temp = -temp;
1207: r = ql->rval;
1208: temp += ql->lval;
1209: cp = qr->name;
1210: if( *cp && ( q->op == MINUS || *ql->name ) ) return;
1211: if( !*cp ) cp = ql->name;
1212:
1213: ormake:
1214: if( notoff( p->type, r, temp, cp ) ) return;
1215: p->op = OREG;
1216: p->rval = r;
1217: p->lval = temp;
1218: for( i=0; i<NCHNAM; ++i )
1219: p->name[i] = *cp++;
1220: tfree(q);
1221: return;
1222: }
1223: }
1224:
1225: }
1226:
1227: canon(p) NODE *p; {
1228: /* put p in canonical form */
1229: int oreg2(), sucomp();
1230:
1231: #ifndef FIELDOPS
1232: int ffld();
1233: fwalk( p, ffld, 0 ); /* look for field operators */
1234: # endif
1235: walkf( p, oreg2 ); /* look for and create OREG nodes */
1236: #ifdef MYCANON
1237: MYCANON(p); /* your own canonicalization routine(s) */
1238: #endif
1239: walkf( p, sucomp ); /* do the Sethi-Ullman computation */
1240:
1241: }
1242:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.