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