public void AddLoopInvariantDisabledTag()
{
AssumeCmd assume = new AssumeCmd(Token.NoToken, Expr.True, null);
assume.Attributes = new QKeyValue(Token.NoToken, "invGenSkippedLoop", new List <object>(), assume.Attributes);
header.Cmds.Insert(0, assume);
}
private void AddHoudiniConstant(AssumeCmd assumeCmd)
{
if (houdini.MatchCandidate(assumeCmd.Expr, out Variable houdiniConstant))
{
houdiniAssumeConstants.Add(houdiniConstant);
}
}
private static void ProcessCounterexampleForDiffInliningWOSymbolicOut(List <Variable> eqLocVars, Implementation vtLeftProcImpl, Implementation vtRightProcImpl, string v1Name, string v2Name, List <Block> listBlocksV1, List <Block> listBlocksV2, GotoCmd labelEntry)
{
if (vtLeftProcImpl != null && vtRightProcImpl != null) //only when diff inlining is on
{
var blocksLeftProcImpl = vtLeftProcImpl.Blocks.ToArray();
var blocksRightProcImpl = vtRightProcImpl.Blocks.ToArray();
var firstCmdThirdBlockLeft = new AssumeCmd(Token.NoToken, Expr.Not(Expr.True));
var firstCmdThirdBlockRight = new AssumeCmd(Token.NoToken, Expr.Not(Expr.True));
var leftThirdBlockCmdElems = blocksLeftProcImpl[2].Cmds;
var rightThirdBlockCmdElems = blocksRightProcImpl[2].Cmds;
leftThirdBlockCmdElems[0] = firstCmdThirdBlockLeft;
rightThirdBlockCmdElems[0] = firstCmdThirdBlockRight;
blocksLeftProcImpl[2].Cmds = leftThirdBlockCmdElems;
blocksRightProcImpl[2].Cmds = rightThirdBlockCmdElems;
// re-building the first block (only the goto cmds)
blocksLeftProcImpl[0].TransferCmd = labelEntry;
blocksRightProcImpl[0].TransferCmd = labelEntry;
// removing the second block
vtLeftProcImpl.Blocks.RemoveAt(1);
vtRightProcImpl.Blocks.RemoveAt(1);
foreach (Block currentBlockV1 in listBlocksV1)
{
vtLeftProcImpl.Blocks.Add(currentBlockV1);
}
foreach (Block currentBlockV2 in listBlocksV2)
{
vtRightProcImpl.Blocks.Add(currentBlockV2);
}
//vtLeftProcImpl.Blocks.Add(blockV1);
//vtRightProcImpl.Blocks.Add(blockV2);
//hemr - handling local variable declarations
List <Variable> locVarsV1_diff_inline = new List <Variable>();
List <Variable> locVarsV2_diff_inline = new List <Variable>();
foreach (Variable currentVariable in eqLocVars)
{
if (currentVariable.ToString().Contains("inline$" + v1Name))
{
locVarsV1_diff_inline.Add(currentVariable);
}
else if (currentVariable.ToString().Contains("inline$" + v2Name))
{
locVarsV2_diff_inline.Add(currentVariable);
}
}
vtLeftProcImpl.LocVars = locVarsV1_diff_inline;
vtRightProcImpl.LocVars = locVarsV2_diff_inline;
}
}
//additional stuff needed to do for diff inlining is on
private static void ProcessCounterexampleForDiffInline(SDiffCounterexamples errors, Implementation vtLeftProcImpl, Implementation vtRightProcImpl, Expr disjunctionDiffCond)
{
if (vtLeftProcImpl != null && vtRightProcImpl != null)
{
var blocksLeftProcImpl = vtLeftProcImpl.Blocks.ToArray();
var blocksRightProcImpl = vtRightProcImpl.Blocks.ToArray();
var firstCmdSecondBlockLeft = new AssumeCmd(Token.NoToken, disjunctionDiffCond);
var firstCmdSecondBlockRight = new AssumeCmd(Token.NoToken, disjunctionDiffCond);
var firstCmdThirdBlockLeft = new AssumeCmd(Token.NoToken, Expr.Not(disjunctionDiffCond));
var firstCmdThirdBlockRight = new AssumeCmd(Token.NoToken, Expr.Not(disjunctionDiffCond));
if (Options.PropagateSingleDifference && errors.Count > 1)
{
firstCmdThirdBlockLeft = new AssumeCmd(Token.NoToken, Expr.False);
firstCmdThirdBlockRight = new AssumeCmd(Token.NoToken, Expr.False);
}
var leftSecondBlockCmdElems = blocksLeftProcImpl[1].Cmds;
var leftThirdBlockCmdElems = blocksLeftProcImpl[2].Cmds;
var rightSecondBlockCmdElems = blocksRightProcImpl[1].Cmds;
var rightThirdBlockCmdElems = blocksRightProcImpl[2].Cmds;
leftSecondBlockCmdElems[0] = firstCmdSecondBlockLeft;
leftThirdBlockCmdElems[0] = firstCmdThirdBlockLeft;
rightSecondBlockCmdElems[0] = firstCmdSecondBlockRight;
rightThirdBlockCmdElems[0] = firstCmdThirdBlockRight;
blocksLeftProcImpl[1].Cmds = leftSecondBlockCmdElems;
blocksLeftProcImpl[2].Cmds = leftThirdBlockCmdElems;
blocksRightProcImpl[1].Cmds = rightSecondBlockCmdElems;
blocksRightProcImpl[2].Cmds = rightThirdBlockCmdElems;
}
}
private bool AnalyseConflict(string state1, string state2, AssumeCmd assume1, AssumeCmd assume2)
{
string t1 = this.GetThreadName(assume1.Attributes);
string t2 = this.GetThreadName(assume2.Attributes);
// if (!this.Pair.EntryPoint1.Name.Equals(ep1))
// return false;
// if (!this.Pair.EntryPoint2.Name.Equals(ep2))
// return false;
string access1 = this.GetAccessType(assume1.Attributes);
string access2 = this.GetAccessType(assume2.Attributes);
if (access1.Equals("read") && access2.Equals("read"))
{
return(false);
}
// var sourceInfoForAccess1 = new SourceLocationInfo(assume1.Attributes);
// var sourceInfoForAccess2 = new SourceLocationInfo(assume2.Attributes);
// ErrorReporter.ErrorWriteLine("\n" + sourceInfoForAccess1.GetFile() + ":",
// "potential " + access1 + "-" + access2 + " race:\n", ErrorMsgType.Error);
// Console.Error.Write(access1 + " by thread " + t1 + ", ");
// Console.Error.WriteLine(sourceInfoForAccess1.ToString());
// sourceInfoForAccess1.PrintStackTrace();
// Console.Error.WriteLine(access2 + " by entry point " + ep2 + ", " + sourceInfoForAccess2.ToString());
// sourceInfoForAccess2.PrintStackTrace();
return(true);
}
// goto label1, label2;
//
// label1:
// assume {:avn tok} !assertsPassed;
// return;
//
// label2:
// assume assertsPassed;
// goto lab;
//
// lab:
//
// Inputs: the list of blocks being constructed; the current block being constructed.
// End current block and adds two new blocks.
// Returns "lab".
private string addInstr(List <Block> instrumented, List <Cmd> curr, string curr_label, int token)
{
string lbl1 = getNewLabel();
string lbl2 = getNewLabel();
List <String> ssp = new List <String> {
lbl1, lbl2
};
instrumented.Add(new Block(Token.NoToken, curr_label, curr, new GotoCmd(Token.NoToken, ssp)));
string common_label = getNewLabel();
// assume (!assertsPassed)
AssumeCmd cmd1 = new AssumeCmd(Token.NoToken, Expr.Not(Expr.Ident(assertsPassed)));
if (token >= 0)
{
cmd1.Attributes = new QKeyValue(Token.NoToken, "avn", new List <object> {
Expr.Literal(token)
}, cmd1.Attributes);
}
// assume (assertsPassed)
AssumeCmd cmd2 = new AssumeCmd(Token.NoToken, Expr.Ident(assertsPassed));
curr = new List <Cmd>();
curr.Add(cmd1);
instrumented.Add(new Block(Token.NoToken, lbl1, curr, new ReturnCmd(Token.NoToken)));
curr = new List <Cmd>();
curr.Add(cmd2);
instrumented.Add(new Block(Token.NoToken, lbl2, curr, BoogieAstFactory.MkGotoCmd(common_label)));
return(common_label);
}
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 Dictionary<Block, List<CallSite>> CollectCallSites(Implementation implementation)
{
var callSites = new Dictionary<Block, List<CallSite>>();
foreach (Block block in implementation.Blocks)
{
for (int i = 0; i < block.Cmds.Count; i++)
{
Cmd cmd = block.Cmds[i];
AssumeCmd assumeCmd = cmd as AssumeCmd;
if (assumeCmd == null) continue;
NAryExpr naryExpr = assumeCmd.Expr as NAryExpr;
if (naryExpr == null) continue;
if (!implName2StratifiedInliningInfo.ContainsKey(naryExpr.Fun.FunctionName)) continue;
List<VCExpr> interfaceExprs = new List<VCExpr>();
foreach (Expr e in naryExpr.Args)
{
interfaceExprs.Add(prover.Context.BoogieExprTranslator.Translate(e));
}
int instr = i;
i++;
AssumeCmd callSiteAssumeCmd = (AssumeCmd) block.Cmds[i];
IdentifierExpr iexpr = (IdentifierExpr) callSiteAssumeCmd.Expr;
CallSite cs = new CallSite(naryExpr.Fun.FunctionName, interfaceExprs,
prover.Context.BoogieExprTranslator.LookupVariable(iexpr.Decl), block, instr, assumeCmd.Attributes);
if (!callSites.ContainsKey(block))
callSites[block] = new List<CallSite>();
callSites[block].Add(cs);
}
}
return callSites;
}
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);
}
private void AddPath()
{
Dictionary <Variable, Expr> varToExpr =
frame
.Concat(first != null ? first.thatOutParams : Enumerable.Empty <Variable>())
.Concat(second.thisOutParams)
.ToDictionary(v => v, v => Expr.Ident(v) as Expr);
List <Expr> pathExprs = new List <Expr>();
foreach (Cmd cmd in cmdStack)
{
if (cmd is AssumeCmd)
{
AssumeCmd assumeCmd = cmd as AssumeCmd;
FlattenAnd(assumeCmd.Expr, pathExprs);
}
else if (cmd is AssignCmd)
{
AssignCmd assignCmd = (cmd as AssignCmd).AsSimpleAssignCmd;
Dictionary <Variable, Expr> map = new Dictionary <Variable, Expr>();
for (int k = 0; k < assignCmd.Lhss.Count; k++)
{
map[assignCmd.Lhss[k].DeepAssignedVariable] = assignCmd.Rhss[k];
}
Substitute(map, ref pathExprs, ref varToExpr);
}
else
{
Debug.Assert(false);
}
}
paths.Add(new PathInfo(varToExpr, pathExprs));
}
public Dictionary<Block, List<CallSite>> CollectRecordProcedureCallSites(Implementation implementation)
{
var callSites = new Dictionary<Block, List<CallSite>>();
foreach (Block block in implementation.Blocks)
{
for (int i = 0; i < block.Cmds.Count; i++)
{
AssumeCmd assumeCmd = block.Cmds[i] as AssumeCmd;
if (assumeCmd == null) continue;
NAryExpr naryExpr = assumeCmd.Expr as NAryExpr;
if (naryExpr == null) continue;
if (!naryExpr.Fun.FunctionName.StartsWith(recordProcName)) continue;
List<VCExpr> interfaceExprs = new List<VCExpr>();
foreach (Expr e in naryExpr.Args)
{
interfaceExprs.Add(prover.Context.BoogieExprTranslator.Translate(e));
}
CallSite cs = new CallSite(naryExpr.Fun.FunctionName, interfaceExprs, null, block, i, assumeCmd.Attributes);
if (!callSites.ContainsKey(block))
callSites[block] = new List<CallSite>();
callSites[block].Add(cs);
}
}
return callSites;
}
public override List <AssumeCmd> GetInstantiationCmds()
{
var result = new List <AssumeCmd>();
foreach (var instantiation in instantiationExprs)
{
foreach (var thread in Enumerable.Range(1, 2))
{
var vd = new VariableDualiser(thread, Dualiser.Verifier, ProcName);
var ti = new ThreadInstantiator(instantiation, thread, Dualiser.Verifier, ProcName);
var assume = new AssumeCmd(
Token.NoToken,
Expr.Imp(
vd.VisitExpr(Predicate),
Expr.Imp(
Expr.And(
NonNegative(instantiation),
NotTooLarge(instantiation)),
ti.VisitExpr(BarrierInvariant))));
result.Add(vd.VisitAssumeCmd(assume) as AssumeCmd);
}
}
return(result);
}
private HashSet <VariableDescriptor> GetControlDependencyVariables(string proc, Block b)
{
// This method works under the assumption that assume statements
// relevant to control flow between basic blocks have the "partition" attribute
HashSet <VariableDescriptor> result = new HashSet <VariableDescriptor>();
var gotoCmd = b.TransferCmd as GotoCmd;
if (gotoCmd != null && gotoCmd.labelTargets.Count >= 2)
{
foreach (Block succ in gotoCmd.labelTargets)
{
foreach (Cmd c in succ.Cmds)
{
AssumeCmd a = c as AssumeCmd;
if (a != null && QKeyValue.FindBoolAttribute(a.Attributes, "partition"))
{
var VarCollector = new VariableCollector();
VarCollector.VisitExpr(a.Expr);
result.UnionWith(VarCollector.usedVars.Where(Item => VariableRelevantToAnalysis(Item, proc)).
Select(Item => MakeDescriptor(proc, Item)));
}
else
{
break;
}
}
}
}
return(result);
}
public virtual Cmd VisitAssumeCmd(AssumeCmd node)
{
Contract.Requires(node != null);
Contract.Ensures(Contract.Result <Cmd>() != null);
node.Expr = this.VisitExpr(node.Expr);
return(node);
}
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 override List <AssumeCmd> GetInstantiationCmds()
{
var result = new List <AssumeCmd>();
foreach (var instantiation in instantiationExprPairs)
{
foreach (var thread in new int[] { 1, 2 })
{
var vd = new VariableDualiser(thread, Dualiser.Verifier, ProcName);
var ti = new ThreadPairInstantiator(Dualiser.Verifier, instantiation.Item1, instantiation.Item2, thread);
var assume = new AssumeCmd(
Token.NoToken,
Expr.Imp(
vd.VisitExpr(Predicate),
Expr.Imp(
Expr.And(
Expr.And(
Expr.And(
NonNegative(instantiation.Item1),
NotTooLarge(instantiation.Item1)),
Expr.And(
NonNegative(instantiation.Item2),
NotTooLarge(instantiation.Item2))),
Expr.Neq(instantiation.Item1, instantiation.Item2)),
ti.VisitExpr(BarrierInvariant))));
result.Add(vd.VisitAssumeCmd(assume) as AssumeCmd);
}
}
return(result);
}
public void InstrumentCallSites(Implementation implementation)
{
var callSiteId = 0;
foreach (Block block in implementation.Blocks)
{
List<Cmd> newCmds = new List<Cmd>();
for (int i = 0; i < block.Cmds.Count; i++)
{
Cmd cmd = block.Cmds[i];
newCmds.Add(cmd);
AssumeCmd assumeCmd = cmd as AssumeCmd;
if (assumeCmd == null) continue;
NAryExpr naryExpr = assumeCmd.Expr as NAryExpr;
if (naryExpr == null) continue;
if (!implName2StratifiedInliningInfo.ContainsKey(naryExpr.Fun.FunctionName)) continue;
Variable callSiteVar = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, "SICS" + callSiteId, Microsoft.Boogie.Type.Bool));
implementation.LocVars.Add(callSiteVar);
var toInsert = new AssumeCmd(Token.NoToken, new IdentifierExpr(Token.NoToken, callSiteVar),
new QKeyValue(Token.NoToken, callSiteVarAttr, new List<object>(), null));
newCmds.Add(toInsert);
callSiteId++;
}
block.Cmds = newCmds;
}
}
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 void AddPath()
{
HashSet <Variable> existsVars = new HashSet <Variable>();
Dictionary <Variable, Expr> varToExpr = new Dictionary <Variable, Expr>();
foreach (Variable v in frame)
{
varToExpr[v] = Expr.Ident(v);
}
if (first != null)
{
foreach (Variable v in first.thatOutParams)
{
varToExpr[v] = Expr.Ident(v);
}
}
foreach (Variable v in second.thisOutParams)
{
varToExpr[v] = Expr.Ident(v);
}
List <Expr> pathExprs = new List <Expr>();
int boundVariableCount = 0;
foreach (Cmd cmd in cmdStack)
{
if (cmd is AssumeCmd)
{
AssumeCmd assumeCmd = cmd as AssumeCmd;
FlattenAnd(assumeCmd.Expr, pathExprs);
}
else if (cmd is AssignCmd)
{
AssignCmd assignCmd = (cmd as AssignCmd).AsSimpleAssignCmd;
Dictionary <Variable, Expr> map = new Dictionary <Variable, Expr>();
for (int k = 0; k < assignCmd.Lhss.Count; k++)
{
map[assignCmd.Lhss[k].DeepAssignedVariable] = assignCmd.Rhss[k];
}
Substitute(map, ref pathExprs, ref varToExpr);
}
else if (cmd is HavocCmd)
{
HavocCmd havocCmd = cmd as HavocCmd;
Dictionary <Variable, Expr> map = new Dictionary <Variable, Expr>();
foreach (IdentifierExpr ie in havocCmd.Vars)
{
BoundVariable bv = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "#tmp_" + boundVariableCount++, ie.Decl.TypedIdent.Type));
map[ie.Decl] = Expr.Ident(bv);
existsVars.Add(bv);
}
Substitute(map, ref pathExprs, ref varToExpr);
}
else
{
Debug.Assert(false);
}
}
paths.Add(new PathInfo(existsVars, varToExpr, pathExprs));
}
public override Cmd VisitAssumeCmd(AssumeCmd node)
{
currCmd = node;
var b = base.VisitAssumeCmd(node);
currCmd = null;
return(b);
}
public override Cmd VisitAssumeCmd(AssumeCmd node)
{
var result = Translate(node.Expr);
ReturnResult(IsaBoogieTerm.Assume(result));
return(node);
}
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);
}
AssumeCmd GetQuery(Function func, Expr arg)
{
var ret = new AssumeCmd(Token.NoToken, new NAryExpr(Token.NoToken, new FunctionCall(func), new List <Expr> {
arg
}));
ret.Attributes = new QKeyValue(Token.NoToken, "ForDeadCodeDetection", new List <object>(), ret.Attributes);
return(ret);
}
public override Cmd VisitAssumeCmd(AssumeCmd node)
{
if (node.Expr.Equals(Expr.False))
{
// "assume false" has a special return command inserted as the TransferCmd, which is not recognized initially for some reason
// this is a hack to force its addition to the nodeToImpl dictionary. A
nodeToImpl[worklist.cmdBlocks[node].TransferCmd] = nodeToImpl[node];
}
return(worklist.SimpleTransform(node) as Cmd);
}
private static AssumeCmd DetermineConflictingAction(CallCounterexample CallCex, string RaceyState, string AccessHasOccurred, string AccessOffset)
{
AssumeCmd LastLogAssume = null;
string LastOffsetValue = null;
foreach (var b in CallCex.Trace)
{
bool finished = false;
foreach (var c in b.Cmds.OfType <AssumeCmd>())
{
string StateName = QKeyValue.FindStringAttribute(c.Attributes, "captureState");
if (StateName == null)
{
continue;
}
Model.CapturedState state = GetStateFromModel(StateName, CallCex.Model);
if (state == null || state.TryGet(AccessHasOccurred) is Model.Uninterpreted)
{
// Either the state was not recorded, or the state has nothing to do with the reported error, so do not
// analyse it further.
continue;
}
Model.Boolean AHO_value = state.TryGet(AccessHasOccurred) as Model.Boolean;
Model.BitVector AO_value =
(RaceInstrumentationUtil.RaceCheckingMethod == RaceCheckingMethod.ORIGINAL
? state.TryGet(AccessOffset)
: CallCex.Model.TryGetFunc(AccessOffset).GetConstant()) as Model.BitVector;
if (!AHO_value.Value)
{
LastLogAssume = null;
LastOffsetValue = null;
}
else if (LastLogAssume == null || !AO_value.Numeral.Equals(LastOffsetValue))
{
LastLogAssume = c;
LastOffsetValue = AO_value.Numeral;
}
if (StateName.Equals(RaceyState))
{
finished = true;
}
break;
}
if (finished)
{
break;
}
}
Debug.Assert(LastLogAssume != null);
return(LastLogAssume);
}
private void ParseAndRenameFunctionsInAssume(Thread thread, Implementation impl, Block block,
AssumeCmd cmd, IdentifierExpr tid)
{
if (cmd.Expr is NAryExpr)
{
this.ParseAndRenameNAryExpr(thread, impl, block, cmd.Expr as NAryExpr, tid);
}
else if (cmd.Expr is IdentifierExpr)
{
this.ParseAndRenameIdentifier(thread, impl, block, cmd.Expr as IdentifierExpr, tid);
}
}
private void InstrumentSourceLocationInfo(Implementation impl)
{
foreach (var b in impl.Blocks)
{
for (int idx = 0; idx < b.Cmds.Count; idx++)
{
if (!(b.Cmds[idx] is CallCmd))
{
continue;
}
CallCmd call = b.Cmds[idx] as CallCmd;
AssumeCmd assume = null;
for (int i = idx; i >= 0; i--)
{
if (b.Cmds[i] is AssumeCmd)
{
assume = b.Cmds[i] as AssumeCmd;
break;
}
}
if (assume == null)
{
for (int i = idx; i < b.Cmds.Count; i++)
{
if (b.Cmds[i] is AssumeCmd)
{
assume = b.Cmds[i] as AssumeCmd;
break;
}
}
}
if (call.callee.Contains("_UPDATE_CLS"))
{
call.Attributes = this.GetSourceLocationAttributes(
assume.Attributes, call.Attributes);
}
else if (call.callee.Contains("_WRITE_LS_"))
{
call.Attributes = this.GetSourceLocationAttributes(
assume.Attributes, call.Attributes);
}
else if (call.callee.Contains("_READ_LS_"))
{
call.Attributes = this.GetSourceLocationAttributes(
assume.Attributes, call.Attributes);
}
}
}
}
List <Cmd> ProcessAssume(AssumeCmd cmd)
{
var ret = new List <Cmd>();
Reset();
var expr = base.VisitExpr(cmd.Expr);
ret.AddRange(GetTmpAssignments());
cmd.Expr = expr;
ret.Add(cmd);
return(ret);
}
List <Cmd> ProcessAssume(AssumeCmd cmd, Dictionary <string, string> varDecls)
{
var ret = new List <Cmd>();
var gm = new GatherMemAccesses();
gm.VisitExpr(cmd.Expr);
foreach (var tup in gm.accesses)
{
ret.Add(MkAssert(tup.Item2));
}
ret.Add(cmd);
return(ret);
}
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.AddRange(MkAssert(tup.Item2));
}
ret.Add(cmd);
return(ret);
}
