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