private void UnsuppressToken(AssertToken token)
{
var location = tokenLocation[token];
var p = BoogieUtil.findProcedureImpl(currProg.TopLevelDeclarations, location.Item1);
var block = p.Blocks.Where(blk => blk.Label == location.Item2).FirstOrDefault();
// disable assignment to assertsPassed
var ncmds = new List <Cmd>();
foreach (var cmd in block.Cmds)
{
if (!Options.DeepAsserts && cmd is AssumeCmd && QKeyValue.FindIntAttribute((cmd as AssumeCmd).Attributes, "suppressAssert", -1) == token.id)
{
ncmds.Add(BoogieAstFactory.MkVarEqExpr(assertsPassed, (cmd as AssumeCmd).Expr));
}
else if (Options.DeepAsserts && cmd is AssumeCmd &&
QKeyValue.FindIntAttribute((cmd as AssumeCmd).Attributes, "avn", -1) == token.id)
{
ncmds.Add(new AssertCmd(Token.NoToken, (cmd as AssertCmd).Expr, (cmd as AssertCmd).Attributes));
}
else
{
ncmds.Add(cmd);
}
}
block.Cmds = ncmds;
}
private static List <Cmd> ProcessAssume(AssumeCmd cmd)
{
var ret = new List <Cmd>();
var gm = new GatherMemAccesses();
gm.VisitExpr(cmd.Expr);
foreach (var tup in gm.accesses)
{
ret.Add(BoogieAstFactory.MkVarEqExpr(memAccess, tup.Item2));
ret.Add(Read(tup.Item1));
}
ret.Add(cmd);
return(ret);
}
private static List <Cmd> ProcessAssign(AssignCmd cmd)
{
var ret = new List <Cmd>();
var reads = new GatherMemAccesses();
var writes = new List <Tuple <Variable, Expr> >();
var scalars = new List <Variable>();
foreach (var lhs in cmd.Lhss)
{
if (lhs is MapAssignLhs)
{
var ma = lhs as MapAssignLhs;
ma.Indexes.Iter(e => writes.Add(Tuple.Create(ma.DeepAssignedVariable, e)));
ma.Indexes.Iter(e => reads.VisitExpr(e));
}
else if (lhs is SimpleAssignLhs && scalarGlobals.Contains(lhs.DeepAssignedVariable.Name))
{
scalars.Add(lhs.DeepAssignedVariable);
}
}
cmd.Rhss.Iter(e => reads.VisitExpr(e));
writes.Iter(tup =>
{
ret.Add(BoogieAstFactory.MkVarEqExpr(memAccess, tup.Item2));
ret.Add(Write(tup.Item1));
});
reads.accesses.Iter(tup =>
{
ret.Add(BoogieAstFactory.MkVarEqExpr(memAccess, tup.Item2));
ret.Add(Read(tup.Item1));
});
ret.Add(cmd);
scalars.Iter(v => ret.Add(RecordScalar(v)));
return(ret);
}
private static List <Cmd> ProcessCall(CallCmd cmd)
{
var ret = new List <Cmd>();
var gm = new GatherMemAccesses();
cmd.Ins.Where(e => e != null).Iter(e => gm.VisitExpr(e));
foreach (var tup in gm.accesses)
{
ret.Add(BoogieAstFactory.MkVarEqExpr(memAccess, tup.Item2));
ret.Add(Read(tup.Item1));
}
ret.Add(cmd);
cmd.Outs.Where(ie => ie != null && scalarGlobals.Contains(ie.Name))
.Iter(ie => ret.Add(RecordScalar(ie.Decl)));
return(ret);
}
void Desugar(Variable lhs, Expr cond, Expr then, Expr els, ref List <Cmd> currCmds, ref Block currBlock, List <Block> newBlocks)
{
// create three new blocks
var lab1 = GetNewLabel();
var lab2 = GetNewLabel();
var lab3 = GetNewLabel();
var tmp = CreateTmp(btype.Bool);
currCmds.Add(BoogieAstFactory.MkVarEqExpr(tmp, cond));
// end current block
currBlock.Cmds = currCmds;
currBlock.TransferCmd = new GotoCmd(Token.NoToken, new List <string> {
lab1, lab2
});
newBlocks.Add(currBlock);
var blk1 = new Block(Token.NoToken, lab1, new List <Cmd>(), BoogieAstFactory.MkGotoCmd(lab3));
var blk2 = new Block(Token.NoToken, lab2, new List <Cmd>(), BoogieAstFactory.MkGotoCmd(lab3));
blk1.Cmds.AddRange(
new List <Cmd> {
BoogieAstFactory.MkAssume(Expr.Ident(tmp)),
BoogieAstFactory.MkVarEqExpr(lhs, then)
});
blk2.Cmds.AddRange(
new List <Cmd> {
BoogieAstFactory.MkAssume(Expr.Not(Expr.Ident(tmp))),
BoogieAstFactory.MkVarEqExpr(lhs, els)
});
newBlocks.Add(blk1);
newBlocks.Add(blk2);
currBlock = new Block(Token.NoToken, lab3, new List <Cmd>(), null);
currCmds = new List <Cmd>();
}
public override CBAProgram runCBAPass(CBAProgram program)
{
// Add blanks
blanksInfo = AddBlanks(program);
// Remove unreachable procedures
BoogieUtil.pruneProcs(program, program.mainProcName);
if (!Options.TraceSlicing)
{
// Remove source line annotations
sourceInfo = cba.PrintSdvPath.DeleteSourceInfo(program);
}
else
{
sourceInfo = null;
}
// Remove print info
//printInfo = cba.PrintSdvPath.DeletePrintCmds(program);
// Compress
compressBlocks.VisitProgram(program);
// name Ebasic
NameEnvironmentConstraints(program);
// Instrument assertions
int tokenId = 0;
origMainName = program.mainProcName;
CBAProgram ret = null;
if (!Options.DeepAsserts)
{
// Do error-bit instrumentation
var impls = BoogieUtil.nameImplMapping(program);
var pwa = cba.SequentialInstrumentation.procsWithAsserts(program);
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
var instrumented = new List <Block>();
foreach (var blk in impl.Blocks)
{
var currCmds = new List <Cmd>();
var currLabel = blk.Label;
assertInstrInfo.addTrans(impl.Name, blk.Label, blk.Label);
var incnt = -1;
foreach (Cmd cmd in blk.Cmds)
{
incnt++;
// instrument assert
if (cmd is AssertCmd && !BoogieUtil.isAssertTrue(cmd))
{
currCmds.Add(BoogieAstFactory.MkVarEqExpr(assertsPassed, (cmd as AssertCmd).Expr));
var token = new AssertToken(tokenId);
originalAssertions.Add(token, cmd as AssertCmd);
tokenLocation.Add(token, Tuple.Create(impl.Name, currLabel));
procToTokens.InitAndAdd(impl.Name, token);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
currLabel = addInstr(instrumented, currCmds, currLabel, tokenId);
tokenId++;
currCmds = new List <Cmd>();
continue;
}
// procedure call
if (cmd is CallCmd && pwa.Contains((cmd as CallCmd).callee))
{
currCmds.Add(cmd);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
currLabel = addInstr(instrumented, currCmds, currLabel, -1);
currCmds = new List <Cmd>();
continue;
}
currCmds.Add(cmd);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
}
instrumented.Add(new Block(Token.NoToken, currLabel, currCmds, blk.TransferCmd));
}
impl.Blocks = instrumented;
}
program.AddTopLevelDeclaration(assertsPassed);
var newMain = addMain(program);
BoogieUtil.DoModSetAnalysis(program);
// Set inline attribute
// free requires assertsPassed == true;
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
impl.Proc.Requires.Add(new Requires(true, Expr.Ident(assertsPassed)));
}
// convert free ensures e to:
// free ensures assertsPassed == false || e
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>()
.Where(impl => pwa.Contains(impl.Name)))
{
foreach (Ensures ens in impl.Proc.Ensures)
{
ens.Condition = Expr.Or(Expr.Not(Expr.Ident(assertsPassed)), ens.Condition);
}
}
currProg = program;
ret = new CBAProgram(program, newMain, 0);
}
else
{
// Use Deep-assert instrumentation
da = new cba.DeepAssertRewrite();
// First, tag assertions with tokens
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
foreach (var blk in impl.Blocks)
{
foreach (var cmd in blk.Cmds.OfType <AssertCmd>())
{
if (BoogieUtil.isAssertTrue(cmd))
{
continue;
}
var token = new AssertToken(tokenId);
cmd.Attributes = new QKeyValue(Token.NoToken, "avn", new List <object> {
Expr.Literal(tokenId)
},
cmd.Attributes);
originalAssertions.Add(token, cmd);
tokenLocation.Add(token, Tuple.Create(impl.Name, blk.Label));
procToTokens.InitAndAdd(impl.Name, token);
tokenId++;
}
}
}
// Second, do the rewrite
var t1 = new PersistentProgram(program, program.mainProcName, program.contextBound);
var t2 = da.run(t1);
var daprog = t2.getCBAProgram();
// Third, revisit the assertions and remember their location
// in the output program. This is a bit of a hack. The "tokenLocation"
// of a token is the pair (p1,b1) where p1 is the procedure the assertion
// originally came from and b1 is the block in the new main that contains
// that assertion.
var main = BoogieUtil.findProcedureImpl(daprog.TopLevelDeclarations, daprog.mainProcName);
foreach (var block in main.Blocks)
{
foreach (var cmd in block.Cmds.OfType <AssertCmd>())
{
var tok = QKeyValue.FindIntAttribute(cmd.Attributes, "avn", -1);
if (tok < 0)
{
continue;
}
var token = new AssertToken(tok);
Debug.Assert(tokenLocation.ContainsKey(token));
var oldloc = tokenLocation[token];
tokenLocation[token] = Tuple.Create(oldloc.Item1, block.Label);
}
}
currProg = daprog;
ret = daprog;
}
return(ret);
}