![[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] / 40BSD / cmd / mip|
Return to optim.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / mip |
1.1 ! root 1: static char *sccsid ="%W% (Berkeley) %G%"; ! 2: # include "mfile1" ! 3: ! 4: # define SWAP(p,q) {sp=p; p=q; q=sp;} ! 5: # define RCON(p) (p->in.right->in.op==ICON) ! 6: # define RO(p) p->in.right->in.op ! 7: # define RV(p) p->in.right->tn.lval ! 8: # define LCON(p) (p->in.left->in.op==ICON) ! 9: # define LO(p) p->in.left->in.op ! 10: # define LV(p) p->in.left->tn.lval ! 11: ! 12: int oflag = 0; ! 13: ! 14: NODE * ! 15: fortarg( p ) NODE *p; { ! 16: /* fortran function arguments */ ! 17: ! 18: if( p->in.op == CM ){ ! 19: p->in.left = fortarg( p->in.left ); ! 20: p->in.right = fortarg( p->in.right ); ! 21: return(p); ! 22: } ! 23: ! 24: while( ISPTR(p->in.type) ){ ! 25: p = buildtree( UNARY MUL, p, NIL ); ! 26: } ! 27: return( optim(p) ); ! 28: } ! 29: ! 30: /* mapping relationals when the sides are reversed */ ! 31: short revrel[] ={ EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT }; ! 32: NODE * ! 33: optim(p) register NODE *p; { ! 34: /* local optimizations, most of which are probably machine independent */ ! 35: ! 36: register o, ty; ! 37: NODE *sp; ! 38: int i; ! 39: TWORD t; ! 40: ! 41: if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p); ! 42: if( oflag ) return(p); ! 43: ty = optype( o=p->in.op); ! 44: if( ty == LTYPE ) return(p); ! 45: ! 46: if( ty == BITYPE ) p->in.right = optim(p->in.right); ! 47: p->in.left = optim(p->in.left); ! 48: ! 49: /* collect constants */ ! 50: ! 51: switch(o){ ! 52: ! 53: case SCONV: ! 54: case PCONV: ! 55: return( clocal(p) ); ! 56: ! 57: case FORTCALL: ! 58: p->in.right = fortarg( p->in.right ); ! 59: break; ! 60: ! 61: case UNARY AND: ! 62: if( LO(p) != NAME ) cerror( "& error" ); ! 63: ! 64: if( !andable(p->in.left) ) return(p); ! 65: ! 66: LO(p) = ICON; ! 67: ! 68: setuleft: ! 69: /* paint over the type of the left hand side with the type of the top */ ! 70: p->in.left->in.type = p->in.type; ! 71: p->in.left->fn.cdim = p->fn.cdim; ! 72: p->in.left->fn.csiz = p->fn.csiz; ! 73: p->in.op = FREE; ! 74: return( p->in.left ); ! 75: ! 76: case UNARY MUL: ! 77: if( LO(p) != ICON ) break; ! 78: LO(p) = NAME; ! 79: goto setuleft; ! 80: ! 81: case MINUS: ! 82: if( !nncon(p->in.right) ) break; ! 83: RV(p) = -RV(p); ! 84: o = p->in.op = PLUS; ! 85: ! 86: case MUL: ! 87: case PLUS: ! 88: case AND: ! 89: case OR: ! 90: case ER: ! 91: /* commutative ops; for now, just collect constants */ ! 92: /* someday, do it right */ ! 93: if( nncon(p->in.left) || ( LCON(p) && !RCON(p) ) ) SWAP( p->in.left, p->in.right ); ! 94: /* make ops tower to the left, not the right */ ! 95: if( RO(p) == o ){ ! 96: NODE *t1, *t2, *t3; ! 97: t1 = p->in.left; ! 98: sp = p->in.right; ! 99: t2 = sp->in.left; ! 100: t3 = sp->in.right; ! 101: /* now, put together again */ ! 102: p->in.left = sp; ! 103: sp->in.left = t1; ! 104: sp->in.right = t2; ! 105: p->in.right = t3; ! 106: } ! 107: if(o == PLUS && LO(p) == MINUS && RCON(p) && RCON(p->in.left) && ! 108: conval(p->in.right, MINUS, p->in.left->in.right)){ ! 109: zapleft: ! 110: RO(p->in.left) = FREE; ! 111: LO(p) = FREE; ! 112: p->in.left = p->in.left->in.left; ! 113: } ! 114: if( RCON(p) && LO(p)==o && RCON(p->in.left) && conval( p->in.right, o, p->in.left->in.right ) ){ ! 115: goto zapleft; ! 116: } ! 117: else if( LCON(p) && RCON(p) && conval( p->in.left, o, p->in.right ) ){ ! 118: zapright: ! 119: RO(p) = FREE; ! 120: p->in.left = makety( p->in.left, p->in.type, p->fn.cdim, p->fn.csiz ); ! 121: p->in.op = FREE; ! 122: return( clocal( p->in.left ) ); ! 123: } ! 124: ! 125: /* change muls to shifts */ ! 126: ! 127: if( o==MUL && nncon(p->in.right) && (i=ispow2(RV(p)))>=0){ ! 128: if( i == 0 ){ /* multiplication by 1 */ ! 129: goto zapright; ! 130: } ! 131: o = p->in.op = LS; ! 132: p->in.right->in.type = p->in.right->fn.csiz = INT; ! 133: RV(p) = i; ! 134: } ! 135: ! 136: /* change +'s of negative consts back to - */ ! 137: if( o==PLUS && nncon(p->in.right) && RV(p)<0 ){ ! 138: RV(p) = -RV(p); ! 139: o = p->in.op = MINUS; ! 140: } ! 141: break; ! 142: ! 143: case DIV: ! 144: if( nncon( p->in.right ) && p->in.right->tn.lval == 1 ) goto zapright; ! 145: break; ! 146: ! 147: case EQ: ! 148: case NE: ! 149: case LT: ! 150: case LE: ! 151: case GT: ! 152: case GE: ! 153: case ULT: ! 154: case ULE: ! 155: case UGT: ! 156: case UGE: ! 157: if( !LCON(p) ) break; ! 158: ! 159: /* exchange operands */ ! 160: ! 161: sp = p->in.left; ! 162: p->in.left = p->in.right; ! 163: p->in.right = sp; ! 164: p->in.op = revrel[p->in.op - EQ ]; ! 165: break; ! 166: ! 167: } ! 168: ! 169: return(p); ! 170: } ! 171: ! 172: ispow2( c ) CONSZ c; { ! 173: register i; ! 174: if( c <= 0 || (c&(c-1)) ) return(-1); ! 175: for( i=0; c>1; ++i) c >>= 1; ! 176: return(i); ! 177: } ! 178: ! 179: nncon( p ) NODE *p; { ! 180: /* is p a constant without a name */ ! 181: return( p->in.op == ICON && p->tn.rval == NONAME ); ! 182: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.