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