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