![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / mip|
Return to optim.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / mip |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)optim.c 4.7 (Berkeley) 1/8/86"; ! 3: #endif lint ! 4: ! 5: # include "pass1.h" ! 6: ! 7: # define SWAP(p,q) {sp=p; p=q; q=sp;} ! 8: # define RCON(p) (p->in.right->in.op==ICON) ! 9: # define RO(p) p->in.right->in.op ! 10: # define RV(p) p->in.right->tn.lval ! 11: # define LCON(p) (p->in.left->in.op==ICON) ! 12: # define LO(p) p->in.left->in.op ! 13: # define LV(p) p->in.left->tn.lval ! 14: ! 15: /* is p a constant without a name */ ! 16: # define nncon(p) ((p)->in.op == ICON && (p)->tn.rval == NONAME) ! 17: ! 18: int oflag = 0; ! 19: ! 20: NODE * ! 21: fortarg( p ) NODE *p; { ! 22: /* fortran function arguments */ ! 23: ! 24: if( p->in.op == CM ){ ! 25: p->in.left = fortarg( p->in.left ); ! 26: p->in.right = fortarg( p->in.right ); ! 27: return(p); ! 28: } ! 29: ! 30: while( ISPTR(p->in.type) ){ ! 31: p = buildtree( UNARY MUL, p, NIL ); ! 32: } ! 33: return( optim(p) ); ! 34: } ! 35: ! 36: /* mapping relationals when the sides are reversed */ ! 37: short revrel[] ={ EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT }; ! 38: NODE * ! 39: optim(p) register NODE *p; { ! 40: /* local optimizations, most of which are probably machine independent */ ! 41: ! 42: register o, ty; ! 43: NODE *sp; ! 44: int i; ! 45: TWORD t; ! 46: ! 47: if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p); ! 48: if( oflag ) return(p); ! 49: ty = optype( o=p->in.op); ! 50: if( ty == LTYPE ) return(p); ! 51: ! 52: if( ty == BITYPE ) p->in.right = optim(p->in.right); ! 53: p->in.left = optim(p->in.left); ! 54: ! 55: /* collect constants */ ! 56: ! 57: switch(o){ ! 58: ! 59: case SCONV: ! 60: case PCONV: ! 61: return( clocal(p) ); ! 62: ! 63: case FORTCALL: ! 64: p->in.right = fortarg( p->in.right ); ! 65: break; ! 66: ! 67: case UNARY AND: ! 68: if( LO(p) != NAME || !andable(p->in.left) ) return(p); ! 69: ! 70: LO(p) = ICON; ! 71: ! 72: setuleft: ! 73: /* paint over the type of the left hand side with the type of the top */ ! 74: p->in.left->in.type = p->in.type; ! 75: p->in.left->fn.cdim = p->fn.cdim; ! 76: p->in.left->fn.csiz = p->fn.csiz; ! 77: p->in.op = FREE; ! 78: return( p->in.left ); ! 79: ! 80: case UNARY MUL: ! 81: if( LO(p) != ICON ) break; ! 82: LO(p) = NAME; ! 83: goto setuleft; ! 84: ! 85: case MINUS: ! 86: if( !nncon(p->in.right) ) break; ! 87: RV(p) = -RV(p); ! 88: o = p->in.op = PLUS; ! 89: ! 90: case MUL: ! 91: case PLUS: ! 92: case AND: ! 93: case OR: ! 94: case ER: ! 95: /* commutative ops; for now, just collect constants */ ! 96: /* someday, do it right */ ! 97: if( nncon(p->in.left) || ( LCON(p) && !RCON(p) ) ) SWAP( p->in.left, p->in.right ); ! 98: /* make ops tower to the left, not the right */ ! 99: if( RO(p) == o ){ ! 100: NODE *t1, *t2, *t3; ! 101: t1 = p->in.left; ! 102: sp = p->in.right; ! 103: t2 = sp->in.left; ! 104: t3 = sp->in.right; ! 105: /* now, put together again */ ! 106: p->in.left = sp; ! 107: sp->in.left = t1; ! 108: sp->in.right = t2; ! 109: p->in.right = t3; ! 110: } ! 111: if(o == PLUS && LO(p) == MINUS && RCON(p) && RCON(p->in.left) && ! 112: conval(p->in.right, MINUS, p->in.left->in.right)){ ! 113: zapleft: ! 114: RO(p->in.left) = FREE; ! 115: LO(p) = FREE; ! 116: p->in.left = p->in.left->in.left; ! 117: } ! 118: if( RCON(p) && LO(p)==o && RCON(p->in.left) && ! 119: conval( p->in.right, o, p->in.left->in.right ) ){ ! 120: goto zapleft; ! 121: } ! 122: else if( LCON(p) && RCON(p) && ! 123: conval( p->in.left, o, p->in.right ) ){ ! 124: zapright: ! 125: RO(p) = FREE; ! 126: p->in.left = makety( p->in.left, p->in.type, p->fn.cdim, p->fn.csiz ); ! 127: p->in.op = FREE; ! 128: return( clocal( p->in.left ) ); ! 129: } ! 130: /* FALL THROUGH */ ! 131: ! 132: case ASG MUL: ! 133: /* change muls to adds or shifts */ ! 134: ! 135: if( (o == MUL || o == ASG MUL) && ! 136: nncon(p->in.right) && (i=ispow2(RV(p)))>=0){ ! 137: if( i == 0 ) /* multiplication by 1 */ ! 138: goto zapright; ! 139: /* c2 will turn 'i << 1' into 'i + i' for us */ ! 140: else { ! 141: p->in.op = (asgop(o) ? ASG LS : LS); ! 142: o = p->in.op; ! 143: p->in.right->in.type = p->in.right->fn.csiz = INT; ! 144: RV(p) = i; ! 145: } ! 146: } ! 147: ! 148: /* change +'s of negative consts back to - */ ! 149: if( o==PLUS && nncon(p->in.right) && RV(p)<0 ){ ! 150: RV(p) = -RV(p); ! 151: o = p->in.op = MINUS; ! 152: } ! 153: /* FALL THROUGH */ ! 154: case ASG AND: ! 155: case ASG PLUS: ! 156: case ASG MINUS: ! 157: case RS: ! 158: case LS: ! 159: /* Operations with zero */ ! 160: if( nncon(p->in.right) && RV(p) == 0 ) { ! 161: if( o == MUL || o == ASG MUL || ! 162: o == AND || o == ASG AND ) { ! 163: if( asgop(o) ) ! 164: p->in.op = ASSIGN; ! 165: else if( optype(LO(p)) == LTYPE ) { ! 166: p->in.op = FREE; ! 167: LO(p) = FREE; ! 168: p = p->in.right; ! 169: } ! 170: else ! 171: p->in.op = COMOP; /* side effects */ ! 172: } ! 173: else if( o == PLUS || o == MINUS || ! 174: o == ASG PLUS || o == ASG MINUS || ! 175: o == OR || o == ER || ! 176: o == LS || o == RS ) ! 177: goto zapright; ! 178: } ! 179: if( o != LS && o != RS ) ! 180: break; ! 181: /* FALL THROUGH */ ! 182: ! 183: case ASG RS: ! 184: case ASG LS: ! 185: if( !ISUNSIGNED(p->in.left->in.type) ) ! 186: break; ! 187: if( p->in.right->in.op == ICON && ! 188: p->in.right->tn.lval < 0 ) { ! 189: /* ! 190: * Technically negative shifts are illegal ! 191: * but we can support them, at least with ! 192: * constants; you take potluck with variables. ! 193: */ ! 194: p->in.right->tn.lval = -p->in.right->tn.lval; ! 195: switch( o ){ ! 196: case LS: p->in.op = RS; break; ! 197: case ASG LS: p->in.op = ASG RS; break; ! 198: case RS: p->in.op = LS; break; ! 199: case ASG RS: p->in.op = ASG LS; break; ! 200: } ! 201: } ! 202: break; ! 203: ! 204: case ASG DIV: ! 205: case DIV: ! 206: if( nncon( p->in.right ) ){ ! 207: if( RV(p) == 0 ) uerror("division by zero"); ! 208: else if( RV(p) == 1 ) goto zapright; ! 209: /* Unsigned division by a power of two */ ! 210: else if( (i=ispow2(RV(p)))>=0 && ! 211: (ISUNSIGNED(p->in.left->in.type) || ! 212: ISUNSIGNED(p->in.right->in.type)) ){ ! 213: p->in.op = (asgop(o) ? ASG RS : RS); ! 214: p->in.right->in.type = p->in.right->fn.csiz = INT; ! 215: RV(p) = i; ! 216: } ! 217: } ! 218: break; ! 219: ! 220: case ASG MOD: ! 221: case MOD: ! 222: if( nncon(p->in.right) ){ ! 223: if( RV(p) == 0 ) uerror("modulus of zero"); ! 224: else if( RV(p) == 1 ){ /* mod by one gives zero */ ! 225: RV(p) = 0; ! 226: if( asgop(o) ) ! 227: p->in.op = ASSIGN; ! 228: else if( optype(LO(p)) == LTYPE ) { ! 229: p->in.op = FREE; ! 230: LO(p) = FREE; ! 231: p = p->in.right; ! 232: } ! 233: else ! 234: p->in.op = COMOP; /* side effects */ ! 235: } ! 236: else if ((i=ispow2(RV(p)))>=0 && ! 237: (ISUNSIGNED(p->in.left->in.type) || ! 238: ISUNSIGNED(p->in.right->in.type)) ){ ! 239: /* Unsigned mod by a power of two */ ! 240: p->in.op = (asgop(o) ? ASG AND : AND); ! 241: RV(p)--; ! 242: } ! 243: } ! 244: break; ! 245: ! 246: case EQ: ! 247: case NE: ! 248: case LT: ! 249: case LE: ! 250: case GT: ! 251: case GE: ! 252: case ULT: ! 253: case ULE: ! 254: case UGT: ! 255: case UGE: ! 256: if( !LCON(p) ) break; ! 257: ! 258: /* exchange operands */ ! 259: ! 260: sp = p->in.left; ! 261: p->in.left = p->in.right; ! 262: p->in.right = sp; ! 263: p->in.op = revrel[p->in.op - EQ ]; ! 264: break; ! 265: ! 266: } ! 267: ! 268: return(p); ! 269: } ! 270: ! 271: ispow2( c ) CONSZ c; { ! 272: register i; ! 273: if( c <= 0 || (c&(c-1)) ) return(-1); ! 274: for( i=0; c>1; ++i) c >>= 1; ! 275: return(i); ! 276: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.