![[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 [CSRG BSD Unix] / 3BSD / cmd / mip|
Return to allo.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / mip |
1.1 root 1: # include "mfile2"
2:
3: NODE resc[3];
4:
5: int busy[REGSZ];
6:
7: int maxa, mina, maxb, minb;
8:
9: allo0(){ /* free everything */
10:
11: register i;
12:
13: maxa = maxb = -1;
14: mina = minb = 0;
15:
16: REGLOOP(i){
17: busy[i] = 0;
18: if( rstatus[i] & STAREG ){
19: if( maxa<0 ) mina = i;
20: maxa = i;
21: }
22: if( rstatus[i] & STBREG ){
23: if( maxb<0 ) minb = i;
24: maxb = i;
25: }
26: }
27: }
28:
29: # define TBUSY 01000
30:
31: allo( p, q ) NODE *p; struct optab *q; {
32:
33: register n, i, j;
34:
35: n = q->needs;
36: i = 0;
37:
38: while( n & NACOUNT ){
39: resc[i].op = REG;
40: resc[i].rval = freereg( p, n&NAMASK );
41: resc[i].lval = 0;
42: resc[i].name[0] = '\0';
43: n -= NAREG;
44: ++i;
45: }
46:
47: while( n & NBCOUNT ){
48: resc[i].op = REG;
49: resc[i].rval = freereg( p, n&NBMASK );
50: resc[i].lval = 0;
51: resc[i].name[0] = '\0';
52: n -= NBREG;
53: ++i;
54: }
55:
56: if( n & NTMASK ){
57: resc[i].op = OREG;
58: resc[i].rval = TMPREG;
59: if( p->op == STCALL || p->op == STARG || p->op == UNARY STCALL || p->op == STASG ){
60: resc[i].lval = freetemp( (SZCHAR*p->stsize + (SZINT-1))/SZINT );
61: }
62: else {
63: resc[i].lval = freetemp( (n&NTMASK)/NTEMP );
64: }
65: resc[i].name[0] = '\0';
66: resc[i].lval = BITOOR(resc[i].lval);
67: ++i;
68: }
69:
70: /* turn off "temporarily busy" bit */
71:
72: REGLOOP(j){
73: busy[j] &= ~TBUSY;
74: }
75:
76: for( j=0; j<i; ++j ) if( resc[j].rval < 0 ) return(0);
77: return(1);
78:
79: }
80:
81: freetemp( k ){ /* allocate k integers worth of temp space */
82: /* we also make the convention that, if the number of words is more than 1,
83: /* it must be aligned for storing doubles... */
84:
85: # ifndef BACKTEMP
86: int t;
87:
88: if( k>1 ){
89: SETOFF( tmpoff, ALDOUBLE );
90: }
91:
92: t = tmpoff;
93: tmpoff += k*SZINT;
94: if( tmpoff > maxoff ) maxoff = tmpoff;
95: if( tmpoff-baseoff > maxtemp ) maxtemp = tmpoff-baseoff;
96: return(t);
97:
98: # else
99: tmpoff += k*SZINT;
100: if( k>1 ) {
101: SETOFF( tmpoff, ALDOUBLE );
102: }
103: if( tmpoff > maxoff ) maxoff = tmpoff;
104: if( tmpoff-baseoff > maxtemp ) maxtemp = tmpoff-baseoff;
105: return( -tmpoff );
106: # endif
107: }
108:
109: freereg( p, n ) NODE *p; {
110: /* allocate a register of type n */
111: /* p gives the type, if floating */
112:
113: register j;
114:
115: /* not general; means that only one register (the result) OK for call */
116: if( callop(p->op) ){
117: j = callreg(p);
118: if( usable( p, n, j ) ) return( j );
119: /* have allocated callreg first */
120: }
121: j = p->rall & ~MUSTDO;
122: if( j!=NOPREF && usable(p,n,j) ){ /* needed and not allocated */
123: return( j );
124: }
125: if( n&NAMASK ){
126: for( j=mina; j<=maxa; ++j ) if( rstatus[j]&STAREG ){
127: if( usable(p,n,j) ){
128: return( j );
129: }
130: }
131: }
132: else if( n &NBMASK ){
133: for( j=minb; j<=maxb; ++j ) if( rstatus[j]&STBREG ){
134: if( usable(p,n,j) ){
135: return(j);
136: }
137: }
138: }
139:
140: return( -1 );
141: }
142:
143: usable( p, n, r ) NODE *p; {
144: /* decide if register r is usable in tree p to satisfy need n */
145:
146: /* checks, for the moment */
147: if( !istreg(r) ) cerror( "usable asked about nontemp register" );
148:
149: if( busy[r] > 1 ) return(0);
150: if( isbreg(r) ){
151: if( n&NAMASK ) return(0);
152: }
153: else {
154: if( n & NBMASK ) return(0);
155: }
156: if( (n&NAMASK) && (szty(p->type) == 2) ){ /* only do the pairing for real regs */
157: if( !istreg(r+1) ) return( 0 );
158: if( busy[r+1] > 1 ) return( 0 );
159: if( busy[r] == 0 && busy[r+1] == 0 ||
160: busy[r+1] == 0 && shareit( p, r, n ) ||
161: busy[r] == 0 && shareit( p, r+1, n ) ||
162: shareit( p, r, n ) && shareit( p, r+1, n ) ){
163: busy[r] |= TBUSY;
164: busy[r+1] |= TBUSY;
165: return(1);
166: }
167: else return(0);
168: }
169: if( busy[r] == 0 ) {
170: busy[r] |= TBUSY;
171: return(1);
172: }
173:
174: /* busy[r] is 1: is there chance for sharing */
175: return( shareit( p, r, n ) );
176:
177: }
178:
179: shareit( p, r, n ) NODE *p; {
180: /* can we make register r available by sharing from p
181: given that the need is n */
182: if( (n&(NASL|NBSL)) && ushare( p, 'L', r ) ) return(1);
183: if( (n&(NASR|NBSR)) && ushare( p, 'R', r ) ) return(1);
184: return(0);
185: }
186:
187: ushare( p, f, r ) NODE *p; {
188: /* can we find a register r to share on the left or right
189: (as f=='L' or 'R', respectively) of p */
190: p = getlr( p, f );
191: if( p->op == UNARY MUL ) p = p->left;
192: if( p->op == OREG ){
193: if( R2TEST(p->rval) ){
194: return( r==R2UPK1(p->rval) || r==R2UPK2(p->rval) );
195: }
196: else return( r == p->rval );
197: }
198: if( p->op == REG ){
199: return( r == p->rval || ( szty(p->type) == 2 && r==p->rval+1 ) );
200: }
201: return(0);
202: }
203:
204: recl2( p ) register NODE *p; {
205: register r = p->rval;
206: if( p->op == REG ) rfree( r, p->type );
207: else if( p->op == OREG ) {
208: if( R2TEST( r ) ) {
209: if( R2UPK1( r ) != 100 ) rfree( R2UPK1( r ), PTR+INT );
210: rfree( R2UPK2( r ), INT );
211: }
212: else {
213: rfree( r, PTR+INT );
214: }
215: }
216: }
217:
218: int rdebug = 0;
219:
220: rfree( r, t ) TWORD t; {
221: /* mark register r free, if it is legal to do so */
222: /* t is the type */
223:
224: if( rdebug ){
225: printf( "rfree( %s ), size %d\n", rnames[r], szty(t) );
226: }
227:
228: if( istreg(r) ){
229: if( --busy[r] < 0 ) cerror( "register overfreed");
230: if( szty(t) == 2 ){
231: if( (istreg(r)^istreg(r+1)) ) cerror( "illegal free" );
232: if( --busy[r+1] < 0 ) cerror( "register overfreed" );
233: }
234: }
235: }
236:
237: rbusy(r,t) TWORD t; {
238: /* mark register r busy */
239: /* t is the type */
240:
241: if( rdebug ){
242: printf( "rbusy( %s ), size %d\n", rnames[r], szty(t) );
243: }
244:
245: if( istreg(r) ) ++busy[r];
246: if( szty(t) == 2 ){
247: if( istreg(r+1) ) ++busy[r+1];
248: if( (istreg(r)^istreg(r+1)) ) cerror( "illegal register pair freed" );
249: }
250: }
251:
252: rwprint( rw ){ /* print rewriting rule */
253: register i, flag;
254: static char * rwnames[] = {
255:
256: "RLEFT",
257: "RRIGHT",
258: "RESC1",
259: "RESC2",
260: "RESC3",
261: 0,
262: };
263:
264: if( rw == RNULL ){
265: printf( "RNULL" );
266: return;
267: }
268:
269: if( rw == RNOP ){
270: printf( "RNOP" );
271: return;
272: }
273:
274: flag = 0;
275: for( i=0; rwnames[i]; ++i ){
276: if( rw & (1<<i) ){
277: if( flag ) printf( "|" );
278: ++flag;
279: printf( rwnames[i] );
280: }
281: }
282: }
283:
284: reclaim( p, rw, cookie ) NODE *p; {
285: register NODE **qq;
286: register NODE *q;
287: register i;
288: NODE *recres[5];
289: struct respref *r;
290:
291: /* get back stuff */
292:
293: if( rdebug ){
294: printf( "reclaim( %o, ", p );
295: rwprint( rw );
296: printf( ", " );
297: prcook( cookie );
298: printf( " )\n" );
299: }
300:
301: if( rw == RNOP || ( p->op==FREE && rw==RNULL ) ) return; /* do nothing */
302:
303: walkf( p, recl2 );
304:
305: if( callop(p->op) ){
306: /* check that all scratch regs are free */
307: callchk(p); /* ordinarily, this is the same as allchk */
308: }
309:
310: if( rw == RNULL || (cookie&FOREFF) ){ /* totally clobber, leaving nothing */
311: tfree(p);
312: return;
313: }
314:
315: /* handle condition codes specially */
316:
317: if( (cookie & FORCC) && (rw&RESCC)) {
318: /* result is CC register */
319: tfree(p);
320: p->op = CCODES;
321: p->lval = 0;
322: p->rval = 0;
323: return;
324: }
325:
326: /* locate results */
327:
328: qq = recres;
329:
330: if( rw&RLEFT) *qq++ = p->left;
331: if( rw&RRIGHT ) *qq++ = p->right;
332: if( rw&RESC1 ) *qq++ = &resc[0];
333: if( rw&RESC2 ) *qq++ = &resc[1];
334: if( rw&RESC3 ) *qq++ = &resc[2];
335:
336: if( qq == recres ){
337: cerror( "illegal reclaim");
338: }
339:
340: *qq = NIL;
341:
342: /* now, select the best result, based on the cookie */
343:
344: for( r=respref; r->cform; ++r ){
345: if( cookie & r->cform ){
346: for( qq=recres; (q= *qq) != NIL; ++qq ){
347: if( tshape( q, r->mform ) ) goto gotit;
348: }
349: }
350: }
351:
352: /* we can't do it; die */
353: cerror( "cannot reclaim");
354:
355: gotit:
356:
357: if( p->op == STARG ) p = p->left; /* STARGs are still STARGS */
358:
359: /* q->type = p->type; /* to make multi-register allocations work */
360: q->type = p->type==FLOAT && q->op==REG ? DOUBLE : p->type;
361: /* maybe there is a better way! */
362: q = tcopy(q);
363:
364: tfree(p);
365:
366: p->op = q->op;
367: p->lval = q->lval;
368: p->rval = q->rval;
369: for( i=0; i<NCHNAM; ++i )
370: p->name[i] = q->name[i];
371:
372: q->op = FREE;
373:
374: /* if the thing is in a register, adjust the type */
375:
376: switch( p->op ){
377:
378: case REG:
379: if( p->type == CHAR || p->type == SHORT ) p->type = INT;
380: else if( p->type == UCHAR || p->type == USHORT ) p->type = UNSIGNED;
381: else if( p->type == FLOAT ) p->type = DOUBLE;
382: if( ! (p->rall & MUSTDO ) ) return; /* unless necessary, ignore it */
383: i = p->rall & ~MUSTDO;
384: if( i & NOPREF ) return;
385: if( i != p->rval ){
386: if( busy[i] || ( szty(p->type)==2 && busy[i+1] ) ){
387: cerror( "faulty register move" );
388: }
389: rbusy( i, p->type );
390: rfree( p->rval, p->type );
391: rmove( i, p->rval, p->type );
392: p->rval = i;
393: }
394:
395: case OREG:
396: if( p->op == REG || !R2TEST(p->rval) ) {
397: if( busy[p->rval]>1 && istreg(p->rval) ) cerror( "potential register overwrite");
398: }
399: else
400: if( (R2UPK1(p->rval) != 100 && busy[R2UPK1(p->rval)]>1 && istreg(R2UPK1(p->rval)) )
401: || (busy[R2UPK2(p->rval)]>1 && istreg(R2UPK2(p->rval)) ) )
402: cerror( "potential register overwrite");
403: }
404:
405: }
406:
407: ncopy( q, p ) NODE *p, *q; {
408: /* copy the contents of p into q, without any feeling for
409: the contents */
410: /* this code assume that copying rval and lval does the job;
411: in general, it might be necessary to special case the
412: operator types */
413: register i;
414:
415: q->op = p->op;
416: q->rall = p->rall;
417: q->type = p->type;
418: q->lval = p->lval;
419: q->rval = p->rval;
420: for( i=0; i<NCHNAM; ++i ) q->name[i] = p->name[i];
421:
422: }
423:
424: NODE *
425: tcopy( p ) register NODE *p; {
426: /* make a fresh copy of p */
427:
428: register NODE *q;
429: register r;
430:
431: ncopy( q=talloc(), p );
432:
433: r = p->rval;
434: if( p->op == REG ) rbusy( r, p->type );
435: else if( p->op == OREG ) {
436: if( R2TEST(r) ){
437: if( R2UPK1(r) != 100 ) rbusy( R2UPK1(r), PTR+INT );
438: rbusy( R2UPK2(r), INT );
439: }
440: else {
441: rbusy( r, PTR+INT );
442: }
443: }
444:
445: switch( optype(q->op) ){
446:
447: case BITYPE:
448: q->right = tcopy(p->right);
449: case UTYPE:
450: q->left = tcopy(p->left);
451: }
452:
453: return(q);
454: }
455:
456: allchk(){
457: /* check to ensure that all register are free */
458:
459: register i;
460:
461: REGLOOP(i){
462: if( istreg(i) && busy[i] ){
463: cerror( "register allocation error");
464: }
465: }
466:
467: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.