![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to order.vax CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc|
Return to order.vax CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc |
1.1 root 1: /*
2: * order.c -- conditionally included vax version
3: */
4:
5: static char *sccsid=" @(#)order.vax 1.1 (Berkeley) 2/3/86 ";
6:
7: int maxargs = { -1 };
8:
9: stoasg( p, o ) register NODE *p;
10: {
11: /* should the assignment op p be stored,
12: given that it lies as the right operand of o
13: (or the left, if o==UNARY MUL) */
14: /*
15: if( p->in.op == INCR || p->in.op == DECR ) return;
16: if( o==UNARY MUL && p->in.left->in.op == REG && !isbreg(p->in.left->tn.rval) ) SETSTO(p,INAREG);
17: */
18: }
19:
20: deltest( p ) register NODE *p;
21: {
22: /* should we delay the INCR or DECR operation p */
23: p = p->in.left;
24: return( p->in.op == REG || p->in.op == NAME || p->in.op == OREG );
25: }
26:
27: autoincr( p ) NODE *p;
28: {
29: register NODE *q = p->in.left, *r;
30:
31: if( q->in.op == INCR && (r=q->in.left)->in.op == REG &&
32: ISPTR(q->in.type) && p->in.type == DECREF(q->in.type) &&
33: tlen(p) == q->in.right->tn.lval ) return(1);
34:
35: return(0);
36: }
37:
38: mkadrs(p) register NODE *p;
39: {
40: register o;
41:
42: o = p->in.op;
43:
44: if( asgop(o) ){
45: if( p->in.left->in.su >= p->in.right->in.su ){
46: if( p->in.left->in.op == UNARY MUL ){
47: SETSTO( p->in.left->in.left, INTEMP );
48: }
49: else if( p->in.left->in.op == FLD && p->in.left->in.left->in.op == UNARY MUL ){
50: SETSTO( p->in.left->in.left->in.left, INTEMP );
51: }
52: else { /* should be only structure assignment */
53: SETSTO( p->in.left, INTEMP );
54: }
55: }
56: else SETSTO( p->in.right, INTEMP );
57: }
58: else {
59: if( p->in.left->in.su > p->in.right->in.su ){
60: SETSTO( p->in.left, INTEMP );
61: }
62: else {
63: SETSTO( p->in.right, INTEMP );
64: }
65: }
66: }
67:
68: notoff( t, r, off, cp) CONSZ off; char *cp;
69: {
70: /* is it legal to make an OREG or NAME entry which has an
71: /* offset of off, (from a register of r), if the
72: /* resulting thing had type t */
73:
74: /* if( r == R0 ) return( 1 ); /* NO */
75: return(0); /* YES */
76: }
77:
78: # define max(x,y) ((x)<(y)?(y):(x))
79:
80:
81: sucomp( p ) register NODE *p;
82: {
83:
84: /* set the su field in the node to the sethi-ullman
85: number, or local equivalent */
86:
87: register o, ty, sul, sur, r;
88:
89: o = p->in.op;
90: ty = optype( o );
91: p->in.su = szty( p->in.type ); /* 2 for float or double, else 1 */;
92:
93: if( ty == LTYPE ){
94: if( o == OREG ){
95: r = p->tn.rval;
96: /* oreg cost is (worst case) 1 + number of temp registers used */
97: if( R2TEST(r) ){
98: if( R2UPK1(r)!=100 && istreg(R2UPK1(r)) ) ++p->in.su;
99: if( istreg(R2UPK2(r)) ) ++p->in.su;
100: }
101: else {
102: if( istreg( r ) ) ++p->in.su;
103: }
104: }
105: if( p->in.su == szty(p->in.type) &&
106: (p->in.op!=REG || !istreg(p->tn.rval)) &&
107: (p->in.type==INT || p->in.type==UNSIGNED || p->in.type==DOUBLE) )
108: p->in.su = 0;
109: return;
110: }
111:
112: else if( ty == UTYPE ){
113: switch( o ) {
114: case UNARY CALL:
115: case UNARY STCALL:
116: p->in.su = fregs; /* all regs needed */
117: return;
118:
119: default:
120: p->in.su = p->in.left->in.su + (szty( p->in.type ) > 1 ? 2 : 0) ;
121: return;
122: }
123: }
124:
125:
126: /* If rhs needs n, lhs needs m, regular su computation */
127:
128: sul = p->in.left->in.su;
129: sur = p->in.right->in.su;
130:
131: if( o == ASSIGN ){
132: /* computed by doing right, then left (if not in mem), then doing it */
133: p->in.su = max(sur,sul+1);
134: return;
135: }
136:
137: if( o == CALL || o == STCALL ){
138: /* in effect, takes all free registers */
139: p->in.su = fregs;
140: return;
141: }
142:
143: if( o == STASG ){
144: /* right, then left */
145: p->in.su = max( max( 1+sul, sur), fregs );
146: return;
147: }
148:
149: if( asgop(o) ){
150: /* computed by doing right, doing left address, doing left, op, and store */
151: p->in.su = max(sur,sul+2);
152: /*
153: if( o==ASG MUL || o==ASG DIV || o==ASG MOD) p->in.su = max(p->in.su,fregs);
154: */
155: return;
156: }
157:
158: switch( o ){
159: case ANDAND:
160: case OROR:
161: case QUEST:
162: case COLON:
163: case COMOP:
164: p->in.su = max( max(sul,sur), 1);
165: return;
166:
167: case PLUS:
168: case OR:
169: case ER:
170: /* commutative ops; put harder on left */
171: if( p->in.right->in.su > p->in.left->in.su && !istnode(p->in.left) ){
172: register NODE *temp;
173: temp = p->in.left;
174: p->in.left = p->in.right;
175: p->in.right = temp;
176: }
177: break;
178: }
179:
180: /* binary op, computed by left, then right, then do op */
181: p->in.su = max(sul,szty(p->in.right->in.type)+sur);
182: /*
183: if( o==MUL||o==DIV||o==MOD) p->in.su = max(p->in.su,fregs);
184: */
185:
186: }
187:
188: int radebug = 0;
189:
190: mkrall( p, r ) register NODE *p;
191: {
192: /* insure that the use of p gets done with register r; in effect, */
193: /* simulate offstar */
194:
195: if( p->in.op == FLD ){
196: p->in.left->in.rall = p->in.rall;
197: p = p->in.left;
198: }
199:
200: if( p->in.op != UNARY MUL ) return; /* no more to do */
201: p = p->in.left;
202: if( p->in.op == UNARY MUL ){
203: p->in.rall = r;
204: p = p->in.left;
205: }
206: if( p->in.op == PLUS && p->in.right->in.op == ICON ){
207: p->in.rall = r;
208: p = p->in.left;
209: }
210: rallo( p, r );
211: }
212:
213: rallo( p, down ) NODE *p;
214: {
215: /* do register allocation */
216: register o, type, down1, down2, ty;
217:
218: if( radebug ) printf( "rallo( %o, %d )\n", p, down );
219:
220: down2 = NOPREF;
221: p->in.rall = down;
222: down1 = ( down &= ~MUSTDO );
223:
224: ty = optype( o = p->in.op );
225: type = p->in.type;
226:
227:
228: if( type == DOUBLE || type == FLOAT ){
229: if( o == FORCE ) down1 = R0|MUSTDO;
230: }
231: else switch( o ) {
232: case ASSIGN:
233: down1 = NOPREF;
234: down2 = down;
235: break;
236:
237:
238: case CALL:
239: case STASG:
240: case EQ:
241: case NE:
242: case GT:
243: case GE:
244: case LT:
245: case LE:
246: case NOT:
247: case ANDAND:
248: case OROR:
249: down1 = NOPREF;
250: break;
251:
252: case FORCE:
253: down1 = R0|MUSTDO;
254: break;
255:
256: }
257:
258: if( ty != LTYPE ) rallo( p->in.left, down1 );
259: if( ty == BITYPE ) rallo( p->in.right, down2 );
260:
261: }
262:
263: offstar( p ) register NODE *p;
264: {
265: if( p->in.op == PLUS ) {
266: if( p->in.left->in.su == fregs ) {
267: order( p->in.left, INTAREG|INAREG );
268: return;
269: } else if( p->in.right->in.su == fregs ) {
270: order( p->in.right, INTAREG|INAREG );
271: return;
272: }
273: if( p->in.left->in.op==LS &&
274: (p->in.left->in.left->in.op!=REG || tlen(p->in.left->in.left)!=sizeof(int) ) ) {
275: order( p->in.left->in.left, INTAREG|INAREG );
276: return;
277: }
278: if( p->in.right->in.op==LS &&
279: (p->in.right->in.left->in.op!=REG || tlen(p->in.right->in.left)!=sizeof(int) ) ) {
280: order( p->in.right->in.left, INTAREG|INAREG );
281: return;
282: }
283: if( p->in.type == (PTR|CHAR) || p->in.type == (PTR|UCHAR) ) {
284: if( p->in.left->in.op!=REG || tlen(p->in.left)!=sizeof(int) ) {
285: order( p->in.left, INTAREG|INAREG );
286: return;
287: }
288: else if( p->in.right->in.op!=REG || tlen(p->in.right)!=sizeof(int) ) {
289: order(p->in.right, INTAREG|INAREG);
290: return;
291: }
292: }
293: }
294: if( p->in.op == PLUS || p->in.op == MINUS ){
295: if( p->in.right->in.op == ICON ){
296: p = p->in.left;
297: order( p , INTAREG|INAREG);
298: return;
299: }
300: }
301:
302: if( p->in.op == UNARY MUL && !canaddr(p) ) {
303: offstar( p->in.left );
304: return;
305: }
306: order( p, INTAREG|INAREG );
307: }
308:
309: setincr( p ) register NODE *p;
310: {
311: p = p->in.left;
312: if( p->in.op == UNARY MUL ){
313: offstar( p );
314: return( 1 );
315: }
316: return( 0 );
317: }
318:
319: setbin( p ) register NODE *p;
320: {
321: register ro, rt;
322:
323: rt = p->in.right->in.type;
324: ro = p->in.right->in.op;
325:
326: if( canaddr( p->in.left ) && !canaddr( p->in.right ) ) { /* address rhs */
327: if( ro == UNARY MUL ) {
328: offstar( p->in.right->in.left );
329: return(1);
330: } else {
331: order( p->in.right, INAREG|INTAREG|SOREG );
332: return(1);
333: }
334: }
335: if( !istnode( p->in.left) ) { /* try putting LHS into a reg */
336: /* order( p->in.left, logop(p->in.op)?(INAREG|INBREG|INTAREG|INTBREG|SOREG):(INTAREG|INTBREG|SOREG) );*/
337: order( p->in.left, INAREG|INTAREG|INBREG|INTBREG|SOREG );
338: return(1);
339: }
340: else if( ro == UNARY MUL && rt != CHAR && rt != UCHAR ){
341: offstar( p->in.right->in.left );
342: return(1);
343: }
344: else if( rt == CHAR || rt == UCHAR || rt == SHORT || rt == USHORT || (ro != REG &&
345: ro != NAME && ro != OREG && ro != ICON ) ){
346: order( p->in.right, INAREG|INBREG );
347: return(1);
348: }
349: /*
350: else if( logop(p->in.op) && rt==USHORT ){ /* must get rhs into register */
351: /*
352: order( p->in.right, INAREG );
353: return( 1 );
354: }
355: */
356: return(0);
357: }
358:
359: setstr( p ) register NODE *p;
360: { /* structure assignment */
361: if( p->in.right->in.op != REG ){
362: order( p->in.right, INTBREG );
363: return(1);
364: }
365: p = p->in.left;
366: if( p->in.op != NAME && p->in.op != OREG ){
367: if( p->in.op != UNARY MUL ) cerror( "bad setstr" );
368: order( p->in.left, INTBREG );
369: return( 1 );
370: }
371: return( 0 );
372: }
373:
374: setasg( p ) register NODE *p;
375: {
376: /* setup for assignment operator */
377:
378: if( !canaddr(p->in.right) ) {
379: if( p->in.right->in.op == UNARY MUL )
380: offstar(p->in.right->in.left);
381: else
382: order( p->in.right, INAREG|INBREG|SOREG );
383: return(1);
384: }
385: if( p->in.left->in.op == UNARY MUL ) {
386: offstar( p->in.left->in.left );
387: return(1);
388: }
389: if( p->in.left->in.op == FLD && p->in.left->in.left->in.op == UNARY MUL ){
390: offstar( p->in.left->in.left->in.left );
391: return(1);
392: }
393: /* FLD patch */
394: if( p->in.left->in.op == FLD && !(p->in.right->in.type==INT || p->in.right->in.type==UNSIGNED)) {
395: order( p->in.right, INAREG);
396: return(1);
397: }
398: /* end of FLD patch */
399: return(0);
400: }
401:
402: setasop( p ) register NODE *p;
403: {
404: /* setup for =ops */
405: register rt, ro;
406:
407: rt = p->in.right->in.type;
408: ro = p->in.right->in.op;
409:
410: if( ro == UNARY MUL && rt != CHAR ){
411: offstar( p->in.right->in.left );
412: return(1);
413: }
414: if( ( rt == CHAR || rt == SHORT || rt == UCHAR || rt == USHORT ||
415: ( ro != REG && ro != ICON && ro != NAME && ro != OREG ) ) ){
416: order( p->in.right, INAREG|INBREG );
417: return(1);
418: }
419: /*
420: if( (p->in.op == ASG LS || p->in.op == ASG RS) && ro != ICON && ro != REG ){
421: order( p->in.right, INAREG );
422: return(1);
423: }
424: */
425:
426:
427: p = p->in.left;
428: if( p->in.op == FLD ) p = p->in.left;
429:
430: switch( p->in.op ){
431:
432: case REG:
433: case ICON:
434: case NAME:
435: case OREG:
436: return(0);
437:
438: case UNARY MUL:
439: if( p->in.left->in.op==OREG )
440: return(0);
441: else
442: offstar( p->in.left );
443: return(1);
444:
445: }
446: cerror( "illegal setasop" );
447: }
448:
449: int crslab = 9999; /* Honeywell */
450:
451: getlab()
452: {
453: return( crslab-- );
454: }
455:
456: deflab( l )
457: {
458: printf( "L%d:\n", l );
459: }
460:
461: genargs( p, ptemp ) register NODE *p, *ptemp;
462: {
463: register NODE *pasg;
464: register align;
465: register size;
466: register TWORD type;
467:
468: /* generate code for the arguments */
469:
470: /* first, do the arguments on the right */
471: while( p->in.op == CM ){
472: genargs( p->in.right, ptemp );
473: p->in.op = FREE;
474: p = p->in.left;
475: }
476:
477: if( p->in.op == STARG ){ /* structure valued argument */
478:
479: size = p->stn.stsize;
480: align = p->stn.stalign;
481: if( p->in.left->in.op == ICON ){
482: p->in.op = FREE;
483: p= p->in.left;
484: p->in.op = NAME;
485: }
486: else {
487: /* make it look beautiful... */
488: p->in.op = UNARY MUL;
489: canon( p ); /* turn it into an oreg */
490: if( p->in.op != OREG ){
491: offstar( p->in.left );
492: canon( p );
493: if( p->in.op != OREG ){
494: offstar( p->in.left );
495: canon( p );
496: if( p->in.op != OREG ) cerror( "stuck starg" );
497: }
498: }
499: }
500:
501:
502: ptemp->tn.lval = 0; /* all moves to (sp) */
503:
504: pasg = talloc();
505: pasg->in.op = STASG;
506: pasg->stn.stsize = size;
507: pasg->stn.stalign = align;
508: pasg->in.right = p;
509: pasg->in.left = tcopy( ptemp );
510:
511: /* the following line is done only with the knowledge
512: that it will be undone by the STASG node, with the
513: offset (lval) field retained */
514:
515: if( p->in.op == OREG ) p->in.op = REG; /* only for temporaries */
516:
517: order( pasg, FORARG );
518: ptemp->tn.lval += size;
519: return;
520:
521: }
522:
523: /* ordinary case */
524: order( p, FORARG );
525: }
526:
527: argsize( p ) register NODE *p;
528: {
529: register t;
530: t = 0;
531: if( p->in.op == CM ){
532: t = argsize( p->in.left );
533: p = p->in.right;
534: }
535: if( p->in.type == DOUBLE || p->in.type == FLOAT ){
536: SETOFF( t, 4 );
537: return( t+8 );
538: }
539: else if( p->in.op == STARG ){
540: SETOFF( t, 4 ); /* alignment */
541: return( t + ((p->stn.stsize+3)/4)*4 ); /* size */
542: }
543: else {
544: SETOFF( t, 4 );
545: return( t+4 );
546: }
547: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.