private int GetLoopId(WhileCmd wc)
{
AssertCmd inv = wc.Invariants[0] as AssertCmd;
Debug.Assert(inv.Attributes.Key.Contains("loophead_"));
return(Convert.ToInt32(inv.Attributes.Key.Substring("loophead_".Length)));
}
private AssumeCmd MakeThreadSpecificAssumeFromAssert(AssertCmd a, int Thread)
{
AssumeCmd result = new AssumeCmd(Token.NoToken, new VariableDualiser(Thread,
verifier.uniformityAnalyser, procName).VisitExpr(a.Expr.Clone() as Expr));
return(result);
}
public static void Assign_Label_To_Declaration(ref Declaration decl)
{
Contract.Assert(decl != null);
var axiomDecl = decl as Axiom;
var procedureDecl = decl as Procedure;
var functionDecl = decl as Function;
var implemDecl = decl as Implementation;
if (axiomDecl != null)
{
var expr = axiomDecl.Expr;
Assign_Label_To_Expression(ref expr);
}
else if (procedureDecl != null)
{
var requires = procedureDecl.Requires;
var ensures = procedureDecl.Ensures;
var list_ens_req = new List <Absy>();
list_ens_req.AddRange(requires);
list_ens_req.AddRange(ensures);
Get_Names_For_Procedure(list_ens_req);
}
else if (functionDecl != null)
{
var body_expressions = (functionDecl.Body);
if (body_expressions != null)
{
Assign_Label_To_Expression(ref body_expressions);
}
}
else if (implemDecl != null)
{
for (int i = 0; i < implemDecl.Blocks.Count; i++)
{
for (int j = 0; j < implemDecl.Blocks.ToList()[i].Cmds.Count; j++)
{
Cmd c = implemDecl.Blocks.ToList()[i].Cmds.ToList()[j];
AssertCmd artc = c as AssertCmd;
AssumeCmd amec = c as AssumeCmd;
AssignCmd assc = c as AssignCmd;
Expr tmp = null;
if (artc != null)
{
tmp = artc.Expr;
}
else if (amec != null)
{
tmp = amec.Expr;
}
else if (assc != null)
{
var list_temp = assc.Rhss.ToList();
Assign_Label_To_Set_Of_Expressions(ref list_temp);
}
Assign_Label_To_Expression(ref tmp);
}
}
}
}
private Program ApplyInvariants(Houdini.HoudiniOutcome outcome)
{
Program program = getFreshProgram(false, false);
CommandLineOptions.Clo.PrintUnstructured = 2;
Houdini.Houdini.ApplyAssignment(program, outcome);
if (((GPUVerifyCruncherCommandLineOptions)CommandLineOptions.Clo).ReplaceLoopInvariantAssertions)
{
foreach (Block block in program.Blocks())
{
List <Cmd> newCmds = new List <Cmd>();
foreach (Cmd cmd in block.Cmds)
{
AssertCmd assertion = cmd as AssertCmd;
if (assertion != null &&
QKeyValue.FindBoolAttribute(assertion.Attributes, "originated_from_invariant"))
{
AssumeCmd assumption = new AssumeCmd(assertion.tok, assertion.Expr, assertion.Attributes);
newCmds.Add(assumption);
}
else
{
newCmds.Add(cmd);
}
}
block.Cmds = newCmds;
}
}
return(program);
}
public virtual Cmd VisitAssertCmd(AssertCmd node)
{
Contract.Requires(node != null);
Contract.Ensures(Contract.Result <Cmd>() != null);
node.Expr = this.VisitExpr(node.Expr);
return(node);
}
//precondition: each block contains at most one assert with SlashVerifyCommandType attribute,
// which is true since we use a block for each instruction
private bool EquivalentCmd(Cmd c1, Cmd c2)
{
//Note: The assumption here is that we only instrument assignments and attributed-asserts in the original sourcefile
if (c1.GetType() != c2.GetType())
{
return(false);
}
if (c1 is AssignCmd && c2 is AssignCmd)
{
AssignCmd c1_assignment = c1 as AssignCmd;
AssignCmd c2_assignment = c2 as AssignCmd;
//ASSUME: only 1 assignment to a variable in a block
return((c1_assignment.Lhss[0].DeepAssignedVariable == c2_assignment.Lhss[0].DeepAssignedVariable) &&
(c1_assignment.Rhss[0].ToString() == c2_assignment.Rhss[0].ToString())); //TODO: need better equality here
}
else if (c1 is AssertCmd && c2 is AssertCmd)
{
AssertCmd c1_assertion = c1 as AssertCmd;
AssertCmd c2_assertion = c2 as AssertCmd;
string c1_attribute = QKeyValue.FindStringAttribute(c1_assertion.Attributes, "SlashVerifyCommandType");
string c2_attribute = QKeyValue.FindStringAttribute(c2_assertion.Attributes, "SlashVerifyCommandType");
return(c1_attribute != null && c2_attribute != null && c1_attribute.Equals(c2_attribute));
}
return(false);
}
bool ContainsReachVariable(Cmd c)
{
Contract.Requires(c != null);
AssertCmd artc = c as AssertCmd;
AssumeCmd amec = c as AssumeCmd;
Expr e;
if (artc != null)
{
e = artc.Expr;
}
else if (amec != null)
{
e = amec.Expr;
}
else
{
return(false);
}
Set freevars = new Set();
e.ComputeFreeVariables(freevars);
foreach (Variable v in freevars)
{
Contract.Assert(v != null);
if (v.Name.Contains(reachvarsuffix))
{
return(true);
}
}
return(false);
}
public override AssertCmd GetAssertCmd()
{
AssertCmd result = base.GetAssertCmd();
result.Expr = Expr.Imp(Verifier.ThreadsInSameGroup(), result.Expr);
return(result);
}
private AssertCmd makeHavocStyleSourceInfo(IList <object> list)
{
var fn = new List <object>();
var newFn = this.relativeDir + unifyPrefix((string)list[0]);
if (File.Exists(newFn))
{
fn.Add(newFn);
}
else
{
newFn = this.relativeDir + trimDirectoryPrefix((string)list[0]);
if (File.Exists(newFn))
{
fn.Add(newFn);
}
else
{
Console.WriteLine("[ERROR] Preprocessing. Cannot Map File to name using curent heuristics.");
}
}
var lineno = new List <object>();
lineno.Add(list[1]);
var assert = new AssertCmd(Token.NoToken, Expr.True,
new QKeyValue(Token.NoToken, "sourcefile", fn,
new QKeyValue(Token.NoToken, "sourceline", lineno, null)));
return(assert);
}
public Assert(AssertCmd boogieStatement, Expression expression, string message)
: base(expression, message)
{
Debug.Assert(boogieStatement != null);
Debug.Assert(message != null);
this.boogieStatement = boogieStatement;
}
public void RecordAssertion(string label, Cmd typedCmd, AssertCmd assertion, SlashVerifyCmdType cmdType)
{
if (!Options.splitFiles)
{
return;
}
assertions.Add(new Tuple <string, Cmd, AssertCmd, SlashVerifyCmdType>(label, typedCmd, assertion, cmdType));
}
public override Cmd VisitAssertCmd(AssertCmd node)
{
var result = Translate(node.Expr);
ReturnResult(IsaBoogieTerm.Assert(result));
return(node);
}
public override Cmd VisitAssertCmd(AssertCmd node)
{
if (Util.IsSourceInfoAssertCmd(node))
{
node.Attributes = null;
}
return(base.VisitAssertCmd(node));
}
//private readonly Dictionary<IToken, List<ErrorCode>> reportedVerificationErrors = new Dictionary<IToken, List<ErrorCode>>();
//private readonly List<string> errors = new List<string>();
public void ReportCounterexample(Counterexample ce, string message)
{
if (message != null)
{
message = " (" + message + ")";
}
else
{
message = "";
}
try {
ReturnCounterexample /*?*/ rce = ce as ReturnCounterexample;
if (rce != null)
{
IToken tok = rce.FailingReturn.tok;
for (int i = rce.Trace.Length - 1; i >= 0; i--)
{
foreach (Cmd c in rce.Trace[i].Cmds)
{
AssertCmd assrt = c as AssertCmd;
if (assrt != null)
{
NAryExpr nary = assrt.Expr as NAryExpr;
if (nary != null)
{
FunctionCall fcall = nary.Fun as FunctionCall;
if (fcall != null && fcall.FunctionName == "$position_marker")
{
tok = assrt.tok;
}
}
}
}
}
ReportOutcomePostconditionFailed(rce.FailingEnsures.tok, tok, message);
}
AssertCounterexample /*?*/ ace = ce as AssertCounterexample;
if (ace != null)
{
ReportOutcomeAssertFailed(ace.FailingAssert.tok,
(ace.FailingAssert is LoopInvMaintainedAssertCmd ? "Loop body invariant" :
ace.FailingAssert is LoopInitAssertCmd ? "Loop entry invariant" : "Assertion"),
message
);
}
CallCounterexample /*?*/ cce = ce as CallCounterexample;
if (cce != null)
{
ReportOutcomePreconditionFailed(cce.FailingCall.tok, cce.FailingRequires, message);
}
} finally {
if (commandLineOptions != null && commandLineOptions.PrintCEVModel)
{
ce.PrintModel();
}
}
}
public List <Cmd> CreateFinalAssertCmds()
{
var cmds = CreateAssertCmds();
AssertCmd assertCmd = new AssertCmd(Token.NoToken, Expr.Ident(ok));
assertCmd.ErrorData = "Failed to execute atomic action before procedure return";
cmds.Add(assertCmd);
return(cmds);
}
public override List <Cmd> CreateReturnAssertCmds()
{
AssertCmd assertCmd = new AssertCmd(Token.NoToken, Expr.Ident(ok));
assertCmd.ErrorData = "Failed to execute atomic action before procedure return";
return(new List <Cmd> {
assertCmd
});
}
private List <Cmd> CollectCausalStatements(Block b)
{
Contract.Requires(b != null);
Contract.Ensures(cce.NonNullElements(Contract.Result <List <Cmd> >()));
Cmd lastCausal = null;
foreach (Cmd c in b.Cmds)
{
Contract.Assert(c != null);
AssertCmd ac = c as AssertCmd;
AssumeCmd uc = c as AssumeCmd;
if (ac != null && !ContainsReachVariable(ac))
{
if (ac.Expr != Expr.True)
{
lastCausal = c;
}
}
else if (uc != null && !ContainsReachVariable(uc))
{
lastCausal = c;
}
}
List <Cmd> causals = new List <Cmd>();
GotoCmd gc = b.TransferCmd as GotoCmd;
if (gc != null && gc.labelTargets != null)
{
List <Cmd> tmp;
//bool allcausal = true;
foreach (Block b_ in gc.labelTargets)
{
Contract.Assert(b_ != null);
tmp = CollectCausalStatements(b_);
foreach (Cmd cau in tmp)
{
if (!causals.Contains(cau))
{
causals.Add(cau);
}
}
}
//if (allcausal)
if (causals.Count > 0)
{
return(causals);
}
}
if (lastCausal != null)
{
causals.Add(lastCausal);
}
return(causals);
}
/// <summary>
/// Adds the required barriers.
/// </summary>
/// <param name="implementation">The procedure where the blocks are being added.</param>
/// <param name="block">The block containing the shared read/write command.</param>
/// <param name="index">The index of the assign command.</param>
private bool AddBarrier(Implementation implementation, Block block, int index)
{
// an assert statement is needed to obtain the source location
// skipping instrumentation if it doesn't exist
if (index - 1 < 0)
{
return(false);
}
AssertCmd assert = block.Cmds[index - 1] as AssertCmd;
if (assert == null)
{
return(false);
}
// add the instrumentation key to the assert command
QKeyValue assertAttribute = new QKeyValue(Token.NoToken, InstrumentationKey, new List <object>(), null);
if (assert.Attributes != null)
{
assert.Attributes.AddLast(assertAttribute);
}
else
{
assert.Attributes = assertAttribute;
}
// get source location infromation
int location = QKeyValue.FindIntAttribute(assert.Attributes, SourceLocationKey, -1);
QKeyValue locationAttribute = null;
if (location != -1)
{
LiteralExpr locationValue = new LiteralExpr(Token.NoToken, BigNum.FromInt(location));
locationAttribute = new QKeyValue(Token.NoToken, SourceLocationKey, new List <object> {
locationValue
}, null);
}
// create a conditional barrier
if (sourceLanguage == SourceLanguage.CUDA && !disableGridBarriers)
{
Barrier barrier = CreateCallCommand(block, locationAttribute, index, "$bugle_barrier");
Barrier grid_barrier = CreateCallCommand(block, locationAttribute, index, "$bugle_grid_barrier");
InsertBarriers(implementation, block, index, barrier, grid_barrier);
}
else
{
Barrier barrier = CreateCallCommand(block, locationAttribute, index, "$bugle_barrier");
InsertBarrier(implementation, block, index, barrier);
}
analyzer.LinkBarrier(implementation, block);
return(true);
}
private AssertCmd MakeThreadSpecificAssert(AssertCmd a, int thread)
{
AssertCmd result = new AssertCmd(
Token.NoToken,
new VariableDualiser(thread, Verifier, procName).VisitExpr(a.Expr.Clone() as Expr),
MakeThreadSpecificAttributes(a.Attributes, thread));
return(result);
}
public AssertCounterexample(List <Block> trace, List <object> augmentedTrace, AssertCmd failingAssert, Model model, VC.ModelViewInfo mvInfo,
ProverContext context)
: base(trace, augmentedTrace, model, mvInfo, context)
{
Contract.Requires(trace != null);
Contract.Requires(failingAssert != null);
Contract.Requires(context != null);
this.FailingAssert = failingAssert;
}
private void InstrumentAssertCandidate(Thread thread, Block block, Variable variable, bool value)
{
var cons = this.CreateConstant(thread);
Expr expr = this.CreateImplExpr(cons, variable, value);
var assert = new AssertCmd(Token.NoToken, expr);
assert.Attributes = new QKeyValue(Token.NoToken, "candidate",
new List <object>(), assert.Attributes);
block.Cmds.Insert(0, assert);
}
public override List <Cmd> CreateReturnAssertCmds()
{
AssertCmd assertCmd = CmdHelper.AssertCmd(
tok,
Expr.Ident(ok),
"On some path no yield-to-yield fragment matched the refined atomic action");
return(new List <Cmd> {
assertCmd
});
}
public override Cmd VisitAssertCmd(AssertCmd node)
{
int phaseNum = QKeyValue.FindIntAttribute(node.Attributes, "phase", int.MaxValue);
assertionPhaseNums.Add(phaseNum);
if (phaseNum > enclosingProcPhaseNum)
{
Error(node, "The phase of assert cannot be greater than the phase of enclosing procedure");
}
return(node);
}
public override Cmd VisitAssertCmd(AssertCmd node)
{
if (node.Attributes == null)
{
return(new AssertCmd(node.tok, VisitExpr(node.Expr)));
}
else
{
return(new AssertCmd(node.tok, VisitExpr(node.Expr), (QKeyValue)node.Attributes.Clone()));
}
}
public virtual AssertCmd GetAssertCmd()
{
AssertCmd result = new AssertCmd(
Token.NoToken,
new VariableDualiser(1, Dualiser.Verifier, ProcName).VisitExpr(Expr.Imp(Predicate, BarrierInvariant)),
Dualiser.MakeThreadSpecificAttributes(sourceLocationInfo, 1));
result.Attributes = new QKeyValue(Token.NoToken, "barrier_invariant", new List <object> {
Expr.True
}, result.Attributes);
return(result);
}
public static IEnumerable <AssertCmd> GetGateAsserts(AtomicAction action, Substitution subst, string msg)
{
foreach (var gate in action.gate)
{
AssertCmd cmd =
subst != null
? (AssertCmd)Substituter.Apply(subst, gate)
: new AssertCmd(gate.tok, gate.Expr);
cmd.ErrorData = msg;
yield return(cmd);
}
}
private bool IsTerminatingLoopHeader(Block block)
{
foreach (Cmd cmd in block.Cmds)
{
AssertCmd assertCmd = cmd as AssertCmd;
if (assertCmd != null && QKeyValue.FindBoolAttribute(assertCmd.Attributes, "terminates") && moverTypeChecker.absyToLayerNums[assertCmd].Contains(currLayerNum))
{
return(true);
}
}
return(false);
}
private AssertCmd CreateSkipOrBetaAssertCmd()
{
// assert pc || g_old == g || beta(i, g_old, o, g);
var aa = OldEqualityExprForGlobals();
var assertExpr = Expr.Or(Expr.Ident(pc), Expr.Or(aa, beta));
assertExpr.Typecheck(new TypecheckingContext(null));
var skipOrBetaAssertCmd = new AssertCmd(Token.NoToken, assertExpr);
skipOrBetaAssertCmd.ErrorData = "Transition invariant violated in initial state";
return(skipOrBetaAssertCmd);
}
private AssertCmd CreateSkipAssertCmd()
{
// assert pc ==> o_old == o && g_old == g;
Expr bb = OldEqualityExpr();
var assertExpr = Expr.Imp(Expr.Ident(pc), bb);
assertExpr.Typecheck(new TypecheckingContext(null));
AssertCmd skipAssertCmd = new AssertCmd(Token.NoToken, assertExpr);
skipAssertCmd.ErrorData = "Transition invariant violated in final state";
return(skipAssertCmd);
}
private void CreateFailurePreservationChecker(AtomicAction first, AtomicAction second)
{
if (!first.gateUsedGlobalVars.Intersect(second.modifiedGlobalVars).Any())
{
return;
}
if (!failurePreservationCheckerCache.Add(Tuple.Create(first, second)))
{
return;
}
HashSet <Variable> frame = new HashSet <Variable>();
frame.UnionWith(first.gateUsedGlobalVars);
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
var linearTypeChecker = civlTypeChecker.linearTypeChecker;
List <Requires> requires = new List <Requires>
{
DisjointnessRequires(
first.firstImpl.InParams.Union(second.secondImpl.InParams)
.Where(v => linearTypeChecker.FindLinearKind(v) != LinearKind.LINEAR_OUT), frame)
};
Expr firstNegatedGate = Expr.Not(Expr.And(first.firstGate.Select(a => a.Expr)));
firstNegatedGate.Type = Type.Bool; // necessary?
requires.Add(new Requires(false, firstNegatedGate));
foreach (AssertCmd assertCmd in second.secondGate)
{
requires.Add(new Requires(false, assertCmd.Expr));
}
IEnumerable <Expr> linearityAssumes =
linearTypeChecker.DisjointnessExprForEachDomain(first.firstImpl.InParams.Union(second.secondImpl.OutParams)
.Union(frame));
AssertCmd gateFailureCheck = CmdHelper.AssertCmd(
first.proc.tok,
Expr.Imp(Expr.And(linearityAssumes), firstNegatedGate),
$"Gate failure of {first.proc.Name} not preserved by {second.proc.Name}");
string checkerName = $"FailurePreservationChecker_{first.proc.Name}_{second.proc.Name}";
List <Variable> inputs = Enumerable.Union(first.firstImpl.InParams, second.secondImpl.InParams).ToList();
List <Variable> outputs = Enumerable.Union(first.firstImpl.OutParams, second.secondImpl.OutParams).ToList();
var cmds = new List <Cmd>
{
ActionCallCmd(second, second.secondImpl),
gateFailureCheck
};
AddChecker(checkerName, inputs, outputs, new List <Variable>(), requires, cmds);
}
