public static BvConst GetBVFromLiteral(Expr l)
{
Assert.IsTrue(l is LiteralExpr);
LiteralExpr litExpr = l as LiteralExpr;
Assert.IsTrue(litExpr.isBvConst);
BvConst literalBV = litExpr.asBvConst;
return(literalBV);
}
public static LiteralExpr CheckIsLiteralBVConstWithValue(Expr e, BigNum value)
{
Assert.IsInstanceOf <LiteralExpr>(e);
LiteralExpr lit = e as LiteralExpr;
Assert.IsTrue(lit.isBvConst);
BvConst litBV = lit.asBvConst;
Assert.AreEqual(value, litBV.Value);
return(lit);
}
public void MultipleTargets()
{
int hits = 0;
p = LoadProgramFrom("programs/GotoMultiplePaths.bpl");
e = GetExecutor(p);
e.BreakPointReached += delegate(object executor, Executor.BreakPointEventArgs data)
{
if (data.Name == "entry")
{
Assert.AreEqual("entry_block", e.CurrentState.GetCurrentStackFrame().CurrentBlock.Label);
++hits;
}
else if (data.Name == "path0")
{
Assert.AreEqual("P0", e.CurrentState.GetCurrentStackFrame().CurrentBlock.Label);
++hits;
var a = e.CurrentState.GetInScopeVariableAndExprByName("a");
BvConst aBV = GetBVFromLiteral(a.Value as LiteralExpr);
Assert.AreEqual(7, aBV.Value.ToInt);
}
else if (data.Name == "path1")
{
var a = e.CurrentState.GetInScopeVariableAndExprByName("a");
Assert.AreEqual("P1", e.CurrentState.GetCurrentStackFrame().CurrentBlock.Label);
BvConst aBV = GetBVFromLiteral(a.Value as LiteralExpr);
Assert.AreEqual(8, aBV.Value.ToInt);
++hits;
}
else if (data.Name == "path2")
{
var a = e.CurrentState.GetInScopeVariableAndExprByName("a");
Assert.AreEqual("P2", e.CurrentState.GetCurrentStackFrame().CurrentBlock.Label);
BvConst aBV = GetBVFromLiteral(a.Value as LiteralExpr);
Assert.AreEqual(9, aBV.Value.ToInt);
++hits;
}
else
{
Assert.Fail("Unexpected break point");
}
};
e.Run(GetMain(p));
Assert.AreEqual(4, hits);
}
public BitVector(BvConst bv)
{
// Create bit-string representation
string str = bv.ToReadableString();
string bareStr = str.Substring(0, str.IndexOf("bv"));
if (bareStr.StartsWith("0x"))
{
bareStr = bareStr.Replace("0x", "").Replace(".", "");
for (int i = 0; i < bareStr.Length; ++i)
{
Bits += HexToBinary(bareStr[i]);
}
}
else
{
int val = Convert.ToInt32(bareStr);
Bits = Convert.ToString(val, 2);
}
Pad(bv.Bits, '0');
}
public static Node CreateFromExpr(Expr expr)
{
if (expr is NAryExpr)
{
NAryExpr nary = expr as NAryExpr;
if (nary.Fun is IfThenElse)
{
Node one = CreateFromExpr(nary.Args[0]);
Node two = CreateFromExpr(nary.Args[1]);
Node three = CreateFromExpr(nary.Args[2]);
Node parent = new TernaryNode(nary.Fun.FunctionName, one, two, three);
one.parent = parent;
two.parent = parent;
three.parent = parent;
return(parent);
}
else if (nary.Fun is BinaryOperator)
{
Node one = CreateFromExpr(nary.Args[0]);
Node two = CreateFromExpr(nary.Args[1]);
Node parent = new BinaryNode(nary.Fun.FunctionName, one, two);
one.parent = parent;
two.parent = parent;
return(parent);
}
else if (nary.Fun is UnaryOperator)
{
Node one = CreateFromExpr(nary.Args[0]);
UnaryNode parent = new UnaryNode(nary.Fun.FunctionName, one);
one.parent = parent;
return(parent);
}
else if (nary.Fun is FunctionCall)
{
FunctionCall call = nary.Fun as FunctionCall;
if (nary.Args.Count == 1)
{
Node one = CreateFromExpr(nary.Args[0]);
UnaryNode parent = new UnaryNode(nary.Fun.FunctionName, one);
one.parent = parent;
return(parent);
}
else if (nary.Args.Count == 2)
{
Node one = CreateFromExpr(nary.Args[0]);
Node two = CreateFromExpr(nary.Args[1]);
Node parent = new BinaryNode(call.FunctionName, one, two);
one.parent = parent;
two.parent = parent;
return(parent);
}
else
{
Print.ExitMessage("Unhandled number of arguments in Boogie function call with function: " + nary.Fun.FunctionName);
}
}
else if (nary.Fun is MapSelect)
{
List <Expr> indices = new List <Expr>();
while (true)
{
NAryExpr nary2 = nary.Args[0] as NAryExpr;
Print.ConditionalExitMessage(nary.Args.Count == 2, "Map select has more than two arguments");
indices.Insert(0, nary.Args[1]);
if (nary2 == null)
{
break;
}
else
{
nary = nary2;
}
}
IdentifierExpr identifier = nary.Args[0] as IdentifierExpr;
Node parent = new MapSymbolNode(identifier.Name);
foreach (Expr index in indices)
{
Node child = CreateFromExpr(index);
parent.Children.Add(child);
child.parent = parent;
}
return(parent);
}
else
{
Print.ExitMessage("Unhandled Nary expression: " + nary.Fun.GetType().ToString());
}
}
else if (expr is IdentifierExpr)
{
IdentifierExpr identifier = expr as IdentifierExpr;
return(new ScalarSymbolNode(identifier.Name, identifier.Type));
}
else if (expr is LiteralExpr)
{
LiteralExpr literal = expr as LiteralExpr;
if (literal.Val is BvConst)
{
BvConst bv = (BvConst)literal.Val;
return(new LiteralNode(new BitVector(bv)));
}
else if (literal.Val is BigNum)
{
BigNum num = (BigNum)literal.Val;
return(new LiteralNode(new BitVector(num.ToInt)));
}
else if (literal.Val is bool)
{
bool boolean = (bool)literal.Val;
if (boolean)
{
return(new LiteralNode(BitVector.True));
}
else
{
return(new LiteralNode(BitVector.False));
}
}
else
{
Print.ExitMessage("Unhandled literal expression: " + literal.ToString());
}
}
else if (expr is BvExtractExpr)
{
BvExtractExpr bvExtract = expr as BvExtractExpr;
Node child = CreateFromExpr(bvExtract.Bitvector);
Node parent = new BVExtractNode(child, bvExtract.End, bvExtract.Start);
child.parent = parent;
return(parent);
}
else if (expr is BvConcatExpr)
{
BvConcatExpr bvConcat = expr as BvConcatExpr;
Node one = CreateFromExpr(bvConcat.E0);
Node two = CreateFromExpr(bvConcat.E1);
Node parent = new BVConcatenationNode(one, two);
one.parent = parent;
two.parent = parent;
return(parent);
}
else if (expr is ForallExpr)
{
ForallExpr forall = expr as ForallExpr;
Node one = CreateFromExpr(forall._Body);
Node parent = new ForAllNode(one);
one.parent = parent;
return(parent);
}
Print.ExitMessage("Unhandled expression tree: " + expr.ToString() + " " + expr.Type.ToString());
return(null);
}
// Bitvector nodes
public VCExpr Bitvector(BvConst bv)
{
Contract.Requires(bv != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
return(Function(new VCExprBvOp(bv.Bits), Integer(bv.Value)));
}
