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);
}
