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