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