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