![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to allo.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 allo.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 root 1: /* @(#) allo.c: 1.7 6/26/84 */
2:
3: # include "mfile2.h"
4:
5: NODE resc[NRGS];
6:
7: int busy[NRGS];
8:
9: # define TBUSY 0100
10:
11: allo0()
12: {
13: /* free everything */
14: register i;
15:
16: for( i=0; i<NRGS; ++i )
17: {
18: busy[i] = 0;
19: }
20: }
21:
22: allo( p, q )
23: register NODE *p;
24: register struct optab *q;
25: {
26: register n, i, j;
27: register NODE *presc;
28:
29: n = q->needs;
30: i = 0;
31: /* This code assumes a double reg counts 1 */
32: while( n & NCOUNT )
33: {
34: if( n&NPAIR )
35: {
36: j = freepair( p, n&NMASK );
37: busy[j] |= TBUSY;
38: busy[j+1] |= TBUSY;
39: #if defined(M32B) && defined(IMPREGAL)
40: radbl(); /* inform optimizer double reg used */
41: #endif
42: }
43: else
44: {
45: j = freereg( p, n&NMASK );
46: busy[j] |= TBUSY;
47: }
48: n -= NREG;
49: presc = &resc[i];
50: presc->in.op = REG;
51: presc->tn.rval = j;
52: presc->tn.type = p->tn.type;
53: presc->tn.lval = 0;
54: presc->in.name = (char *) 0;
55: ++i;
56: }
57:
58: /* turn off "temporarily busy" bit */
59: for( j=0; j<NRGS; ++j )
60: {
61: busy[j] &= ~TBUSY;
62: }
63: #ifndef NODBG
64: if( rdebug > 1 )
65: {
66: printf( "allo( %d, %d ), %o", p-node, q->stinline, q->needs );
67: for( j=0; j<i; ++j )
68: {
69: if( resc[j].tn.op == REG )
70: printf( ", REG(%d)", resc[j].tn.rval );
71: else
72: printf( ", TEMP(%ld)", resc[j].tn.lval );
73: }
74: putchar( '\n' );
75: prbusy( "busy:" );
76: }
77: #endif
78: }
79:
80: int tmpoff; /* offset of next temp to be allocated */
81:
82: int rdebug = 0;
83:
84: freetemp( k )
85: register k;
86: {
87: /* allocate k integers worth of temp space
88: ** we also make the convention that, if the number of words is more than 1,
89: ** it must be aligned for storing doubles...
90: */
91:
92: # ifndef BACKTEMP
93: int t;
94:
95: if( k>1 )
96: {
97: SETOFF( tmpoff, ALDOUBLE );
98: }
99:
100: t = tmpoff;
101: tmpoff += k*SZINT;
102: if( tmpoff > maxtemp ) maxtemp = tmpoff;
103: return(t);
104:
105: # else
106: tmpoff += k*SZINT;
107: if( k>1 )
108: {
109: SETOFF( tmpoff, ALDOUBLE );
110: }
111: if( tmpoff > maxtemp ) maxtemp = tmpoff;
112: return( -tmpoff );
113: # endif
114: }
115:
116: # ifdef STACK
117: /* for stack machines, totally disable the register allocation */
118: freereg( p, n )
119: NODE *p;
120: {
121: return( 0 );
122: }
123:
124: freepair( p, n )
125: NODE *p;
126: {
127: cerror( "pairs on a stack machine?" );
128: }
129:
130: rbusy( r, t )
131: TWORD t;
132: {
133: }
134: rfree( r, t )
135: TWORD t;
136: {
137: }
138:
139: regrcl( p )
140: NODE *p;
141: {
142: }
143: # else
144: freepair( p, n )
145: register NODE *p;
146: register n;
147: {
148: /* allocate a register pair */
149: /* p gives the type */
150:
151: #ifdef MYPAIR
152: return (mypair(p, n));
153: #else
154: register j;
155:
156: if( callop(p->in.op) )
157: {
158: j = callreg(p);
159: if( j&1 ) cerror( "callreg returns bad pair" );
160: if( usable( p, n, j ) ) return( j );
161: /* have allocated callreg first */
162: }
163: if( n&NMASK )
164: {
165: #ifdef ODDPAIR /* if pair may start on odd reg. */
166: for( j=0; j<NRGS; j++ )
167: #else
168: for( j=0; j<NRGS; j+=2 )
169: #endif
170: if( usable(p,n,j) && usable(p,n,j+1))
171: return( j );
172: }
173: cerror( "allocation fails, op %s", opst[p->tn.op] );
174: /* NOTREACHED */
175: #endif
176: }
177:
178: freereg( p, n )
179: register NODE *p;
180: register n;
181: {
182: /* allocate a register */
183: /* p gives the type */
184:
185: register j;
186: register int t = optype( p->tn.op );
187:
188: if( callop(p->in.op) )
189: {
190: j = callreg(p);
191: if( usable( p, n, j ) ) return( j );
192: /* have allocated callreg first */
193: }
194: if( n&NMASK )
195: {
196: if( (n&LPREF) && (j = shared( getlt( p, t ) ) ) >= 0 &&
197: usable( p, n, j ) ) return( j );
198: if( (n&RPREF) && (j = shared( getrt( p, t ) ) ) >= 0 &&
199: usable( p, n, j ) ) return( j );
200: for( j=0; j<NRGS; ++j ) if( usable(p,n,j) ) return( j );
201: }
202: cerror( "allocation fails, op %s", opst[p->tn.op] );
203: /* NOTREACHED */
204: }
205:
206: shared( p )
207: register NODE *p;
208: {
209: /* simple, at present */
210: /* try to find a single register to share */
211: register r, o;
212: #ifndef NODBG
213: if( rdebug )
214: {
215: printf( "shared called on:\n" );
216: e2print( p );
217: }
218: #endif
219: if( (o=p->tn.op) == REG )
220: {
221: r = p->tn.rval;
222: if (r >= NRGS) return ( -1 );
223: #ifndef NODBG
224: if( rdebug )
225: {
226: printf( "preference for %s\n", rnames[r] );
227: }
228: #endif
229: return( r );
230: }
231: /* we look for shared regs under unary-like ops */
232: switch( optype( o ) )
233: {
234:
235: case BITYPE:
236: /* look for simple cases */
237: /* look only on the left */
238: case UTYPE:
239: return( shared( p->in.left ) );
240: }
241: return( -1 );
242: }
243:
244: usable( p, n, r )
245: register NODE *p;
246: register n,r;
247: {
248: /* decide if register r is usable in tree p to satisfy need n */
249: /* this does not concern itself with pairs */
250:
251: if( r>= NRGS || (busy[r] & TBUSY) ) return( 0 );
252: if( busy[r] > 1 )
253: {
254: /*
255: ** uerror( "register %d too busy", r );
256: */
257: return( 0 );
258: }
259: if( busy[r] == 0 ) {
260: return(1);
261: }
262:
263: /* busy[r] is 1: is there chance for sharing */
264: return( shareit( p, r, n ) );
265:
266: }
267:
268: shareit( p, r, n )
269: register NODE *p;
270: register r;
271: int n;
272: {
273: /* can we make register r available by sharing from p
274: ** given that the need is n
275: */
276: register NODE *sub;
277: register int t = optype(p->tn.op);
278:
279: sub = getlt( p, t );
280: if( (n&LSHARE) && ushare( sub, r ) ) {
281: return 1;
282: }
283: sub = getrt( p, t );
284: if( (n&RSHARE) && ushare( sub, r ) ) {
285: return(1);
286: }
287: return(0);
288: }
289:
290: ushare( p, r )
291: register NODE *p;
292: register r;
293: {
294: /* can we find register r to share in p */
295: if( p->in.op == REG )
296: {
297: if( szty( p->tn.type ) == 2 && r==(p->tn.rval+1) ) return( 1 );
298: return( r == p->tn.rval );
299: }
300: switch( optype( p->tn.op ) )
301: {
302: case BITYPE:
303: if( ushare( p->in.right, r ) ) return( 1 );
304: case UTYPE:
305: if( ushare( p->in.left, r ) ) return( 1 );
306: }
307: return(0);
308: }
309:
310: regrcl( p )
311: register NODE *p;
312: {
313: /* free registers in the tree (or fragment) p */
314: register r;
315: if( !p ) return;
316: r = p->tn.rval;
317: if( p->in.op == REG ) rfree( r, p->in.type );
318: switch( optype( p->tn.op ) )
319: {
320: case BITYPE:
321: regrcl( p->in.right );
322: /* explict assignment to regs not accounted for */
323: if( asgop(p->tn.op) && p->in.left->tn.op == REG ) break;
324: case UTYPE:
325: regrcl( p->in.left );
326: }
327: }
328:
329: rfree( r, t )
330: register TWORD t;
331: register r;
332: {
333: /* mark register r free, if it is legal to do so */
334: /* t is the type */
335:
336: #ifndef NODBG
337: if( rdebug )
338: {
339: printf( "rfree( %s, ", rnames[r] );
340: t2print( t );
341: printf( " )\n" );
342: }
343: #endif
344: if( istreg(r) )
345: {
346: if( --busy[r] < 0 ) cerror( "register overfreed");
347: if( szty( t ) > 1 )
348: {
349: if( !istreg(r+1) ) cerror( "big register" );
350: if( --busy[r+1] < 0 ) cerror( "register overfreed" );
351: }
352: }
353: }
354:
355: rbusy(r, t )
356: register r;
357: register TWORD t;
358: {
359: /* mark register r busy */
360:
361: #ifndef NODBG
362: if( rdebug )
363: {
364: printf( "rbusy( %s, ", rnames[r] );
365: t2print( t );
366: printf( " )\n" );
367: }
368: #endif
369: if( istreg(r) )
370: {
371: ++busy[r];
372: if( szty( t ) > 1 )
373: {
374: if( !istreg(r+1) ) cerror( "big register" );
375: ++busy[r+1];
376: }
377: }
378: }
379:
380: prbusy( s )
381: char *s;
382: {
383: /* print out the busy[] array */
384: int i;
385: printf( "%s [", s );
386: for( i=0; i<NRGS-1; ++i ) printf( "%d,", busy[i] );
387: printf( "%d]\n", busy[NRGS-1] );
388: }
389:
390: # endif
391:
392: rwprint( rw )
393: register rw;
394: {
395: /* print rewriting rule */
396: register i, flag;
397: static char * rwnames[] =
398: {
399: "RLEFT",
400: "RRIGHT",
401: "RESC1",
402: "RESC2",
403: "RESC3",
404: "RESCC",
405: "RNOP",
406: 0,
407: };
408: if( rw == RNULL )
409: {
410: printf( "RNULL" );
411: return;
412: }
413: flag = 0;
414: for( i=0; rwnames[i]; ++i )
415: {
416: if( rw & (1<<i) )
417: {
418: if( flag ) printf( "|" );
419: ++flag;
420: printf( rwnames[i] );
421: }
422: }
423: if( !flag ) printf( "?%o", rw );
424: }
425:
426: reclaim( p, rw, goal )
427: register NODE *p;
428: register rw, goal;
429: {
430: register NODE *q;
431: register o;
432:
433: /* get back stuff */
434: #ifndef NODBG
435: if( rdebug )
436: {
437: printf( "reclaim( %d, ", p-node );
438: rwprint( rw );
439: printf( ", " );
440: prgoal( goal );
441: printf( " )\n" );
442: }
443: #endif
444: if( !p ) return;
445: /* special cases... */
446: if( (o=p->tn.op) == COMOP )
447: {
448: /* LHS has already been freed; don't free again */
449: regrcl( p->in.right );
450: }
451: else regrcl( p );
452: if( (o==FREE && rw==RNULL) || rw==RNOP ) return;
453: if( callop(o) )
454: {
455: /* check that all scratch regs are free */
456: callchk(p); /* ordinarily, this is the same as allchk() */
457: }
458: if( rw == RNULL || (goal&FOREFF) )
459: {
460: /* totally clobber, leave nothing */
461: tfree(p);
462: return;
463: }
464: /* handle condition codes specially */
465: if( (goal & FORCC) && (rw&RESCC))
466: {
467: /* result is CC register */
468: tfree(p);
469: p->in.op = CCODES;
470: p->tn.lval = 0;
471: p->tn.rval = 0;
472: return;
473: }
474: q = 0;
475: if( rw&RLEFT) q = getl( p );
476: else if( rw&RRIGHT ) q = getr( p );
477: else if( rw&RESC1 ) q = &resc[0];
478: else if( rw&RESC2 ) q = &resc[1];
479: else if( rw&RESC3 ) q = &resc[2];
480: else
481: {
482: cerror( "illegal reclaim, op %s", opst[p->tn.op]);
483: }
484: if( o == STARG ) p = p->in.left; /* STARGs are still STARGS */
485: q = tcopy(q);
486: tfree(p);
487: *p = *q; /* make the result replace the original */
488: q->in.op = FREE;
489: }
490:
491: NODE *
492: tcopy( p )
493: register NODE *p;
494: {
495: /* make a fresh copy of p */
496: register NODE *q;
497: register r;
498:
499: q=talloc();
500: *q = *p;
501: r = p->tn.rval;
502: if( p->in.op == REG ) rbusy( r, p->in.type );
503: switch( optype(q->in.op) )
504: {
505: case BITYPE:
506: q->in.right = tcopy(p->in.right);
507: case UTYPE:
508: q->in.left = tcopy(p->in.left);
509: }
510: return(q);
511: }
512:
513: allchk()
514: {
515: /* check to ensure that all register are free */
516: register i;
517:
518: for( i=0; i<NRGS; ++i )
519: {
520: if( busy[i] )
521: {
522: cerror( "register allocation error");
523: }
524: }
525: }
526:
527: /* this may not be the best place for this routine... */
528: argsize( p )
529: register NODE *p;
530: {
531: /* size of the arguments */
532: register t;
533: t = 0;
534: if( p->tn.op == CM )
535: {
536: t = argsize( p->in.left );
537: p = p->in.right;
538: }
539: if( p->tn.type & (TDOUBLE|TFLOAT) )
540: {
541: SETOFF( t, ALDOUBLE );
542: t += SZDOUBLE;
543: }
544: else if( p->tn.type & (TLONG|TULONG) )
545: {
546: SETOFF( t, ALLONG );
547: t += SZLONG;
548: }
549: else if( p->tn.type & TPOINT )
550: {
551: SETOFF( t, ALPOINT );
552: t += SZPOINT;
553: }
554: else if( p->tn.type & TSTRUCT )
555: {
556: SETOFF( t, p->stn.stalign ); /* alignment */
557: t += p->stn.stsize; /* size */
558: }
559: else
560: {
561: SETOFF( t, ALINT );
562: t += SZINT;
563: }
564: return( t );
565: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.