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