public void nestedNegs(int depth) { var pair = GetVarAndIdExpr("foo", BasicType.GetBvType(8)); var variable = pair.Item1; var id = pair.Item2; var cfb = GetConstantFoldingBuilder(); Expr result = id; for (int i = 0; i < depth; ++i) { result = cfb.BVNEG(result); CheckIsBvType(result, 8); } if (depth % 2 == 0) { Assert.AreSame(id, result); } else { var asBvNeg = ExprUtil.AsBVNEG(result); Assert.IsNotNull(asBvNeg); Assert.AreSame(id, asBvNeg.Args[0]); } }
public void nestedBVEXTRACTVariableMiddle(int bitWidth) { Assert.IsTrue(bitWidth >= 3 && (bitWidth % 2 == 1)); var cfb = GetConstantFoldingBuilder(); var id = GetVarAndIdExpr("x", BasicType.GetBvType(bitWidth)).Item2; Expr result = id; // Keep peeling off the least significant bit and the most significant bit // until we're only left the middle bit in the original "id" for (int count = 0; count < bitWidth / 2; ++count) { int topBit = result.Type.BvBits - 1; result = cfb.BVEXTRACT(result, topBit, 1); CheckIsBvType(result, bitWidth - (2 * (count + 1))); } var asBvExtract = ExprUtil.AsBVEXTRACT(result); Assert.IsNotNull(asBvExtract); CheckIsBvType(asBvExtract, 1); // Check there is only a single BvExtractExpr Assert.AreSame(id, asBvExtract.Bitvector); var middleBitIndex = bitWidth / 2; Assert.AreEqual(middleBitIndex + 1, asBvExtract.End); Assert.AreEqual(middleBitIndex, asBvExtract.Start); }
public void nestedBVEXTRACTConstant(int initialValue, int bitWidth, bool bitIsTrue) { var cfb = GetConstantFoldingBuilder(); var constant = cfb.ConstantBV(initialValue, bitWidth); Expr result = constant; // Keep peeling off the least significant bit until we're only left // with the most significant bit for (int count = 0; count < bitWidth - 1; ++count) { int topBitPlusOne = bitWidth - count; result = cfb.BVEXTRACT(result, topBitPlusOne, 1); } var asLit = ExprUtil.AsLiteral(result); Assert.IsNotNull(asLit); CheckIsBvType(asLit, 1); if (bitIsTrue) { Assert.AreEqual(Microsoft.Basetypes.BigNum.FromInt(1), asLit.asBvConst.Value); } else { Assert.AreEqual(Microsoft.Basetypes.BigNum.FromInt(0), asLit.asBvConst.Value); } }
public void nestedBVEXTRACTVariableEnd(int bitWidth) { var cfb = GetConstantFoldingBuilder(); var id = GetVarAndIdExpr("x", BasicType.GetBvType(bitWidth)).Item2; Expr result = id; // Keep peeling off the least significant bit until we're only left // with the most significant bit for (int count = 0; count < bitWidth - 1; ++count) { int topBitPlusOne = bitWidth - count; result = cfb.BVEXTRACT(result, topBitPlusOne, 1); CheckIsBvType(result, bitWidth - count - 1); } var asBvExtract = ExprUtil.AsBVEXTRACT(result); Assert.IsNotNull(asBvExtract); CheckIsBvType(asBvExtract, 1); // Check there is only a single BvExtractExpr Assert.AreSame(id, asBvExtract.Bitvector); Assert.AreEqual(bitWidth, asBvExtract.End); Assert.AreEqual(bitWidth - 1, asBvExtract.Start); }
public bool RunOn(Microsoft.Boogie.Program prog, PassInfo passInfo) { var blocks = prog.Blocks(); bool changed = false; foreach (var block in blocks) { var newCmds = new List <Cmd>(); foreach (var cmd in block.Cmds) { if (cmd is AssumeCmd) { var assumeCmd = cmd as AssumeCmd; if (ExprUtil.IsTrue(assumeCmd.Expr)) { // This is a trivial assume Console.WriteLine("Removing trivial assume true on line {0}", assumeCmd.tok.line); changed = true; continue; } } // Add the existing command to the list if we want to keep it newCmds.Add(cmd); } if (block.cmds.Count > newCmds.Count) { // Assign new list if necessary block.Cmds = newCmds; } } return(changed); }
public void SymbolicStoreSameValue(int depth) { var cfb = GetConstantFoldingBuilder(); var map = GetMapVariable("m", BasicType.Int, BasicType.Int, BasicType.Int).Item1; var idx0 = GetVarAndIdExpr("idx0", BasicType.Int).Item2; var idx1 = GetVarAndIdExpr("idx0", BasicType.Int).Item2; var id = GetVarAndIdExpr("value", BasicType.Int).Item2; Expr result = map; // Writes to the same concrete location should get folded for (int index = 0; index < depth; ++index) { var oldResult = result; result = cfb.MapStore(result, id, idx0, idx1); CheckIsMapType(result, BasicType.Int, BasicType.Int, BasicType.Int); if (index > 0) { // The same location with the same value is repeatedly written to // so we shouldn't create a new node for this case. Assert.AreSame(oldResult, result); } } // Check we have a single map store var asMapStore = ExprUtil.AsMapStore(result); Assert.AreSame(map, asMapStore.Args[0]); // map written to Assert.AreEqual(idx0, asMapStore.Args[1]); // first index Assert.AreEqual(idx1, asMapStore.Args[2]); // second index Assert.AreSame(id, asMapStore.Args[3]); // value stored }
public void MULAssociativityAddNearbyConstants() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; var x = GetVarAndIdExpr("x", BasicType.GetBvType(8)).Item2; Expr foldedResult = x; Expr unfoldedResult = foldedResult; for (int index = 2; index <= 4; ++index) { foldedResult = cfb.BVMUL(cfb.ConstantBV(index, 8), foldedResult); unfoldedResult = sb.BVMUL(sb.ConstantBV(index, 8), unfoldedResult); CheckIsBvType(foldedResult, 8); CheckIsBvType(unfoldedResult, 8); } Assert.AreEqual("BVMUL8(24bv8, x)", foldedResult.ToString()); Assert.AreEqual("BVMUL8(4bv8, BVMUL8(3bv8, BVMUL8(2bv8, x)))", unfoldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var foldedTopAsNAry = ExprUtil.AsBVMUL(foldedResult); // Check the constant is the top left argument var topLeftConstant = ExprUtil.AsLiteral(foldedTopAsNAry.Args[0]); Assert.IsNotNull(topLeftConstant); CheckIsBvType(topLeftConstant, 8); Assert.AreEqual(24, topLeftConstant.asBvConst.Value.ToInt); }
public void MulAssociativityPropagateConstantUp() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; Expr foldedResult = sb.ConstantBV(1, 8); Expr unfoldedResult = foldedResult; for (int index = 0; index < 3; ++index) { var x = GetVarAndIdExpr("x" + index.ToString(), BasicType.GetBvType(8)).Item2; foldedResult = cfb.BVMUL(x, foldedResult); unfoldedResult = sb.BVMUL(x, unfoldedResult); CheckIsBvType(foldedResult, 8); CheckIsBvType(unfoldedResult, 8); } Assert.AreEqual("BVMUL8(1bv8, BVMUL8(x2, BVMUL8(x1, x0)))", foldedResult.ToString()); Assert.AreEqual("BVMUL8(x2, BVMUL8(x1, BVMUL8(x0, 1bv8)))", unfoldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var foldedTopAsNAry = ExprUtil.AsBVMUL(foldedResult); // Check the constant is the top left argument var topLeftConstant = ExprUtil.AsLiteral(foldedTopAsNAry.Args[0]); Assert.IsNotNull(topLeftConstant); CheckIsBvType(topLeftConstant, 8); Assert.AreEqual(1, topLeftConstant.asBvConst.Value.ToInt); }
public void IsFalseWithFalse() { var sb = GetSimpleBuilder(); var e = sb.False; Assert.IsTrue(ExprUtil.IsFalse(e)); }
public void BVORAssociativityPropagateConstantUp() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; Expr foldedResult = sb.ConstantBV(5, 4); Expr unfoldedResult = foldedResult; for (int index = 0; index < 3; ++index) { var x = GetVarAndIdExpr("x" + index.ToString(), BasicType.GetBvType(4)).Item2; foldedResult = cfb.BVOR(x, foldedResult); unfoldedResult = sb.BVOR(x, unfoldedResult); CheckIsBvType(foldedResult, 4); CheckIsBvType(unfoldedResult, 4); } Assert.AreEqual("BVOR4(x2, BVOR4(x1, BVOR4(x0, 5bv4)))", unfoldedResult.ToString()); Assert.AreEqual("BVOR4(5bv4, BVOR4(x2, BVOR4(x1, x0)))", foldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var topAsBVOR = ExprUtil.AsBVOR(foldedResult); Assert.IsNotNull(topAsBVOR); // Check the constant is the top left argument Assert.IsNotNull(ExprUtil.AsLiteral(topAsBVOR.Args[0])); }
public void NoFoldSymbolicStoreSameValueAtDifferentLocations(int depth) { var builders = GetSimpleAndConstantFoldingBuilder(); var sb = builders.Item1; var cfb = builders.Item2; var map = GetMapVariable("m", BasicType.Int, BasicType.Int, BasicType.Int).Item1; var id = GetVarAndIdExpr("value", BasicType.Int).Item2; Expr result = map; Expr resultSb = map; // Writes to different concrete locations should not be folded for (int index = 0; index < depth; ++index) { var oldResult = result; var unconstrainedIndex = GetVarAndIdExpr("idx" + index.ToString(), BasicType.Int).Item2; result = cfb.MapStore(result, id, unconstrainedIndex, unconstrainedIndex); resultSb = sb.MapStore(resultSb, id, unconstrainedIndex, unconstrainedIndex); CheckIsMapType(result, BasicType.Int, BasicType.Int, BasicType.Int); CheckIsMapType(resultSb, BasicType.Int, BasicType.Int, BasicType.Int); Assert.AreNotSame(oldResult, result); } // Check we have a single map store Assert.IsNotNull(ExprUtil.AsMapStore(result)); Assert.AreEqual(resultSb, result); }
public void BVANDAssociativityAddNearbyConstants() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; var x = GetVarAndIdExpr("x", BasicType.GetBvType(4)).Item2; Expr foldedResult = x; Expr unfoldedResult = foldedResult; for (int index = 1; index <= 3; ++index) { foldedResult = cfb.BVAND(cfb.ConstantBV(5, 4), foldedResult); unfoldedResult = sb.BVAND(sb.ConstantBV(5, 4), unfoldedResult); CheckIsBvType(foldedResult, 4); CheckIsBvType(unfoldedResult, 4); } Assert.AreEqual("BVAND4(5bv4, BVAND4(5bv4, BVAND4(5bv4, x)))", unfoldedResult.ToString()); Assert.AreEqual("BVAND4(5bv4, x)", foldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var topAsBVAND = ExprUtil.AsBVAND(foldedResult); Assert.IsNotNull(topAsBVAND); // Check the constant is the top left argument Assert.IsNotNull(ExprUtil.AsLiteral(topAsBVAND.Args[0]));; }
public void ConcreteStoreDifferentValues(int depth) { var cfb = GetConstantFoldingBuilder(); var map = GetMapVariable("m", BasicType.Int, BasicType.Int, BasicType.Int).Item1; Expr id = null; Expr result = map; // Writes to the same concrete location should get folded, but here // the value being written each is different so we need to make a new node each time for (int index = 0; index < depth; ++index) { id = GetVarAndIdExpr("value" + index.ToString(), BasicType.Int).Item2; var oldResult = result; result = cfb.MapStore(result, id, cfb.ConstantInt(0), cfb.ConstantInt(1)); Assert.AreNotSame(oldResult, result); CheckIsMapType(result, BasicType.Int, BasicType.Int, BasicType.Int); } // Check we have a single map store var asMapStore = ExprUtil.AsMapStore(result); Assert.AreSame(map, asMapStore.Args[0]); // map written to Assert.AreEqual(cfb.ConstantInt(0), asMapStore.Args[1]); // first index Assert.AreEqual(cfb.ConstantInt(1), asMapStore.Args[2]); // second index Assert.AreSame(id, asMapStore.Args[3]); // value stored }
public void AddAssociativityAddNearbyConstants() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; var x = GetVarAndIdExpr("x", BasicType.Int).Item2; Expr foldedResult = x; Expr unfoldedResult = foldedResult; for (int index = 2; index <= 4; ++index) { foldedResult = cfb.Mul(cfb.ConstantInt(index), foldedResult); unfoldedResult = sb.Mul(sb.ConstantInt(index), unfoldedResult); CheckIsInt(foldedResult); CheckIsInt(unfoldedResult); } Assert.AreEqual("24 * x", foldedResult.ToString()); Assert.AreEqual("4 * 3 * 2 * x", unfoldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var asMul = ExprUtil.AsMul(foldedResult); Assert.IsNotNull(asMul); // Check the constant is the top left argument Assert.IsNotNull(ExprUtil.AsLiteral(asMul.Args[0])); }
public void MulAssociativityPropagateConstantUp() { var builderPair = GetSimpleAndConstantFoldingBuilder(); var sb = builderPair.Item1; var cfb = builderPair.Item2; Expr foldedResult = sb.ConstantInt(2); Expr unfoldedResult = foldedResult; for (int index = 0; index < 3; ++index) { var x = GetVarAndIdExpr("x" + index.ToString(), BasicType.Int).Item2; foldedResult = cfb.Mul(x, foldedResult); unfoldedResult = sb.Mul(x, unfoldedResult); CheckIsInt(foldedResult); CheckIsInt(unfoldedResult); } Assert.AreEqual("2 * x2 * x1 * x0", foldedResult.ToString()); Assert.AreEqual("x2 * x1 * x0 * 2", unfoldedResult.ToString()); Assert.IsFalse(foldedResult.Equals(unfoldedResult)); var asMul = ExprUtil.AsMul(foldedResult); Assert.IsNotNull(asMul); // Check the constant is the top left argument Assert.IsNotNull(ExprUtil.AsLiteral(asMul.Args[0])); }
public void FollowElse() { p = LoadProgramFrom(@" procedure main() { var a:int; var b:int; var old_b:int; old_b := b; assume a < 0; b := if a > 0 then 1 else b; assert {:symbooglix_bp ""follow_else""} b == old_b; } ", "test.bpl"); Run(0, 1, (object sender, Executor.BreakPointEventArgs e) => { Assert.AreEqual("follow_else", e.Name); Executor executor = sender as Executor; Assert.IsNotNull(executor); var pair = executor.CurrentState.GetInScopeVariableAndExprByName("b"); var id = ExprUtil.AsIdentifer(pair.Value); Assert.IsNotNull(id); Assert.IsInstanceOf <SymbolicVariable>(id.Decl); }); }
public void RequiresEqualityConcretisesOldExpr() { p = LoadProgramFrom(@" var g:int; procedure main() modifies g; requires g == 0; { // At this point make sure ""g"" is concrete but // also make sure that the old(g) is also concrete assert {:symbooglix_bp ""check""} true; g := 2; assert old(g + 1 -1) == 0; } ", "test.bpl"); e = GetExecutor(p, new DFSStateScheduler(), GetSolver()); int bpCounter = 0; e.BreakPointReached += delegate(object sender, Executor.BreakPointEventArgs eventArgs) { ++bpCounter; switch (eventArgs.Name) { case "check": // Check that the global "g" is concrete var p1 = e.CurrentState.GetInScopeVariableAndExprByName("g"); var asLit = ExprUtil.AsLiteral(p1.Value); Assert.IsNotNull(asLit); Assert.IsTrue(asLit.isBigNum); Assert.AreEqual(Microsoft.Basetypes.BigNum.FromInt(0), asLit.asBigNum); // Now check that old expr for "g" also was concretised var oldVars = e.CurrentState.GetCurrentStackFrame().Impl.GetOldExprVariables(); Assert.AreEqual(1, oldVars.Count); var gVariable = oldVars[0]; Assert.AreEqual("g", gVariable.Name); var oldExprForG = e.CurrentState.GetCurrentStackFrame().OldGlobals[gVariable]; var oldExprForGAsLit = ExprUtil.AsLiteral(oldExprForG); Assert.IsNotNull(oldExprForGAsLit); Assert.IsTrue(oldExprForGAsLit.isBigNum); Assert.AreEqual(Microsoft.Basetypes.BigNum.ZERO, oldExprForGAsLit.asBigNum); break; default: Assert.Fail("Unexpected break point"); break; } }; var tc = new TerminationCounter(); tc.Connect(e); e.Run(GetMain(p)); Assert.AreEqual(1, bpCounter); Assert.AreEqual(1, tc.Sucesses); Assert.AreEqual(0, tc.NumberOfFailures); }
public void IsFalseWithWithExpr() { var sb = GetSimpleBuilder(); var v = GetVarAndIdExpr("foo", BasicType.Bool).Item2; var e = sb.Eq(v, sb.False); Assert.IsFalse(ExprUtil.IsFalse(e)); }
public void simpleFalse() { var cfb = GetConstantFoldingBuilder(); var result = cfb.Not(cfb.False); CheckIsBoolType(result); Assert.IsTrue(ExprUtil.IsTrue(result)); }
internal void SendDropView(string schema, string name, bool ifExists) { var builder = new DropView(); builder.Collection = ExprUtil.BuildCollection(schema, name); builder.IfExists = ifExists; _writer.Write((int)ClientMessages.Types.Type.CrudDropView, builder); }
public void AsGeWithoutGe() { var sb = GetSimpleBuilder(); var v = GetVarAndIdExpr("foo", BasicType.Int).Item2; var e = sb.Eq(v, sb.ConstantInt(0)); var asGe = ExprUtil.AsGe(e); Assert.IsNull(asGe); }
public void VarOrTrue() { var cfb = GetConstantFoldingBuilder(); var variable = GetVarAndIdExpr("foo", BasicType.Bool).Item2; var result = cfb.Or(variable, cfb.True); CheckIsBoolType(result); Assert.IsTrue(ExprUtil.IsTrue(result)); }
/// <summary> /// Sends the delete documents message /// </summary> public void SendDelete(string schema, string collection, bool isRelational, FilterParams filter) { var msg = new Delete(); msg.DataModel = (isRelational ? DataModel.Table : DataModel.Document); msg.Collection = ExprUtil.BuildCollection(schema, collection); ApplyFilter(v => msg.Limit = v, v => msg.Criteria = v, msg.Order.Add, filter, msg.Args.Add); _writer.Write(ClientMessageId.CRUD_DELETE, msg); }
public void AsBVSEXTWithBVSEXT() { var sb = GetSimpleBuilder(); var v = GetVarAndIdExpr("foo", BasicType.GetBvType(4)).Item2; var sext = sb.BVSEXT(v, 8); var asBvSExt = ExprUtil.AsBVSEXT(sext); Assert.IsNotNull(asBvSExt); }
public void FalseAndVar() { var cfb = GetConstantFoldingBuilder(); var variable = GetVarAndIdExpr("foo", BasicType.Bool).Item2; var result = cfb.And(cfb.False, variable); CheckIsBoolType(result); Assert.IsTrue(ExprUtil.IsFalse(result)); }
public void SetCapabilities(Dictionary <string, object> clientCapabilities) { if (clientCapabilities == null || clientCapabilities.Count == 0) { return; } var builder = new CapabilitiesSet(); var capabilities = new Capabilities(); foreach (var cap in clientCapabilities) { var value = new Any(); if (cap.Key == "tls") { value = ExprUtil.BuildAny(cap.Value); } else if (cap.Key == "session_connect_attrs" || cap.Key == "compression") { var obj = new Mysqlx.Datatypes.Object(); if (cap.Key == "session_connect_attrs") { foreach (var pair in (Dictionary <string, string>)cap.Value) { obj.Fld.Add(new ObjectField { Key = pair.Key, Value = ExprUtil.BuildAny(pair.Value) }); } } else if (cap.Key == "compression") { foreach (var pair in (Dictionary <string, object>)cap.Value) { obj.Fld.Add(new ObjectField { Key = pair.Key, Value = ExprUtil.BuildAny(pair.Value) }); } } value = new Any { Type = Any.Types.Type.Object, Obj = obj }; } var capabilityMsg = new Capability() { Name = cap.Key, Value = value }; capabilities.Capabilities_.Add(capabilityMsg); } builder.Capabilities = capabilities; _writer.Write(ClientMessageId.CON_CAPABILITIES_SET, builder); ReadOk(); }
public void OvershiftExpr(int bitWidth, int shiftWidth) { var cfb = GetConstantFoldingBuilder(); var id = GetVarAndIdExpr("x", BasicType.GetBvType(bitWidth)).Item2; var result = cfb.BVLSHR(id, cfb.ConstantBV(shiftWidth, bitWidth)); CheckIsBvType(result, bitWidth); Assert.IsTrue(ExprUtil.IsZero(result)); }
public void AsBVZEXTNotWithoutBVZEXT() { var sb = GetSimpleBuilder(); var v = GetVarAndIdExpr("foo", BasicType.GetBvType(4)).Item2; var zext = sb.BVADD(v, v); var asBvZExt = ExprUtil.AsBVZEXT(zext); Assert.IsNull(asBvZExt); }
public void ShiftZeroByExpr() { var cfb = GetConstantFoldingBuilder(); var id = GetVarAndIdExpr("x", BasicType.GetBvType(8)).Item2; var result = cfb.BVLSHR(cfb.ConstantBV(0, 8), id); CheckIsBvType(result, 8); Assert.IsTrue(ExprUtil.IsZero(result)); }
public void AsEqWithoutEq() { var sb = GetSimpleBuilder(); var v = GetVarAndIdExpr("foo", BasicType.GetBvType(4)).Item2; var e = sb.NotEq(v, sb.ConstantBV(0, 4)); var asEq = ExprUtil.AsEq(e); Assert.IsNull(asEq); }