![[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] / researchv10no / cmd / ccom / common|
Return to allo.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
1.1 root 1: /* @(#) allo.c: 1.6 2/23/84 */
2:
3: # include "mfile2.h"
4:
5: extern NODE resc[];
6:
7: extern int busy[];
8:
9: # define TBUSY 0100
10:
11: allo( p, q )
12: register NODE *p;
13: register struct optab *q;
14: {
15: register n, i, j;
16: register NODE *presc;
17:
18: n = q->needs;
19: i = 0;
20: /* This code assumes a double reg counts 1 */
21: while( n & NCOUNT )
22: {
23: if( n&NPAIR )
24: {
25: j = freepair( p, n&NMASK );
26: busy[j] |= TBUSY;
27: busy[j+1] |= TBUSY;
28: }
29: else
30: {
31: j = freereg( p, n&NMASK );
32: busy[j] |= TBUSY;
33: }
34: n -= NREG;
35: presc = &resc[i];
36: presc->in.op = REG;
37: presc->tn.rval = j;
38: presc->tn.type = p->tn.type;
39: presc->tn.lval = 0;
40: presc->in.name = (char *) 0;
41: ++i;
42: }
43:
44: /* turn off "temporarily busy" bit */
45: for( j=0; j<NRGS; ++j )
46: {
47: busy[j] &= ~TBUSY;
48: }
49: #ifndef NODBG
50: if( rdebug > 1 )
51: {
52: printf( "allo( %d, %d ), %o", p-node, q->stinline, q->needs );
53: for( j=0; j<i; ++j )
54: {
55: if( resc[j].tn.op == REG )
56: printf( ", REG(%d)", resc[j].tn.rval );
57: else
58: printf( ", TEMP(%ld)", resc[j].tn.lval );
59: }
60: putchar( '\n' );
61: prbusy( "busy:" );
62: }
63: #endif
64: }
65:
66: # ifdef STACK
67: /* for stack machines, totally disable the register allocation */
68: freereg( p, n )
69: NODE *p;
70: {
71: return( 0 );
72: }
73:
74: freepair( p, n )
75: NODE *p;
76: {
77: cerror( "pairs on a stack machine?" );
78: }
79:
80: rbusy( r, t )
81: TWORD t;
82: {
83: }
84: rfree( r, t )
85: TWORD t;
86: {
87: }
88:
89: regrcl( p )
90: NODE *p;
91: {
92: }
93: # else
94: freepair( p, n )
95: register NODE *p;
96: register n;
97: {
98: /* allocate a register pair */
99: /* p gives the type */
100:
101: #ifdef MYPAIR
102: return (mypair(p, n));
103: #else
104: register j;
105:
106: if( callop(p->in.op) )
107: {
108: j = callreg(p);
109: if( j&1 ) cerror( "callreg returns bad pair" );
110: if( usable( p, n, j ) ) return( j );
111: /* have allocated callreg first */
112: }
113: if( n&NMASK )
114: {
115: #ifdef ODDPAIR /* if pair may start on odd reg. */
116: for( j=0; j<NRGS; j++ )
117: #else
118: for( j=0; j<NRGS; j+=2 )
119: #endif
120: if( usable(p,n,j) && usable(p,n,j+1))
121: return( j );
122: }
123: cerror( "freepair allocation fails, op %s", opst[p->tn.op] );
124: /* NOTREACHED */
125: #endif
126: }
127:
128: freereg( p, n )
129: register NODE *p;
130: register n;
131: {
132: /* allocate a register */
133: /* p gives the type */
134:
135: register j;
136: register int t = optype( p->tn.op );
137:
138: if( callop(p->in.op) )
139: {
140: j = callreg(p);
141: if( usable( p, n, j ) ) return( j );
142: /* have allocated callreg first */
143: }
144: if( n&NMASK )
145: {
146: if( (n&LPREF) && (j = shared( getlt( p, t ) ) ) >= 0 &&
147: usable( p, n, j ) ) return( j );
148: if( (n&RPREF) && (j = shared( getrt( p, t ) ) ) >= 0 &&
149: usable( p, n, j ) ) return( j );
150: for( j=0; j<NRGS; ++j ) if( usable(p,n,j) ) return( j );
151: }
152: cerror( "freereg allocation fails, op %s", opst[p->tn.op] );
153: /* NOTREACHED */
154: }
155:
156: shared( p )
157: register NODE *p;
158: {
159: /* simple, at present */
160: /* try to find a single register to share */
161: register r, o;
162: #ifndef NODBG
163: if( rdebug )
164: {
165: printf( "shared called on:\n" );
166: e2print( p );
167: }
168: #endif
169: if( (o=p->tn.op) == REG )
170: {
171: r = p->tn.rval;
172: if (r >= NRGS) return ( -1 );
173: #ifndef NODBG
174: if( rdebug )
175: {
176: printf( "preference for %s\n", rnames[r] );
177: }
178: #endif
179: return( r );
180: }
181: /* we look for shared regs under unary-like ops */
182: switch( optype( o ) )
183: {
184:
185: case BITYPE:
186: /* look for simple cases */
187: /* look only on the left */
188: case UTYPE:
189: return( shared( p->in.left ) );
190: }
191: return( -1 );
192: }
193:
194: usable( p, n, r )
195: register NODE *p;
196: register n,r;
197: {
198: /* decide if register r is usable in tree p to satisfy need n */
199: /* this does not concern itself with pairs */
200:
201: if( r>= NRGS || (busy[r] & TBUSY) ) return( 0 );
202: if( busy[r] > 1 )
203: {
204: /*
205: ** uerror( "register %d too busy", r );
206: */
207: return( 0 );
208: }
209: if( busy[r] == 0 ) {
210: return(1);
211: }
212:
213: /* busy[r] is 1: is there chance for sharing */
214: return( shareit( p, r, n ) );
215:
216: }
217:
218: shareit( p, r, n )
219: register NODE *p;
220: register r;
221: int n;
222: {
223: /* can we make register r available by sharing from p
224: ** given that the need is n
225: */
226: register NODE *sub;
227: register int t = optype(p->tn.op);
228:
229: sub = getlt( p, t );
230: if( (n&LSHARE) && ushare( sub, r ) ) {
231: return 1;
232: }
233: sub = getrt( p, t );
234: if( (n&RSHARE) && ushare( sub, r ) ) {
235: return(1);
236: }
237: return(0);
238: }
239:
240: ushare( p, r )
241: register NODE *p;
242: register r;
243: {
244: /* can we find register r to share in p */
245: if( p->in.op == REG )
246: {
247: if( szty( p->tn.type ) == 2 && r==(p->tn.rval+1) ) return( 1 );
248: return( r == p->tn.rval );
249: }
250: switch( optype( p->tn.op ) )
251: {
252: case BITYPE:
253: if( ushare( p->in.right, r ) ) return( 1 );
254: case UTYPE:
255: if( ushare( p->in.left, r ) ) return( 1 );
256: }
257: return(0);
258: }
259:
260: regrcl( p )
261: register NODE *p;
262: {
263: /* free registers in the tree (or fragment) p */
264: register r;
265: if( !p ) return;
266: r = p->tn.rval;
267: if( p->in.op == REG ) rfree( r, p->in.type );
268: switch( optype( p->tn.op ) )
269: {
270: case BITYPE:
271: regrcl( p->in.right );
272: /* explict assignment to regs not accounted for */
273: if( asgop(p->tn.op) && p->in.left->tn.op == REG ) break;
274: case UTYPE:
275: regrcl( p->in.left );
276: }
277: }
278:
279: rfree( r, t )
280: register TWORD t;
281: register r;
282: {
283: /* mark register r free, if it is legal to do so */
284: /* t is the type */
285:
286: #ifndef NODBG
287: if( rdebug )
288: {
289: printf( "rfree( %s, ", rnames[r] );
290: t2print( t );
291: printf( " )\n" );
292: }
293: #endif
294: if( istreg(r) )
295: {
296: if( --busy[r] < 0 ) cerror( "register overfreed");
297: if( szty( t ) > 1 )
298: {
299: if( !istreg(r+1) ) cerror( "big register" );
300: if( --busy[r+1] < 0 ) cerror( "register overfreed" );
301: }
302: }
303: }
304:
305: prbusy( s )
306: char *s;
307: {
308: /* print out the busy[] array */
309: int i;
310: printf( "%s [", s );
311: for( i=0; i<NRGS-1; ++i ) printf( "%d,", busy[i] );
312: printf( "%d]\n", busy[NRGS-1] );
313: }
314:
315: # endif
316:
317: rwprint( rw )
318: register rw;
319: {
320: /* print rewriting rule */
321: register i, flag;
322: static char * rwnames[] =
323: {
324: "RLEFT",
325: "RRIGHT",
326: "RESC1",
327: "RESC2",
328: "RESC3",
329: "RESCC",
330: "RNOP",
331: 0,
332: };
333: if( rw == RNULL )
334: {
335: printf( "RNULL" );
336: return;
337: }
338: flag = 0;
339: for( i=0; rwnames[i]; ++i )
340: {
341: if( rw & (1<<i) )
342: {
343: if( flag ) printf( "|" );
344: ++flag;
345: printf( rwnames[i] );
346: }
347: }
348: if( !flag ) printf( "?%o", rw );
349: }
350:
351: reclaim( p, rw, goal )
352: register NODE *p;
353: register rw, goal;
354: {
355: register NODE *q;
356: register o;
357:
358: /* get back stuff */
359: #ifndef NODBG
360: if( rdebug )
361: {
362: printf( "reclaim( %d, ", p-node );
363: rwprint( rw );
364: printf( ", " );
365: prgoal( goal );
366: printf( " )\n" );
367: }
368: #endif
369: if( !p ) return;
370: /* special cases... */
371: if( (o=p->tn.op) == COMOP )
372: {
373: /* LHS has already been freed; don't free again */
374: regrcl( p->in.right );
375: }
376: else regrcl( p );
377: if( (o==FREE && rw==RNULL) || rw==RNOP ) return;
378: if( callop(o) )
379: {
380: /* check that all scratch regs are free */
381: callchk(p); /* ordinarily, this is the same as allchk() */
382: }
383: if( rw == RNULL || (goal&FOREFF) )
384: {
385: /* totally clobber, leave nothing */
386: tfree(p);
387: return;
388: }
389: /* handle condition codes specially */
390: if( (goal & FORCC) && (rw&RESCC))
391: {
392: /* result is CC register */
393: tfree(p);
394: p->in.op = CCODES;
395: p->tn.lval = 0;
396: p->tn.rval = 0;
397: return;
398: }
399: q = 0;
400: if( rw&RLEFT) q = getl( p );
401: else if( rw&RRIGHT ) q = getr( p );
402: else if( rw&RESC1 ) q = &resc[0];
403: else if( rw&RESC2 ) q = &resc[1];
404: else if( rw&RESC3 ) q = &resc[2];
405: else
406: {
407: cerror( "illegal reclaim, op %s", opst[p->tn.op]);
408: }
409: if( o == STARG ) p = p->in.left; /* STARGs are still STARGS */
410: q = tcopy(q, 1);
411: tfree(p);
412: *p = *q; /* make the result replace the original */
413: q->in.op = FREE;
414: }
415:
416: NODE *
417: tcopy( p, busyregs )
418: register NODE *p;
419: int busyregs;
420: {
421: /* make a fresh copy of p */
422: register NODE *q;
423: register r;
424:
425: q=talloc();
426: *q = *p;
427: r = p->tn.rval;
428: if( p->in.op == REG && busyregs) rbusy( r, p->in.type );
429: switch( optype(q->in.op) )
430: {
431: case BITYPE:
432: q->in.right = tcopy(p->in.right, busyregs);
433: case UTYPE:
434: q->in.left = tcopy(p->in.left, busyregs);
435: }
436: return(q);
437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.