Java IntExpr类代码示例

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private <F,T,TT extends Type<T>>
Expr makeIntegerCast(IntExpr castedExpr, IntegerType<F> from, TT to) throws Z3Exception {
  try {
    if(to instanceof BVIntegerType) {
      BVIntegerType<?> bvTo = (BVIntegerType<?>)to;
      return ctx.mkInt2BV(bvTo.getNumBits(), castedExpr);
    }
    if(to instanceof IntegerType) {
      Expr tmp = castedExpr;
      castedExpr = null; // prevent disposal
      return tmp;
    }
    if(to instanceof NumericType) {
      return ctx.mkInt2Real(castedExpr);
    }
    throw new IllegalStateException("Cannot handle integer cast to " + to);
  }
  finally {
    safeDispose(castedExpr);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private Expr makeArithmeticNumericCompound(NumericOperator op, ArithExpr left, ArithExpr right) throws Z3Exception {
  switch(op) {
  case PLUS:
    return ctx.mkAdd(left, right);
  case MINUS:
    return ctx.mkSub(left, right);
  case MUL:
    return ctx.mkMul(left, right);
  case DIV:
    return ctx.mkDiv(left, right);
  case REM:
    if(left instanceof IntExpr && right instanceof IntExpr)
      return ctx.mkRem((IntExpr)left, (IntExpr)right);
    return makeRealRemainder(left, right);
  default:
    throw new IllegalArgumentException("Cannot handle numeric operator " + op);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
public boolean equals(BinopExpr expr1, BinopExpr expr2){
	BoolExpr z3Formula1 = generate(expr1);
	BoolExpr z3Formula2 = generate(expr2);
	BoolExpr z3Formula = null;;
	try {
		BoolExpr lhs = ctx.MkImplies(z3Formula1, z3Formula2);
		BoolExpr rhs = ctx.MkImplies(z3Formula2, z3Formula1);
		z3Formula = ctx.MkAnd(new BoolExpr[]{lhs, rhs});
		Expr [] forall = new Expr[sootVarToZ3Var.size()];
		int i = 0;
		for(IntExpr var : sootVarToZ3Var.values()){
			forall[i] = var;
			i++;
		}
		z3Formula = ctx.MkForall(forall, z3Formula, 0, null, null, null, null);
	} catch (Z3Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	boolean ret = solve(z3Formula);
	return ret;
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private ArithExpr ensureArith(Expr expr, Type<?> type) throws Z3Exception {
  if(expr instanceof ArithExpr)
    return (ArithExpr)expr;
  
  if(expr instanceof BitVecExpr) {
    BVIntegerType<?> bvType = (BVIntegerType<?>)type;
    IntExpr intExp = makeBV2Int((BitVecExpr)expr, bvType);
    safeDispose(expr);
    return intExp;
  }
  
  throw new UnsupportedOperationException();
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
@Override
public <F,E> Expr visit(
    CastExpression<F,E> cast, Void data) {
  
  Expression<F> casted = cast.getCasted();
  Type<F> ft = casted.getType();
  Type<E> tt = cast.getType();
  
  if(ft.equals(tt))
    return visit(casted, null);
  
  Expr castedExpr = null;
  try {
    castedExpr = visit(casted, null);

    if(ft instanceof BVIntegerType) {
      return makeBitvectorCast((BitVecExpr)castedExpr, (BVIntegerType<F>)ft, tt);
    }
    if(ft instanceof IntegerType) {
      return makeIntegerCast((IntExpr)castedExpr, (IntegerType<F>)ft, tt);
    }
    if(ft instanceof RealType) {
      return makeRealCast((RealExpr)castedExpr, (NumericType<F>)ft, tt);
    }
    
    safeDispose(castedExpr);
    throw new IllegalStateException("Cannot handle cast from " + ft + " to " + tt);
  }
  catch(Z3Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private IntExpr makeReal2IntTrunc(ArithExpr real) throws Z3Exception {
  RealExpr rAlias = null;
  BoolExpr eq1 = null;
  IntExpr sign = null;
  IntExpr zero = null, minusOne = null, one = null;
  Expr ite = null;
  BoolExpr ltz = null;
  BoolExpr eq = null;
  RealExpr mul = null; 
  IntExpr r2i = null;
  try {
    rAlias = ctx.mkRealConst("__r2i" + count++);
    eq1 = ctx.mkEq(rAlias, real);
    solver.add(eq1);
    sign = ctx.mkIntConst("__sign" + count++);
    zero = ctx.mkInt(0);
    ltz = ctx.mkLt(rAlias, zero);
    one = ctx.mkInt(1);
    minusOne = ctx.mkInt(-1);
    ite = ctx.mkITE(ltz, minusOne, one);
    eq = ctx.mkEq(sign, ite);
    solver.add(eq);
    mul = (RealExpr)ctx.mkMul(sign, rAlias);
    r2i = ctx.mkReal2Int(mul);
    return (IntExpr)ctx.mkMul(sign, r2i);
  }
  finally {
    uncheckedDispose(rAlias, eq1, sign, zero, minusOne, one, ite, ltz, eq, mul, r2i);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private <F,T,TT extends Type<T>>
Expr makeRealCast(RealExpr castedExpr, NumericType<F> from, TT to) throws Z3Exception {
  try {
    if(to instanceof BVIntegerType) {
      BVIntegerType<?> bvTo = (BVIntegerType<?>)to;
      IntExpr intTmp = null;
      try {
        intTmp = makeReal2IntTrunc(castedExpr);
        return ctx.mkInt2BV(bvTo.getNumBits(), intTmp);
      }
      finally {
        uncheckedDispose(intTmp);
      }
    }
    if(to instanceof IntegerType) {
      return makeReal2IntTrunc(castedExpr);
    }
    if(to instanceof NumericType) {
      Expr tmp = castedExpr;
      castedExpr = null; // prevent disposal
      return tmp;
    }
    throw new IllegalStateException("Cannot handle integer cast to " + to);
  }
  finally {
    safeDispose(castedExpr);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
protected IntExpr getOrCreateIntVar(Variable<?> v) {
	Expr ret = this.variables.get(v);
	if (ret != null) {
		return (IntExpr) ret;
	}

	IntExpr var = createIntVar(v);
	this.variables.put(v, var);
	this.protect.add(var);
	this.own.add(var);

	return var;
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
public List<Long> evaluateSol(BinopExpr expr, BinopExpr a, Value ... unknown) {
	List<Long> ret = null;
	//("expr " + expr + " " + " a " + a);
	BoolExpr z3Formula = generate(expr);
	try {
		BoolExpr z3ForA = a==null? ctx.MkFalse() : generate(a);
		//negate a
		BoolExpr negA = ctx.MkNot(z3ForA);
		//("negA " + negA);
		z3Formula = ctx.MkAnd(new BoolExpr[]{z3Formula, negA});
		Solver solver = ctx.MkSolver();
		Params p = ctx.MkParams();
		p.Add("soft_timeout", timeout);
		solver.setParameters(p);
		solver.Assert(z3Formula);
		Status result = solver.Check();
		if(result.equals(Status.SATISFIABLE)){
			ret = new ArrayList<Long>();
			Model m = solver.Model();
			for(Value v : unknown){
				IntExpr res = (IntExpr)m.ConstInterp(sootVarToZ3Var.get(v));
				if(res.toString().contains("mod") || res.toString().contains("div")){
					System.out.println("Z3Formula  " + z3Formula);
					return null;
				}
				ret.add(Long.parseLong(res.toString()));
			}
		} else if (result.equals(Status.UNSATISFIABLE)){
			ret = new ArrayList<Long>();
		} else {
			//unknown
			System.out.println("Warning: " + result + " for " + z3Formula);
		}
	} catch (Z3Exception e) {
		e.printStackTrace();
	}
	return ret;
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
private <F,T,TT extends Type<T>>
Expr makeBitvectorCast(BitVecExpr castedExpr, BVIntegerType<F> from, TT to) throws Z3Exception {
  try {
    if(to instanceof BVIntegerType) {
      BVIntegerType<?> bvTo = (BVIntegerType<?>)to;
      if(from.getNumBits() == bvTo.getNumBits()) {
        Expr tmp = castedExpr;
        castedExpr = null; // prevent disposal
        return tmp;
      }
      int diff = bvTo.getNumBits() - from.getNumBits();
      if(diff > 0) {
        if(from.isSigned())
          return ctx.mkSignExt(diff, castedExpr);
        return ctx.mkZeroExt(diff, castedExpr);
      }
      return ctx.mkExtract(bvTo.getNumBits() - 1, 0, castedExpr);
    }
    if(to instanceof IntegerType) {
      //return ctx.mkBV2Int(castedExpr, from.isSigned());
      return makeBV2Int(castedExpr, from);
    }
    if(to instanceof RealType) {
      if(to instanceof FloatingPointType) {
        FloatingPointType<?> ft = (FloatingPointType<?>)to;
        int bitsAvail = ft.getSignificantBits() + 1;
        if(bitsAvail < from.getNumBits()) {
          BigInteger mask = BigInteger.valueOf(1L).shiftLeft(from.getNumBits() - bitsAvail).subtract(BigInteger.valueOf(1)).shiftLeft(bitsAvail);
          
          BoolExpr posCheck = null, negCheck = null;
          BoolExpr check = null;
          BoolExpr condCheck = null;
          
          BitVecExpr zero = null;
          BitVecExpr maskExpr = null;
          BitVecExpr andExpr = null;
          
          try {
            maskExpr = ctx.mkBV(mask.toString(), from.getNumBits());
            zero = ctx.mkBV(0, from.getNumBits());
            andExpr = ctx.mkBVAND(castedExpr, maskExpr);
            posCheck = ctx.mkEq(andExpr, zero);
            if(from.isSigned()) {
              negCheck = ctx.mkEq(andExpr, maskExpr);
              check = ctx.mkOr(posCheck, negCheck);
            }
            if(check != null)
              condCheck = ctx.mkOr(check, tainted);
            else
              condCheck = ctx.mkOr(posCheck, tainted);
            solver.add(condCheck);
          }
          finally {
            uncheckedDispose(posCheck, negCheck, check, zero, maskExpr, andExpr);
          }
        }
      }
      IntExpr intTmp = null;
      try {
        intTmp = makeBV2Int(castedExpr, from);
        return ctx.mkInt2Real(intTmp);
      }
      finally {
        uncheckedDispose(intTmp);
      }
    }
    throw new IllegalArgumentException("Cannot handle bitvector cast to " + to);
  }
  finally {
    safeDispose(castedExpr);
  }
}
 

import com.microsoft.z3.IntExpr; //导入依赖的package包/类
public SolverWrapperZ3() throws Z3Exception{
	Map<String, String> cfg = new HashMap<String, String>();
	ctx = new Context(cfg);
	sootVarToZ3Var = new HashMap<Value,IntExpr>();
}