public Z3BoolExpr MkTest(Z3Expr t, Term type) { Contract.Assert(t != null && t.Sort.Equals(Representation)); Term intr; var unn = Owner.GetIntersection(Type, type, out intr); if (intr == null) { return(Context.MkFalse()); } else if (intr == Type) { return(Context.MkTrue()); } Z3BoolExpr test = null; var nat = (Z3IntExpr)UnboxingFun.Apply(t); if (unn.Contains(Index.SymbolTable.GetSortSymbol(BaseSortKind.PosInteger))) { test = test.Or(Context, nat.NEq(Context, Context.MkInt(0))); } var iNat = MkIntCoercion(t); foreach (var r in unn.RangeMembers) { test = test.Or( Context, iNat.Ge( Context, Context.MkInt(r.Key.ToString())).And( Context, iNat.Le(Context, Context.MkInt(r.Value.ToString())))); } return(test); }
public Z3Expr MkCoercion(Z3Expr t) { var srcTE = Owner.GetEmbedding(t.Sort); if (srcTE == this) { return(t); } Term intr; var unn = Owner.GetIntersection(srcTE.GetSubtype(t), Type, out intr); if (unn == null) { return(DefaultMember.Item2); } switch (srcTE.Kind) { case TypeEmbeddingKind.Enum: return(MkCoercion(t, unn, (EnumEmbedding)srcTE)); case TypeEmbeddingKind.Real: return(MkCoercion(t, unn, (RealEmbedding)srcTE)); case TypeEmbeddingKind.Singleton: return(MkCoercion(t, unn, (SingletonEmbedding)srcTE)); case TypeEmbeddingKind.String: return(MkCoercion(t, unn, (StringEmbedding)srcTE)); case TypeEmbeddingKind.Union: return(MkCoercion(t, unn, (UnionEmbedding)srcTE)); default: throw new NotImplementedException(); } }
public Term MkGround(Z3Expr t, Term[] args) { Contract.Assert(t != null); Contract.Assert(args == null || args.Length == 0); Contract.Assert(t.FuncDecl.Equals(BoxingFun)); var n = ((Z3IntNum)t.Args[0]).BigInteger; bool wasAdded; if (n.IsZero) { return(Index.MkCnst(Rational.One, out wasAdded)); } else if (n.Sign > 0) { n = 2 * n; return(Index.MkCnst(new Rational(n, System.Numerics.BigInteger.One), out wasAdded)); } else { n = (-2 * n) + 1; return(Index.MkCnst(new Rational(n, System.Numerics.BigInteger.One), out wasAdded)); } }
public void Test_Runner_Mem_3() { Tools tools = this.CreateTools(); // test is slow (9min - 17min) tools.StateConfig.Set_All_Off(); tools.StateConfig.RAX = true; tools.StateConfig.RBX = true; tools.StateConfig.RCX = true; tools.StateConfig.Mem = true; tools.Quiet = true; bool logToDisplay2 = false;// logToDisplay; string programStr = " mov qword ptr[0], 10 " + Environment.NewLine + " mov qword ptr[10], 20 " + Environment.NewLine + " mov rbx, qword ptr [rax] " + Environment.NewLine + " mov rcx, qword ptr [rbx] "; StaticFlow sFlow = new StaticFlow(tools); sFlow.Update(programStr); DynamicFlow dFlow = Runner.Construct_DynamicFlow_Backward(sFlow, tools); State state0 = dFlow.Create_States_Before(0, 0); State state = dFlow.EndState; Microsoft.Z3.Expr rax = state0.Create(Rn.RAX).Translate(state.Ctx); state.Frozen = false; state.Add(new BranchInfo(state.Ctx.MkEq(rax, state.Ctx.MkBV(0, 64)), true)); if (logToDisplay2) { Console.WriteLine("Forward:\n" + state); } TestTools.AreEqual(Rn.RAX, 0, state); TestTools.AreEqual(Rn.RBX, 10, state); TestTools.AreEqual(Rn.RCX, 20, state); }
public Z3BoolExpr MkTest(Z3Expr t, Term type) { Term intr; var unn = Owner.GetIntersection(Type, type, out intr); var st = (Z3Expr)t; if (intr == null) { return(Context.MkFalse()); } else if (intr == Type) { return(Context.MkTrue()); } Z3BoolExpr test = null; BaseCnstSymb bc; foreach (var e in unn.NonRangeMembers) { if (e.Kind != SymbolKind.BaseCnstSymb) { continue; } bc = (BaseCnstSymb)e; if (bc.CnstKind != CnstKind.String) { continue; } test = test.Or(Context, st.Eq(Context, MkGround(e, null))); } return(test); }
public Z3Expr MkCoercion(Z3Expr t) { var srcTE = Owner.GetEmbedding(t.Sort); if (srcTE == this) { return(t); } Term intr; var unn = Owner.GetIntersection(srcTE.GetSubtype(t), Type, out intr); if (unn == null) { return(DefaultMember.Item2); } switch (srcTE.Kind) { case TypeEmbeddingKind.Enum: case TypeEmbeddingKind.Natural: case TypeEmbeddingKind.Integer: case TypeEmbeddingKind.PosInteger: case TypeEmbeddingKind.NegInteger: case TypeEmbeddingKind.IntRange: case TypeEmbeddingKind.Real: case TypeEmbeddingKind.String: case TypeEmbeddingKind.Singleton: case TypeEmbeddingKind.Constructor: case TypeEmbeddingKind.Union: return(MkCoercion(t, unn, srcTE)); default: throw new NotImplementedException(); } }
public Term GetSubtype(Z3Expr t) { Contract.Assert(t != null && t.Sort.Equals(Representation)); return(Type); }
public Term MkGround(Z3Expr t, Term[] args) { Contract.Assert(args == null || args.Length == 0); return(Value); }
public Z3BoolExpr MkTest(Z3Expr t, Term type) { return(Index.IsGroundMember(type, Value) ? Context.MkTrue() : Context.MkFalse()); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, RealEmbedding te) { return(MkPosCoercion(Context.MkReal2Int((Z3.RealExpr)t))); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, IntRangeEmbedding te) { return(MkPosCoercion(te.MkIntCoercion(t))); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, SingletonEmbedding te) { return(Context.MkInt(((Rational)((BaseCnstSymb)te.Value.Symbol).Raw).Numerator.ToString())); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, SingletonEmbedding te) { return(MkGround(te.Value.Symbol, null)); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, SingletonEmbedding te) { var val = ((Rational)((BaseCnstSymb)te.Value.Symbol).Raw).Numerator - Lower; return(BoxingFun.Apply(Context.MkBV(val.ToString(), bvSort.Size))); }
/// <summary> /// Returns an encoding of this term, possibly after applying some normalizing rewrites. /// </summary> public Z3Expr GetTerm(Term t, out Term normalizedTerm) { Contract.Requires(t != null); normalizedTerm = Normalize(t); Z3Expr enc, encp; if (encodings.TryFindValue(normalizedTerm, out enc)) { return(enc); } int i; bool wasAdded; ITypeEmbedding typEmb; ConstructorEmbedding conEmb; return(normalizedTerm.Compute <Z3Expr>( (x, s) => { if (encodings.ContainsKey(x) || x.Groundness == Groundness.Ground) { return null; } else { return x.Args; } }, (x, ch, s) => { if (encodings.TryFindValue(x, out encp)) { return encp; } else if (x.Groundness == Groundness.Ground) { typEmb = Solver.TypeEmbedder.ChooseRepresentation(x); encp = Solver.TypeEmbedder.MkGround(x, typEmb); encodings.Add(x, encp); return encp; } //// x must be non-ground. Because variables are already encoded, then x should not be a variable Contract.Assert(!x.Symbol.IsVariable); if (x.Symbol.IsDataConstructor) { if (x.Symbol.Kind == SymbolKind.ConSymb) { conEmb = (ConstructorEmbedding)Solver.TypeEmbedder.GetEmbedding( Solver.Index.MkApply(((ConSymb)x.Symbol).SortSymbol, TermIndex.EmptyArgs, out wasAdded)); } else { conEmb = (ConstructorEmbedding)Solver.TypeEmbedder.GetEmbedding( Solver.Index.MkApply(((MapSymb)x.Symbol).SortSymbol, TermIndex.EmptyArgs, out wasAdded)); } i = 0; var args = new Z3Expr[x.Symbol.Arity]; foreach (var a in ch) { typEmb = Solver.TypeEmbedder.GetEmbedding(conEmb.Z3Constructor.ConstructorDecl.Domain[i]); args[i++] = typEmb.MkCoercion(a); } encp = conEmb.MkGround(x.Symbol, args); encodings.Add(x, encp); return encp; } else { throw new NotImplementedException(); } })); }
public static Z3BoolExpr NEq(this Z3Expr expr1, Z3Context context, Z3Expr expr2) { Contract.Requires(expr1 != null && expr2 != null); return(context.MkNot(context.MkEq(expr1, expr2))); }
public static Z3Expr Ite(this Z3BoolExpr cond, Z3Context context, Z3Expr ifTrue, Z3Expr ifFalse) { Contract.Assert(cond != null && ifTrue != null && ifFalse != null); return(context.MkITE(cond, ifTrue, ifFalse)); }
public Term MkGround(Z3Expr t, Term[] args) { Contract.Assert(t != null && t.FuncDecl.Range == Representation); Contract.Assert(args != null && args.Length == 1); return(args[0]); }
public Z3BoolExpr MkTest(Z3Expr t, Term type) { ///// Produces a test of the form. //// ite(isBox_T(t), Test_T(t), ...). Term intr; var unn = Owner.GetIntersection(Type, type, out intr); if (intr == null) { return(Context.MkFalse()); } else if (intr == Type) { return(Context.MkTrue()); } bool wasAdded; Z3Con boxCon; Z3Fun unbox, tester; Z3BoolExpr boxTest; ITypeEmbedding te; Term subtypeTrm; MutableTuple <Z3Con, Term> subtype; Z3BoolExpr iteTest = Context.MkFalse(); //// For non-user sorts, want to project the type along the boxed type, so the boxed type //// can decide how to encode the test of this projection. Map <Z3Sort, MutableTuple <Z3Con, Term> > subtypes = new Map <Z3Sort, MutableTuple <Z3Con, Term> >((x, y) => ((int)x.Id) - ((int)y.Id)); foreach (var s in unn.NonRangeMembers) { boxCon = GetBoxer(s); Contract.Assert(boxCon != null); unbox = boxCon.AccessorDecls[0]; if (s.Kind == SymbolKind.UserSortSymb) { tester = boxCon.TesterDecl; te = Owner.GetEmbedding(unbox.Range); boxTest = (Z3BoolExpr)tester.Apply(t); subtypeTrm = Index.MkApply(s, TermIndex.EmptyArgs, out wasAdded); iteTest = (Z3BoolExpr)boxTest.Ite(Context, te.MkTest(unbox.Apply(t), subtypeTrm), iteTest); } else { if (!subtypes.TryFindValue(unbox.Range, out subtype)) { subtype = new MutableTuple <Z3Con, Term>( boxCon, Index.MkApply(s, TermIndex.EmptyArgs, out wasAdded)); subtypes.Add(unbox.Range, subtype); } else { subtype.Item2 = Index.MkApply( Index.TypeUnionSymbol, new Term[] { Index.MkApply(s, TermIndex.EmptyArgs, out wasAdded), subtype.Item2 }, out wasAdded); } } } foreach (var kv in unn.RangeMembers) { subtypeTrm = Index.MkApply( Index.RangeSymbol, new Term[] { Index.MkCnst(new Rational(kv.Key, BigInteger.One), out wasAdded), Index.MkCnst(new Rational(kv.Value, BigInteger.One), out wasAdded) }, out wasAdded); foreach (var bc in GetBoxers(kv.Key, kv.Value)) { unbox = bc.AccessorDecls[0]; if (!subtypes.TryFindValue(unbox.Range, out subtype)) { subtype = new MutableTuple <Z3Con, Term>(bc, subtypeTrm); subtypes.Add(unbox.Range, subtype); } else { subtype.Item2 = Index.MkApply( Index.TypeUnionSymbol, new Term[] { subtypeTrm, subtype.Item2 }, out wasAdded); } } } foreach (var kv in subtypes) { boxCon = kv.Value.Item1; Contract.Assert(boxCon != null); unbox = boxCon.AccessorDecls[0]; tester = boxCon.TesterDecl; te = Owner.GetEmbedding(unbox.Range); boxTest = (Z3BoolExpr)tester.Apply(t); iteTest = (Z3BoolExpr)boxTest.Ite(Context, te.MkTest(unbox.Apply(t), kv.Value.Item2), iteTest); } return(iteTest); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, UnionEmbedding te) { return(CreationFun.Apply()); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, IntegerEmbedding te) { return(Context.MkInt2Real((Z3.IntExpr)t)); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, IntegerEmbedding te) { return(MkPosCoercion((Z3IntExpr)t)); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, RealEmbedding te) { return(BoxingFun.Apply( ((Z3IntExpr)Context.MkSub(Context.MkReal2Int((Z3RealExpr)t), Context.MkInt(Lower.ToString()))).Int2BV(Context, bvSort.Size))); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, NegIntegerEmbedding te) { return(te.MkIntCoercion(t)); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, UnionEmbedding te) { Z3Expr unbox; //// If the union contains real, then it cannot contain other integral numerics. var test = te.MkTestAndUnbox(Index.SymbolTable.GetSortSymbol(BaseSortKind.Real), t, out unbox); if (test != null) { return(test.Ite( Context, MkCoercion(unbox, unn, (RealEmbedding)Owner.GetEmbedding(BaseSortKind.Real)), DefaultMember.Item2)); } //// If the union contains int, then it cannot contain other integral numerics. test = te.MkTestAndUnbox(Index.SymbolTable.GetSortSymbol(BaseSortKind.Integer), t, out unbox); if (test != null) { return(test.Ite( Context, MkCoercion(unbox, unn, (IntegerEmbedding)Owner.GetEmbedding(BaseSortKind.Integer)), DefaultMember.Item2)); } //// Otherwise unn may contain subsorts of Integer or integer ranges. //// First handle the base subsorts var coercions = DefaultMember.Item2; test = te.MkTestAndUnbox(Index.SymbolTable.GetSortSymbol(BaseSortKind.Natural), t, out unbox); if (test != null) { coercions = test.Ite( Context, MkCoercion(unbox, unn, (NaturalEmbedding)Owner.GetEmbedding(BaseSortKind.Natural)), coercions); } test = te.MkTestAndUnbox(Index.SymbolTable.GetSortSymbol(BaseSortKind.PosInteger), t, out unbox); if (test != null) { coercions = test.Ite( Context, MkCoercion(unbox, unn, (PosIntegerEmbedding)Owner.GetEmbedding(BaseSortKind.PosInteger)), coercions); } test = te.MkTestAndUnbox(Index.SymbolTable.GetSortSymbol(BaseSortKind.NegInteger), t, out unbox); if (test != null) { coercions = test.Ite( Context, MkCoercion(unbox, unn, (NegIntegerEmbedding)Owner.GetEmbedding(BaseSortKind.NegInteger)), coercions); } //// Additionally, there may be integer ranges. Z3BoolExpr[] tests; Z3Expr[] unboxeds; ITypeEmbedding tep; foreach (var kv in unn.RangeMembers) { tests = te.MkTestAndUnbox(kv.Key, kv.Value, t, out unboxeds); for (int i = 0; i < tests.Length; ++i) { test = tests[i]; unbox = unboxeds[i]; tep = Owner.GetEmbedding(unbox.Sort); switch (tep.Kind) { case TypeEmbeddingKind.IntRange: coercions = test.Ite( Context, MkCoercion(unbox, unn, (IntRangeEmbedding)tep), coercions); break; case TypeEmbeddingKind.Singleton: coercions = test.Ite( Context, MkCoercion(unbox, unn, (SingletonEmbedding)tep), coercions); break; default: throw new NotImplementedException(); } } } return(coercions); }
private Z3Expr MkCoercion(Z3Expr t, AppFreeCanUnn unn, IntRangeEmbedding te) { return(Context.MkInt2Real(te.MkIntCoercion(t))); }