public override Element Update(Element element, AssignCmd cmd) {
return element;
}
public override Cmd VisitAssignCmd(AssignCmd node)
{
add(node);
return(base.VisitAssignCmd(node));
}
public override Element Update(Element element, AssignCmd cmd) {
if (element is E_Bottom) {
return element;
}
var e = (E)element;
var nn = e.N;
Contract.Assert(cmd.Lhss.Count == cmd.Rhss.Count);
for (int i = 0; i < cmd.Lhss.Count; i++) {
var lhs = cmd.Lhss[i];
var rhs = cmd.Rhss[i];
BigInteger? lo;
BigInteger? hi;
PartiallyEvaluate(rhs, e.N, out lo, out hi);
nn = UpdateOne(nn, lhs.DeepAssignedVariable, lo, hi);
}
return new E(nn);
}
private Block Abstract(Block b)
{
var NewCmds = new List <Cmd>();
foreach (Cmd c in b.Cmds)
{
if (c is CallCmd)
{
var call = c as CallCmd;
if (QKeyValue.FindBoolAttribute(call.Attributes, "atomic"))
{
// Discard the call
Debug.Assert(call.Ins.Count >= 1);
var IE = call.Ins[0] as IdentifierExpr;
Debug.Assert(IE != null);
Debug.Assert(verifier.ArrayModelledAdversarially(IE.Decl));
continue;
}
for (int i = 0; i < call.Ins.Count; i++)
{
ReadCollector rc = new ReadCollector(verifier.KernelArrayInfo);
rc.Visit(call.Ins[i]);
bool foundAdversarial = false;
foreach (AccessRecord ar in rc.nonPrivateAccesses)
{
if (verifier.ArrayModelledAdversarially(ar.v))
{
foundAdversarial = true;
break;
}
}
if (foundAdversarial)
{
LocalVariable lv = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken,
"_abstracted_call_arg_" + AbstractedCallArgCounter, call.Ins[i].Type));
AbstractedCallArgCounter++;
NewLocalVars.Add(lv);
NewCmds.Add(new HavocCmd(Token.NoToken,
new List <IdentifierExpr>(new IdentifierExpr[] { new IdentifierExpr(Token.NoToken, lv) })));
call.Ins[i] = new IdentifierExpr(Token.NoToken, lv);
}
}
}
if (c is AssignCmd)
{
AssignCmd assign = c as AssignCmd;
var lhss = new List <AssignLhs>();
var rhss = new List <Expr>();
foreach (var LhsRhs in assign.Lhss.Zip(assign.Rhss))
{
AssignLhs lhs = LhsRhs.Item1;
Expr rhs = LhsRhs.Item2;
ReadCollector rc = new ReadCollector(verifier.KernelArrayInfo);
rc.Visit(rhs);
bool foundAdversarial = false;
foreach (AccessRecord ar in rc.nonPrivateAccesses)
{
if (verifier.ArrayModelledAdversarially(ar.v))
{
foundAdversarial = true;
break;
}
}
if (foundAdversarial)
{
Debug.Assert(lhs is SimpleAssignLhs);
NewCmds.Add(new HavocCmd(c.tok, new List <IdentifierExpr>(new IdentifierExpr[] { (lhs as SimpleAssignLhs).AssignedVariable })));
continue;
}
WriteCollector wc = new WriteCollector(verifier.KernelArrayInfo);
wc.Visit(lhs);
if (wc.FoundNonPrivateWrite())
{
if (verifier.ArrayModelledAdversarially(wc.GetAccess().v))
{
continue; // Just remove the write
}
}
lhss.Add(lhs);
rhss.Add(rhs);
}
if (lhss.Count != 0)
{
NewCmds.Add(new AssignCmd(assign.tok, lhss, rhss));
}
continue;
}
NewCmds.Add(c);
}
b.Cmds = NewCmds;
return(b);
}
