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