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