![[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 / jerq / sgs / comp|
Return to reader.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 root 1: /* @(#) reader.c : 1.7 3/5/84 */
2:
3: # include "mfile2.h"
4:
5: /* some storage declarations */
6:
7: # ifdef TWOPASS
8: NODE node[TREESZ];
9: char ftitle[100] = "\"\""; /* the name of the file */
10: int ftnno; /* number of current function */
11: int lineno;
12: #endif
13:
14: int lflag;
15: int e2debug;
16: int udebug;
17: int fast;
18:
19: /* maxtemp is the maximum size (in bits) needed for temps so far */
20: /* maxarg is ditto for outgoing arguments */
21: /* maxboff is ditto for automatic variables */
22: /* earlier attempts to keep these on a per-block basis were silly */
23: int maxtemp;
24: extern int maxarg;
25: int maxboff;
26: NODE * condit();
27:
28: NODE *
29: force(p)
30: register NODE *p;
31: {
32: register NODE *q, *r;
33: if( !p ) cerror( "force" );
34: q = talloc();
35: *q = *p;
36: r = talloc();
37: *r = *p;
38: q->tn.op = ASSIGN;
39: q->in.right = p;
40: q->in.left = r;
41: r->tn.op = QNODE;
42: r->tn.rval = callreg(p); /* the reg where the value will be forced */
43: return( q );
44: }
45:
46: p2init( argc, argv )
47: char *argv[];
48: {
49: /* set the values of the pass 2 arguments */
50:
51: register int c;
52: register char *cp;
53: register files;
54:
55: allo0(); /* free all regs */
56: files = 0;
57:
58: for( c=1; c<argc; ++c )
59: {
60: if( *(cp=argv[c]) == '-' )
61: {
62: while( *++cp )
63: {
64: switch( *cp )
65: {
66:
67: case 'X': /* pass1 flags */
68: while( *++cp )
69: {
70: /* VOID */
71: }
72: --cp;
73: break;
74:
75: case 'l': /* linenos */
76: ++lflag;
77: break;
78:
79: case 'e': /* expressions */
80: ++e2debug;
81: break;
82:
83: case 'o': /* orders */
84: ++odebug;
85: break;
86:
87: case 'r': /* register allocation */
88: ++rdebug;
89: break;
90:
91: case 's': /* shapes */
92: ++sdebug;
93: break;
94:
95: case 'u': /* Sethi-Ullman testing
96: (machine dependent) */
97: ++udebug;
98: break;
99:
100: case 'f': /* try for faster compile speed */
101: ++fast;
102: break;
103:
104: default:
105: cerror( "bad option: %c", *cp );
106: }
107: }
108: }
109: else files = 1; /* assumed to be a ftitle */
110: }
111:
112: mkdope();
113: return( files );
114: }
115:
116: NODE *
117: dlabel( p, l )
118: register NODE *p;
119: {
120: /* define a label after p is executed */
121: register NODE *q;
122: if( !p ) cerror( "dlabel" );
123: q = talloc();
124: q->tn.type = p->tn.type;
125: q->in.left = p;
126: q->tn.op = GENLAB;
127: q->bn.label = l;
128: return( q );
129: }
130:
131:
132: NODE *
133: genbr( o, l, p )
134: register NODE *p;
135: register o,l;
136: {
137: /* after evaluating p, generate a branch to l */
138: /* if o is 0, unconditional */
139: register NODE *q;
140: if( !p ) cerror( "genbr" );
141: if( l < 0 ) cerror( "genbr1" );
142: q = talloc();
143: q->tn.op = o?GENBR:GENUBR;
144: q->tn.type = p->tn.type;
145: q->in.left = p;
146: q->bn.label = l;
147: q->bn.lop = o;
148: if( o && logop(p->tn.op) &&
149: (p->tn.op != ANDAND)
150: && (p->tn.op != OROR)
151: ) p->tn.op = CMP;
152: return( q );
153: }
154:
155:
156: static NODE *
157: oreff(p)
158: register NODE *p;
159: {
160: register NODE *r, *l;
161: NODE *condit(), *seq();
162: int lab, t, f;
163: /* oreff is called if an || op is evaluated with goal=CEFF
164: The rhs of || ops should be executed only if the
165: lhs is false. Since our goal is CEFF, we don't need
166: a result of the ||, but we need to
167: preserve that dependancy with this special case */
168:
169: /* We must catch this case before its children are
170: condit() and change the goal on it left child to CCC */
171:
172: if (tcond(p->in.left)) {
173: tfree(p->in.right);
174: p->in.op = FREE;
175: p = condit( p->in.left, CEFF, -1, -1);
176: } else if (fcond(p->in.left)) {
177: p->in.op = COMOP;
178: p = condit( p, CEFF, -1, -1);
179: } else {
180: lab = getlab();
181: l = condit( p->in.left, CCC, lab, -1);
182: r = condit( p->in.right, CEFF, -1, -1);
183: p->in.op = FREE;
184: p = seq(l, r); /* put r after l */
185: p = dlabel(p, lab);
186: }
187: return p;
188: }
189: static NODE *
190: andeff(p)
191: register NODE *p;
192: {
193: register NODE *r, *l;
194: NODE *condit();
195: int lab, t, f;
196: /* andeff is called if an && op is evaluated with goal=CEFF
197: The rhs of && ops should be executed only if the
198: lhs is true. Since our goal is CEFF, we don't need
199: a result of the &&, but we need to
200: preserve that dependancy with this special case */
201:
202: /* We must catch this case before its children are
203: condit() and change the goal on it left child to CCC */
204:
205: if (fcond(p->in.left)) {
206: tfree(p->in.right);
207: p->in.op = FREE;
208: p = condit( p->in.left, CEFF, -1, -1);
209: } else if (tcond(p->in.left)) {
210: p->in.op = COMOP;
211: p = condit( p, CEFF, -1, -1);
212: } else {
213: lab = getlab();
214: p->in.op = FREE;
215: l = condit( p->in.left, CCC, -1, lab);
216: r = condit( p->in.right, CEFF, -1, -1);
217: p = seq(l, r); /* put r after l */
218: p = dlabel(p, lab);
219: }
220: return p;
221: }
222: int negrel[] =
223: {
224: NE, EQ, GT, GE, LT, LE, UGT, UGE, ULT, ULE
225: } ; /* negatives of relationals */
226:
227: tcond( p )
228: register NODE *p;
229: {
230: /* return 1 if p is always true, 0 otherwise */
231: register o = p->tn.op;
232: register NODE *q;
233:
234: switch( o )
235: {
236:
237: case ICON:
238: return( p->tn.lval || p->tn.name != (char *) 0 );
239:
240: case COMOP:
241: return( tcond( p->in.right ) );
242:
243: case ANDAND:
244: return( tcond( p->in.left ) && tcond( p->in.right ) );
245:
246: case OROR:
247: return( tcond( p->in.left ) || tcond( p->in.right ) );
248:
249: case NOT:
250: return( fcond( p->in.left ) );
251:
252: case QUEST:
253: q = p->in.right;
254: if( tcond( p->in.left ) ) return( tcond( q->in.left ) );
255: if( fcond( p->in.left ) ) return( tcond( q->in.right ) );
256: return( tcond( q->in.left ) && tcond( q->in.right ) );
257:
258: default:
259: return( 0 );
260: }
261: }
262:
263: fcond( p )
264: register NODE *p;
265: {
266: /* return 1 if p is always false, 0 otherwise */
267: register o = p->tn.op;
268: register NODE *q;
269:
270: switch( o )
271: {
272:
273: case ICON:
274: return( !p->tn.lval && p->tn.name == (char *) 0 );
275:
276: case COMOP:
277: return( fcond( p->in.right ) );
278:
279: case ANDAND:
280: return( fcond( p->in.left ) || fcond( p->in.right ) );
281:
282: case OROR:
283: return( fcond( p->in.left ) && fcond( p->in.right ) );
284:
285: case NOT:
286: return( tcond( p->in.left ) );
287:
288: case QUEST:
289: q = p->in.right;
290: if( tcond( p->in.left ) ) return( fcond( q->in.left ) );
291: if( fcond( p->in.left ) ) return( fcond( q->in.right ) );
292: return( fcond( q->in.left ) && fcond( q->in.right ) );
293:
294: default:
295: return( 0 );
296: }
297: }
298:
299: NODE *
300: rcomma( p )
301: register NODE *p;
302: {
303: /* p is a COMOP; return the shrunken version thereof */
304:
305: if( p->tn.op != COMOP ) cerror( "rcomma" );
306:
307: if( p->in.left && p->in.right ) return( p );
308: p->tn.op = FREE;
309: if( !p->in.left ) return( p->in.right );
310: return( p->in.left );
311: }
312:
313: NODE *
314: seq( p1, p2 )
315: register NODE *p1, *p2;
316: {
317: /* execute p then q */
318: register NODE *q;
319:
320: q = talloc();
321: if (!p1) return p2;
322: if (!p2) return p1;
323: q->in.op = COMOP;
324: q->in.type = p2->in.right->in.type;
325: q->in.left = p1;
326: q->in.right = p2;
327: return q;
328: }
329:
330: NODE *
331: gtb( p, l )
332: register NODE *p;
333: register l;
334: {
335: register NODE *q;
336: /* replace p by a trivial branch to l */
337: /* if l is -1, return NULL */
338: q = condit( p, CEFF, -1, -1 );
339: if( l<0 ) return( q );
340: if( !q )
341: {
342: q = talloc();
343: q->tn.op = ICON;
344: q->tn.lval = 0;
345: q->tn.name = (char *) 0;
346: q->tn.type = TINT;
347: }
348: return( genbr( 0, l, q ) );
349: }
350:
351: NODE *
352: condit( p, goal, t, f )
353: register NODE *p;
354: register goal,t,f;
355: {
356: /* generate code for conditionals in terms of GENLAB and GENBR nodes */
357: /* goal is either CEFF, NRGS, or CCC */
358: /* also, delete stuff that never needs get done */
359: /* if goal==CEFF, return of null means nothing to be done */
360:
361: register o, lt, lf, l;
362: register NODE *q, *q1, *q2;
363:
364: o = p->tn.op;
365:
366: #ifndef NODBG
367: if( odebug >2 )
368: {
369: printf( "condit( %d (%s), %s, %d, %d )\n", (int)(p-node),
370: opst[o], goal==CCC?"CCC":(goal==NRGS?"NRGS":"CEFF"),
371: t, f );
372: }
373: #endif
374: if( o == CBRANCH )
375: {
376: p->in.right->tn.op = p->tn.op = FREE;
377: l = p->in.right->tn.lval;
378: p = p->in.left;
379: if( fcond( p ) ) return( gtb(p,l) );
380: if( tcond( p ) ) return( gtb(p,-1) );
381: return( condit( p, CCC, -1, l ) );
382: }
383:
384: /* a convenient place to diddle a few special ops */
385: if( callop(o) )
386: {
387: if( optype(o) == UTYPE ) p->stn.argsize = 0;
388: else p->stn.argsize = argsize(p->in.right);
389: if( goal==CEFF ) goal = NRGS;
390: /* flow on, so that we can handle if( f(...) )... */
391: }
392: else if( goal==CEFF && (asgop(o) || o==STASG || o==INIT)) goal=NRGS;
393:
394: /* do a bit of optimization */
395:
396: if( goal == NRGS )
397: {
398: if( logop(o) )
399: {
400: /* must make p into ( p ? 1 : 0 ), then recompile */
401: q1 = talloc();
402: q1->tn.op = ICON;
403: q1->tn.name = (char *) 0;
404: q1->tn.lval = 1;
405: q1->tn.type = p->tn.type;
406: q2 = talloc();
407: *q2 = *q1;
408: q2->tn.lval = 0;
409: q = talloc();
410: q->tn.op = COLON;
411: q->tn.type = p->tn.type;
412: q->in.left = q1;
413: q->in.right = q2;
414: q1 = talloc();
415: q1->tn.op = o = QUEST;
416: q1->tn.type = p->tn.type;
417: q1->in.left = p;
418: q1->in.right = q;
419: p = q1; /* flow on, and compile */
420: }
421: }
422:
423: if( goal != CCC )
424: {
425: if( o == QUEST )
426: {
427: /* rewrite ? : when goal not CCC */
428: lf = getlab();
429: l = getlab();
430: p->tn.op = COMOP;
431: q = p->in.right;
432: q1 = condit( q->in.left, goal, -1, -1 );
433: q->in.right = condit( q->in.right, goal, -1, -1 );
434: if( tcond( p->in.left ) )
435: {
436: q->tn.op = FREE;
437: tfree( q->in.right );
438: p->in.right = q1;
439: p->in.left=condit( p->in.left, CEFF, -1, -1 );
440: return( rcomma( p ) );
441: }
442: if( fcond( p->in.left ) )
443: {
444: q->tn.op = FREE;
445: tfree( q1 );
446: p->in.right = q->in.right;
447: p->in.left=condit( p->in.left, CEFF, -1, -1 );
448: return( rcomma( p ) );
449: }
450: if( !q1 )
451: {
452: if( !q->in.right )
453: {
454: /* may still have work to do
455: ** if left side of ? has effect
456: */
457: q1 = condit(p->in.left, goal,
458: -1, -1);
459: if (!q1)
460: {
461: tfree( p->in.left );
462: }
463: p->tn.op = q->tn.op = FREE;
464: return( q1 );
465: }
466: /* rhs done if condition is false */
467: p->in.left = condit( p->in.left, CCC, l, -1 );
468: p->in.right = dlabel( q->in.right, l );
469: q->tn.op = FREE;
470: return( p );
471: }
472: else if( !q->in.right )
473: {
474: /* lhs done if condition is true */
475: p->in.left=condit( p->in.left, CCC, -1, lf );
476: p->in.right = dlabel( q1, lf );
477: q->tn.op = FREE;
478: return( p );
479: }
480:
481: /* both sides exist and the condition is nontrivial */
482: p->in.left = condit( p->in.left, CCC, -1, lf );
483: q1 = force(q1);
484: q->in.right = force(q->in.right);
485: q1 = genbr( 0, l, q1 );
486: q->in.left = dlabel( q1, lf );
487: q->tn.op = COMOP;
488: return( dlabel( p, l ) );
489: }
490:
491: if( goal == CEFF )
492: {
493: /* some things may disappear */
494: switch( o )
495: {
496:
497: case CBRANCH:
498: case GENBR:
499: case GENUBR:
500: case CALL:
501: case UNARY CALL:
502: case FORTCALL:
503: case UNARY FORTCALL:
504: case STCALL:
505: case UNARY STCALL:
506: case STASG:
507: case INIT:
508: case MOD: /* do these for the side effects */
509: case DIV:
510: case UOP0:
511: case UOP1:
512: case UOP2:
513: case UOP3:
514: case UOP4:
515: case UOP5:
516: case UOP6:
517: case UOP7:
518: case UOP8:
519: case UOP9:
520: goal = NRGS;
521: }
522: }
523:
524: /* The rhs of && and || ops are executed only if the
525: result is not clear from the lhs. If our goal is
526: CEFF, we don't need a result, but we need to
527: preserve that dependancy. So special case it. */
528: if (goal==CEFF) {
529: if (o == ANDAND) return andeff(p);
530: if (o == OROR) return oreff(p);
531: }
532: /* This next batch of code wanders over the tree getting
533: rid of code which is for effect only and has no
534: effect */
535: switch( optype(o) )
536: {
537: case LTYPE:
538: if( goal == CEFF )
539: {
540: p->tn.op = FREE;
541: return( NIL );
542: }
543: break;
544:
545: case BITYPE:
546: p->in.right = condit( p->in.right, goal, -1, -1 );
547: case UTYPE:
548: p->in.left = condit( p->in.left, o==COMOP?CEFF:goal,
549: -1, -1 );
550: }
551: /* If we are only interested in effects, we quit here */
552: if( goal == CEFF || o==COMOP )
553: {
554: /* lhs or rhs may have disappeared */
555: /* op need not get done */
556:
557: switch( optype(o) )
558: {
559:
560: case BITYPE:
561: p->tn.op = COMOP;
562: p = rcomma(p);
563: return ( p );
564:
565: case UTYPE:
566: p->tn.op = FREE;
567: return( p->in.left );
568:
569: case LTYPE:
570: p->tn.op = FREE;
571: return( NIL );
572: }
573: }
574: return( p );
575: }
576:
577: /* goal must = CCC from here on */
578:
579: switch( o )
580: {
581:
582: case ULE:
583: case ULT:
584: case UGE:
585: case UGT:
586: case EQ:
587: case NE:
588: case LE:
589: case LT:
590: case GE:
591: case GT:
592: if(t<0 )
593: {
594: o = p->tn.op = negrel[o-EQ];
595: t = f;
596: f = -1;
597: }
598:
599: #ifndef NOOPT
600: if( p->in.right->in.op == ICON &&
601: p->in.right->tn.lval == 0 &&
602: p->in.right->in.name == (char *) 0 )
603: {
604: /* if chars are unsigned, do these optimizations
605: as if this is an unsigned compare*/
606: #ifndef CHSIGN
607: if (
608: ( p->in.left->tn.type == TCHAR ||
609: ( p->in.left->in.op == CONV &&
610: p->in.left->in.left->tn.type == TCHAR ) )
611: && o >= LE && o <= GT)
612: o += UGT - GT;
613: #endif
614:
615: /* the question here is whether we can assume that */
616: /* unconditional branches preserve condition codes */
617: /* if this turned out to be no, we would have to */
618: /* explicitly handle this case here */
619:
620: switch( o )
621: {
622:
623: case UGT:
624: case ULE:
625: o = p->in.op = (o==UGT)?NE:EQ;
626: case EQ:
627: case NE:
628: case LE:
629: case LT:
630: case GE:
631: case GT:
632: if( logop( p->in.left->tn.op ) )
633: {
634: /* situation like (a==0)==0 */
635: /* ignore optimization */
636: goto noopt;
637: }
638: break;
639:
640: case ULT: /* never succeeds */
641: return( gtb( p, f ) );
642:
643: case UGE:
644: /* always succeeds */
645: return( gtb( p, t ) );
646: }
647: p->tn.op = p->in.right->tn.op = FREE;
648: p = condit( p->in.left, NRGS, -1, -1 );
649: p = genbr( o, t, p );
650: if( f<0 ) return( p );
651: else return( genbr( 0, f, p ) );
652: }
653: noopt:
654: # endif
655:
656: p->in.left = condit( p->in.left, NRGS, -1, -1 );
657: p->in.right = condit( p->in.right, NRGS, -1, -1 );
658: p = genbr( o, t, p );
659: if( f>=0 ) p = genbr( 0, f, p );
660: return( p );
661:
662: case COMOP:
663: p->in.left = condit( p->in.left, CEFF, -1, -1 );
664: p->in.right = condit( p->in.right, CCC, t, f );
665: return( rcomma( p ) );
666:
667: case NOT:
668: p->tn.op = FREE;
669: return( condit( p->in.left, CCC, f, t ) );
670:
671: case ANDAND:
672: lf = f<0 ? getlab() : f;
673: lt = t<0 ? getlab() : t;
674: p->tn.op = COMOP;
675: if( tcond( p->in.left ) )
676: {
677: /* left is always true */
678: p->in.left = condit( p->in.left, CEFF, -1, -1 );
679: p->in.right = condit( p->in.right, CCC, t, f );
680: }
681: else {
682: /* lhs not always true */
683: if( tcond( p->in.right ) )
684: {
685: /* rhs is always true */
686: p->in.right =
687: condit( p->in.right, CEFF, -1, -1 );
688: if (p->in.right) {
689: /* const with sideeffect */
690: p->in.left =
691: condit( p->in.left, CCC, -1,lf);
692: p->in.right = condit( p->in.right,
693: CCC, t, t );
694: } else
695: p->in.left =
696: condit( p->in.left, CCC, t, f );
697: } else {
698: p->in.left =
699: condit( p->in.left, CCC, -1, lf );
700: p->in.right =
701: condit( p->in.right, CCC, t, f );
702: }
703: }
704: q = rcomma( p );
705: if( f<0 ) q = dlabel( q, lf );
706: if( t<0 ) q = dlabel( q, lt );
707: return( q );
708:
709: case OROR:
710: lf = f<0 ? getlab() : f;
711: lt = t<0 ? getlab() : t;
712: p->tn.op = COMOP;
713: if( fcond( p->in.left ) )
714: {
715: /* left is always false */
716: p->in.left = condit( p->in.left, CEFF, -1, -1 );
717: p->in.right = condit( p->in.right, CCC, t, f );
718: }
719: else {
720: /* left is not always false */
721: if( fcond( p->in.right ) )
722: {
723: /* right always false */
724: p->in.right =
725: condit( p->in.right, CEFF, -1, -1 );
726: if (p->in.right) {
727: /* const with sideeffect */
728: p->in.left =
729: condit( p->in.left, CCC, lt,-1);
730: /* This may generate a superfluous
731: test. Tough. */
732: p->in.right = condit( p->in.right,
733: CCC, f, f );
734: } else
735: p->in.left =
736: condit( p->in.left, CCC, t, f );
737: } else {
738: p->in.left =
739: condit( p->in.left, CCC, lt, -1 );
740: p->in.right =
741: condit( p->in.right, CCC, t, f );
742: }
743: }
744: p = rcomma( p );
745: if( f<0 ) p = dlabel( p, lf );
746: if( t<0 ) p = dlabel( p, lt );
747: return( p );
748:
749: case QUEST:
750: lf = f<0 ? getlab() : f;
751: lt = t<0 ? getlab() : t;
752: p->in.left = condit( p->in.left, CCC, -1, l=getlab() );
753: q = p->in.right;
754: q1 = condit( q->in.left, goal, lt, lf );
755: q->in.left = dlabel( q1, l );
756: q->in.right = condit( q->in.right, goal, t, f );
757: p->tn.op = COMOP;
758: q->tn.op = COMOP;
759: if( t<0 ) p = dlabel( p, lt );
760: if( f<0 ) p = dlabel( p, lf );
761: return( p );
762:
763: default:
764: /* get the condition codes, generate the branch */
765: switch( optype(o) )
766: {
767: case BITYPE:
768: p->in.right = condit( p->in.right, NRGS, -1, -1 );
769: case UTYPE:
770: p->in.left = condit( p->in.left, NRGS, -1, -1 );
771: }
772: if( t>=0 ) p = genbr( NE, t, p );
773: if( f>=0 ) p = genbr( (t>=0)?0:EQ, f, p );
774: return( p );
775: }
776: }
777:
778: # ifndef TWOPASS
779:
780: p2compile( p )
781: register NODE *p;
782: {
783: if( lflag ) lineid( lineno, ftitle );
784: tmpoff = 0; /* expression at top level reuses temps */
785: /* generate code for the tree p */
786:
787: # ifdef MYREADER
788: MYREADER(p); /* do your own laundering of the input */
789: # endif
790: /* eliminate the conditionals */
791: # ifndef NODBG
792: if( p && odebug>2 ) e2print(p);
793: # endif
794: p = condit( p, CEFF, -1, -1 );
795: if( p )
796: {
797: /* expression does something */
798: /* generate the code */
799: # ifndef NODBG
800: if( odebug>2 ) e2print(p);
801: # endif
802: codgen( p );
803: }
804: # ifndef NODBG
805: else if( odebug>1 ) printf( "null effect\n" );
806: # endif
807: allchk();
808: /* tcheck will be done by the first pass at the end of a ftn. */
809: /* first pass will do it... */
810: }
811:
812: p2bbeg( aoff, myreg )
813: register aoff,myreg;
814: {
815: static int myftn = -1;
816: SETOFF( aoff, ALSTACK );
817: if( myftn != ftnno )
818: {
819: /* beginning of function */
820: maxboff = aoff;
821: myftn = ftnno;
822: maxtemp = 0;
823: maxarg = 0;
824: }
825: else
826: {
827: if( aoff > maxboff ) maxboff = aoff;
828: }
829: # ifdef SETREGS
830: SETREGS(myreg);
831: # endif
832: }
833:
834: p2bend()
835: {
836: SETOFF( maxboff, ALSTACK );
837: SETOFF( maxarg, ALSTACK );
838: SETOFF( maxtemp, ALSTACK );
839: eobl2();
840: maxboff = maxarg = maxtemp = 0;
841: }
842:
843: # endif
844:
845: char *cnames[] =
846: {
847: "CEFF",
848: "NRGS",
849: "CCC",
850: 0,
851: };
852:
853: prgoal( goal )
854: register goal;
855: {
856: /* print a nice-looking description of goal */
857:
858: register i, flag;
859:
860: flag = 0;
861: for( i=0; cnames[i]; ++i )
862: {
863: if( goal & (1<<i) )
864: {
865: if( flag ) printf( "|" );
866: ++flag;
867: printf( cnames[i] );
868: }
869: }
870: if( !flag ) printf( "?%o", goal );
871:
872: }
873:
874: #ifndef NODBG
875: e2print( p )
876: register NODE *p;
877: {
878: printf( "\n********* costs=(0,...,NRGS;EFF;TEMP;CC)\n" );
879: e22print( p ,"T");
880: printf("=========\n");
881: }
882:
883: e22print( p ,s)
884: register NODE *p;
885: char *s;
886: {
887: static down=0;
888: register ty;
889:
890: ty = optype( p->tn.op );
891: if( ty == BITYPE )
892: {
893: ++down;
894: e22print( p->in.right ,"R");
895: --down;
896: }
897: e222print( down, p, s );
898:
899: if( ty != LTYPE )
900: {
901: ++down;
902: e22print( p->in.left, "L" );
903: --down;
904: }
905: }
906:
907: e222print( down, p, s )
908: NODE *p;
909: char *s;
910: {
911: /* print one node */
912: int i, d;
913:
914: for( d=down; d>1; d -= 2 ) printf( "\t" );
915: if( d ) printf( " " );
916:
917: printf( "%s.%d) op= '%s'",s, (int)(p-node), opst[p->in.op] );
918: switch( p->in.op )
919: {
920: /* special cases */
921: case REG:
922: printf( " %s", rnames[p->tn.rval] );
923: break;
924:
925: case ICON:
926: case NAME:
927: case VAUTO:
928: case VPARAM:
929: case TEMP:
930: printf( " " );
931: adrput( p );
932: break;
933:
934: case STCALL:
935: case UNARY STCALL:
936: printf( " args=%d", p->stn.argsize );
937: case STARG:
938: case STASG:
939: printf( " size=%d", p->stn.stsize );
940: printf( " align=%d", p->stn.stalign );
941: break;
942:
943: case GENBR:
944: printf( " %d (%s)", p->bn.label, opst[p->bn.lop] );
945: break;
946:
947: case CALL:
948: case UNARY CALL:
949: printf( " args=%d", p->stn.argsize );
950: break;
951:
952: case GENUBR:
953: case GENLAB:
954: printf( " %d", p->bn.label );
955: break;
956:
957: case FUNARG:
958: printf( " offset=%d", p->tn.rval );
959:
960: }
961:
962: printf( ", " );
963: t2print( p->in.type );
964: printf( ", c=[" );
965: for( i=0; i<NRGS; ++i ) cprt( p->in.cst[i], "," );
966: cprt( p->in.cst[NRGS], "; " );
967: cprt( p->in.cst[CEFF], "; " );
968: cprt( p->in.cst[CTEMP], "; " );
969: cprt( p->in.cst[CCC], "]" );
970: if( p->tn.goal == CEFF ) printf( " (EFF)\n" );
971: else if( p->tn.goal == CCC ) printf( " (CC)\n" );
972: else if( p->tn.goal != NRGS ) printf( "(BAD GOAL: %d)\n", p->tn.goal );
973: else printf( "\n" );
974: }
975:
976: t2print( t )
977: TWORD t;
978: {
979: int i;
980: static struct {
981: TWORD mask;
982: char * string;
983: } t2tab[] = {
984: TANY, "ANY",
985: TINT, "INT",
986: TUNSIGNED, "UNSIGNED",
987: TCHAR, "CHAR",
988: TUCHAR, "UCHAR",
989: TSHORT, "SHORT",
990: TUSHORT, "USHORT",
991: TLONG, "LONG",
992: TULONG, "ULONG",
993: TFLOAT, "FLOAT",
994: TDOUBLE, "DOUBLE",
995: TPOINT, "POINTER",
996: TPOINT2, "POINTER2",
997: TSTRUCT, "STRUCT",
998: TVOID, "VOID",
999: 0, 0
1000: };
1001:
1002: for( i=0; t && t2tab[i].mask; ++i ) {
1003: if( (t&t2tab[i].mask) == t2tab[i].mask ) {
1004: printf( " %s", t2tab[i].string );
1005: t ^= t2tab[i].mask;
1006: }
1007: }
1008: }
1009:
1010: # else
1011: e2print( p )
1012: NODE *p;
1013: {
1014: werror( "e2print not compiled" );
1015: }
1016: e222print( p, s )
1017: NODE *p;
1018: char *s;
1019: {
1020: werror( "e222print not compiled" );
1021: }
1022: # endif
1023: cprt( c, s )
1024: register char *s;
1025: register c;
1026: {
1027: if( c >= INFINITY ) printf( "*%s", s );
1028: else printf( "%d%s", c, s );
1029: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.