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