private void WaitForOutput(object dummy) {
lock (this)
{
try
{
outcome = thmProver.CheckOutcome(cce.NonNull(handler));
}
catch (UnexpectedProverOutputException e)
{
outputExn = e;
}
switch (outcome)
{
case ProverInterface.Outcome.Valid:
thmProver.LogComment("Valid");
break;
case ProverInterface.Outcome.Invalid:
thmProver.LogComment("Invalid");
break;
case ProverInterface.Outcome.TimeOut:
thmProver.LogComment("Timed out");
break;
case ProverInterface.Outcome.OutOfMemory:
thmProver.LogComment("Out of memory");
break;
case ProverInterface.Outcome.Undetermined:
thmProver.LogComment("Undetermined");
break;
}
hasOutput = true;
proverRunTime = DateTime.UtcNow - proverStart;
}
}
public ProverInterface.Outcome Verify(ProverInterface proverInterface, Dictionary <Variable, bool> assignment, out List <Counterexample> errors, int taskID = -1)
{
collector.examples.Clear();
if (CommandLineOptions.Clo.Trace)
{
Console.WriteLine("Verifying " + descriptiveName);
}
DateTime now = DateTime.UtcNow;
VCExpr vc = proverInterface.VCExprGen.Implies(BuildAxiom(proverInterface, assignment), conjecture);
proverInterface.BeginCheck(descriptiveName, vc, handler);
ProverInterface.Outcome proverOutcome = proverInterface.CheckOutcome(handler, taskID: taskID);
double queryTime = (DateTime.UtcNow - now).TotalSeconds;
stats.proverTime += queryTime;
stats.numProverQueries++;
if (CommandLineOptions.Clo.Trace)
{
Console.WriteLine("Outcome = " + proverOutcome);
Console.WriteLine("Time taken = " + queryTime);
}
errors = collector.examples;
return(proverOutcome);
}
public override void OnModel(IList <string> labels, Model model, ProverInterface.Outcome proverOutcome)
{
if (CommandLineOptions.Clo.PrintErrorModel >= 1 && model != null)
{
model.Write(Console.Out);
}
this.model = model;
}
protected override void HoudiniVerifyCurrent(HoudiniSession session, int stage, IEnumerable <int> completedStages)
{
while (true)
{
this.NotifyAssignment(currentHoudiniState.Assignment);
//check the VC with the current assignment
List <Counterexample> errors;
ProverInterface.Outcome outcome = TryCatchVerify(session, stage, completedStages, out errors);
this.NotifyOutcome(outcome);
DebugRefutedCandidates(currentHoudiniState.Implementation, errors);
#region Explain Houdini
if (CommandLineOptions.Clo.ExplainHoudini && outcome == ProverInterface.Outcome.Invalid)
{
Contract.Assume(errors != null);
// make a copy of this variable
errors = new List <Counterexample>(errors);
var refutedAnnotations = new List <RefutedAnnotation>();
foreach (Counterexample error in errors)
{
RefutedAnnotation refutedAnnotation = ExtractRefutedAnnotation(error);
if (refutedAnnotation == null || refutedAnnotation.Kind == RefutedAnnotationKind.ASSERT)
{
continue;
}
refutedAnnotations.Add(refutedAnnotation);
}
foreach (var refutedAnnotation in refutedAnnotations)
{
session.Explain(proverInterface, currentHoudiniState.Assignment, refutedAnnotation.Constant);
}
}
#endregion
if (UpdateHoudiniOutcome(currentHoudiniState.Outcome, currentHoudiniState.Implementation, outcome, errors)) // abort
{
currentHoudiniState.WorkQueue.Dequeue();
this.NotifyDequeue();
FlushWorkList(stage, completedStages);
return;
}
else if (UpdateAssignmentWorkList(outcome, errors))
{
if (CommandLineOptions.Clo.UseUnsatCoreForContractInfer && outcome == ProverInterface.Outcome.Valid)
{
session.UpdateUnsatCore(proverInterface, currentHoudiniState.Assignment);
}
currentHoudiniState.WorkQueue.Dequeue();
this.NotifyDequeue();
return;
}
}
}
// This method is called to inform about the prover outcome for the previous GetNextBlock call.
override public bool SetCurrentResult(List <Variable> reachvar, ProverInterface.Outcome outcome, DoomErrorHandler cb)
{
this.__DEBUG_BlocksChecked++;
// outcome==Valid means that there is no feasible execution for the current block/path (i.e., might be doomed)
if (outcome == ProverInterface.Outcome.Valid && m_Current <= m_Blocks.Count)
{
List <Block> lb = new List <Block>();
lb.Add(m_Blocks[m_Current - 1]);
DetectedBlock.Add(lb);
}
return(true);
}
override public bool SetCurrentResult(List <Variable> reachvar, ProverInterface.Outcome outcome, DoomErrorHandler cb)
{
this.__DEBUG_BlocksChecked++;
// Valid means infeasible...
int oldl = MinBlocks;
int oldsize = m_Uncheckedlocks.Count;
if (outcome == ProverInterface.Outcome.Valid)
{
this.__DEBUG_InfeasibleTraces++;
if (MinBlocks == 1)
{
m_NoMoreMoves = true;
}
else
{
MinBlocks = 1;
}
}
else if (outcome == ProverInterface.Outcome.Invalid)
{
this.__DEBUG_TracesChecked++;
List <Block> errortrace = m_GetErrorTraceFromCE(cb);
foreach (Block b in errortrace)
{
if (m_Uncheckedlocks.Contains(b))
{
m_Uncheckedlocks.Remove(b);
}
}
cb.TraceNodes.Clear();
m_MaxK = m_BlockH.GetMaxK(m_Uncheckedlocks);
if (m_MaxK < 1)
{
m_NoMoreMoves = true; m_Uncheckedlocks.Clear();
}
MinBlocks = m_MaxK / 2 + (m_MaxK % 2 > 0 ? 1 : 0);
//if (MinBlocks > m_MaxK) MinBlocks = m_MaxK;
}
else
{
m_NoMoreMoves = true; m_Uncheckedlocks.Clear();
}
if (__DEBUGOUT)
{
Console.WriteLine("K := {0,3}, L := {1,3}, deltaSp {2,3}, out {3,8}, time {4,8}", MaxBlocks, oldl, (oldsize - m_Uncheckedlocks.Count), outcome, sw.ElapsedTicks);
}
sw.Stop();
sw.Reset();
return(true);
}
public void Retarget(Program prog, ProverContext ctx)
{
lock (this)
{
hasOutput = default(bool);
outcome = default(ProverInterface.Outcome);
outputExn = default(UnexpectedProverOutputException);
handler = default(ProverInterface.ErrorHandler);
TheoremProver.FullReset(gen);
ctx.Reset();
Setup(prog, ctx);
}
}
private static List <VCExpr> AnalyzeUsingUnsatCoreHelper(VCExpr programVC,
ref List <Counterexample> cexs,
ref ProverInterface.Outcome outcome,
ref VCExpr preInp, List <VCExpr> assumptions)
{
List <int> unsatClauseIdentifiers = new List <int>();
if (true) //in case we have to turn off the unsat core related logic
{
//VERY IMPORTANT: TO USE UNSAT CORE, SET ContractInfer to true in CommandLineOptions.Clo.
outcome = ProverInterface.Outcome.Undetermined;
outcome = SymDiffVC.proverInterface.CheckAssumptions(assumptions, out unsatClauseIdentifiers, SymDiffVC.handler);
Debug.Assert(outcome == ProverInterface.Outcome.Valid);
Console.Write("+");
Debug.Assert(unsatClauseIdentifiers.Count() > 0, "Something went wrong! Unsat core with 0 elements");
//newVC should be always at 0, since it has to participate in inconsistency
Debug.Assert(unsatClauseIdentifiers.Remove(0), "Something went wrong! The VC itself is not part of UNSAT core");
}
var core0 = unsatClauseIdentifiers.Count() > 0 ?
unsatClauseIdentifiers.Select(i => assumptions[i]) :
assumptions;
Console.Write("(upper bound on tainted after unsat core ={0}/{1})", core0.Count(), assumptions.Count() / 2);
var core = new List <VCExpr>(core0);
//Core may not be minimal, need to iterate
if (true)
{
foreach (var b in core0)
{
//for singleton checks, we can disable all other Booleans to only consider this equality
var tmpAssumps = new List <VCExpr>(assumptions);
tmpAssumps.Remove(b);
preInp = tmpAssumps.Aggregate(VCExpressionGenerator.True, (x, y) => SymDiffVC.exprGen.And(x, y));
preInp = SymDiffVC.exprGen.And(preInp, SymDiffVC.exprGen.Not(b)); //consider the actual output
Console.Write(".");
outcome = SymDiffVC.VerifyVC("RefinedStmtTaint", SymDiffVC.exprGen.Implies(preInp, programVC), out cexs);
if (outcome == ProverInterface.Outcome.Valid)
{
Console.Write("*");
core.Remove(b);
continue;
}
Console.Write("/"); //possibly different
}
}
return(core);
}
public void UpdateUnsatCore(ProverInterface proverInterface, Dictionary <Variable, bool> assignment)
{
DateTime now = DateTime.UtcNow;
Boogie2VCExprTranslator exprTranslator = proverInterface.Context.BoogieExprTranslator;
proverInterface.Push();
proverInterface.Assert(conjecture, false);
foreach (var v in assignment.Keys)
{
if (assignment[v])
{
continue;
}
proverInterface.Assert(exprTranslator.LookupVariable(v), false);
}
List <Variable> assumptionVars = new List <Variable>();
List <VCExpr> assumptionExprs = new List <VCExpr>();
foreach (var v in assignment.Keys)
{
if (!assignment[v])
{
continue;
}
assumptionVars.Add(v);
assumptionExprs.Add(exprTranslator.LookupVariable(v));
}
List <int> unsatCore;
ProverInterface.Outcome tmp = proverInterface.CheckAssumptions(assumptionExprs, out unsatCore, handler);
System.Diagnostics.Debug.Assert(tmp == ProverInterface.Outcome.Valid);
unsatCoreSet = new HashSet <Variable>();
foreach (int i in unsatCore)
{
unsatCoreSet.Add(assumptionVars[i]);
}
proverInterface.Pop();
double unsatCoreQueryTime = (DateTime.UtcNow - now).TotalSeconds;
stats.unsatCoreProverTime += unsatCoreQueryTime;
stats.numUnsatCoreProverQueries++;
}
// This method is called to inform about the prover outcome for the previous GetNextBlock call.
override public bool SetCurrentResult(List <Variable> reachvar, ProverInterface.Outcome outcome, DoomErrorHandler cb)
{
this.__DEBUG_BlocksChecked++;
// outcome==Valid means that there is no feasible execution for the current block/path (i.e., might be doomed)
if (outcome == ProverInterface.Outcome.Valid && m_Current <= m_Blocks.Count)
{
m_doomedBlocks.Add(m_Blocks[m_Current - 1]);
}
if (__DEBUGOUT)
{
Console.WriteLine("K := {0,3} , out {1,8}, time {2,12}", MaxBlocks, outcome, sw.ElapsedTicks);
}
sw.Stop();
sw.Reset();
return(true);
}
public override void OnModel(IList <string> /*!>!*/ labels, Model model, ProverInterface.Outcome proverOutcome)
{
// TODO: it would be better to check which reachability variables are actually set to one!
List <Block> traceNodes = new List <Block>();
List <AssertCmd> assertNodes = new List <AssertCmd>();
foreach (string s in labels)
{
Contract.Assert(s != null);
Absy node = Label2Absy(s);
if (node is Block)
{
Block b = (Block)node;
traceNodes.Add(b);
//Console.Write("{0}, ", b.Label);
}
}
m_CurrentTrace.AddRange(traceNodes);
}
// This method is called to inform about the prover outcome for the previous GetNextBlock call.
override public bool SetCurrentResult(List <Variable> reachvar, ProverInterface.Outcome outcome, DoomErrorHandler cb)
{
this.__DEBUG_BlocksChecked++;
// outcome==Valid means that there is no feasible execution for the current block/path (i.e., might be doomed)
if (outcome == ProverInterface.Outcome.Valid && m_Current != null)
{
m_doomedBlocks.Add(m_Current);
}
else if (outcome == ProverInterface.Outcome.Invalid)
{
List <Block> errortrace = m_GetErrorTraceFromCE(cb);
foreach (Block b in errortrace)
{
if (m_Blocks.Contains(b))
{
m_Blocks.Remove(b);
}
}
cb.TraceNodes.Clear();
}
return(true);
}
bool ReCheckImpl(Variable reachvar, Implementation impl, VerifierCallback callback,
out ProverInterface.Outcome outcome)
{
Contract.Requires(reachvar != null);
Contract.Requires(impl != null);
Contract.Requires(callback != null);
Checker checker = FindCheckerFor(impl, 1000);
Contract.Assert(checker != null);
DoomCheck dc = new DoomCheck(impl, this.exitBlock, checker, m_UncheckableBlocks);
dc.ErrorHandler = new DoomErrorHandler(dc.Label2Absy, callback);
outcome = ProverInterface.Outcome.Undetermined;
List <Variable> rv = new List <Variable>();
rv.Add(reachvar);
if (!dc.CheckLabel(rv, null, out outcome))
{
checker.Close();
return(false);
}
checker.Close();
return(true);
}
/* - Checking a label means to ask the prover if |= ( rvar=false -> vc ) holds.
* - outcome is set to Outcome.Invalid if the Block denoted by reachvar is doomed.
* - returns false if the theorem prover throws an exception, otherwise true.
*/
public bool CheckLabel(List <Variable> lv, Dictionary <Expr, int> finalreachvars, out ProverInterface.Outcome outcome)
{
Contract.Requires(lv != null);
outcome = ProverInterface.Outcome.Undetermined;
DEBUG_ProverTime.Reset();
DEBUG_ProverTime.Start();
if (m_Evc.CheckReachvar(lv, finalreachvars, m_Order.MaxBlocks, m_Order.MinBlocks, m_Order.HACK_NewCheck, out outcome))
{
DEBUG_ProverTime.Stop();
if (!m_Order.SetCurrentResult(lv, outcome, m_ErrHandler))
{
outcome = ProverInterface.Outcome.Undetermined;
}
return(true);
}
else
{
DEBUG_ProverTime.Stop();
Console.WriteLine(outcome);
m_Order.SetCurrentResult(lv, ProverInterface.Outcome.Undetermined, m_ErrHandler);
return(false);
}
}
private void WaitForOutput(object dummy)
{
lock (this)
{
try
{
outcome = thmProver.CheckOutcome(cce.NonNull(handler));
}
catch (UnexpectedProverOutputException e)
{
outputExn = e;
}
switch (outcome)
{
case ProverInterface.Outcome.Valid:
thmProver.LogComment("Valid");
break;
case ProverInterface.Outcome.Invalid:
thmProver.LogComment("Invalid");
break;
case ProverInterface.Outcome.TimeOut:
thmProver.LogComment("Timed out");
break;
case ProverInterface.Outcome.OutOfMemory:
thmProver.LogComment("Out of memory");
break;
case ProverInterface.Outcome.Undetermined:
thmProver.LogComment("Undetermined");
break;
}
hasOutput = true;
proverRunTime = DateTime.UtcNow - proverStart;
}
}
public void Retarget(Program prog, ProverContext ctx, int timeout = 0)
{
lock (this)
{
hasOutput = default(bool);
outcome = default(ProverInterface.Outcome);
outputExn = default(UnexpectedProverOutputException);
handler = default(ProverInterface.ErrorHandler);
TheoremProver.FullReset(gen);
ctx.Reset();
Setup(prog, ctx);
this.timeout = timeout;
SetTimeout();
}
}
public bool CheckReachvar(List <Variable> lv, Dictionary <Expr, int> finalreachvars,
int k, int l, bool usenew, out ProverInterface.Outcome outcome)
{
Contract.Requires(lv != null);
VCExpr vc = VCExpressionGenerator.False;
if (usenew)
{
foreach (Variable v in lv)
{
vc = m_Checker.VCExprGen.Or(
m_Checker.VCExprGen.Neq(
m_Checker.VCExprGen.Integer(BigNum.ZERO),
m_Checker.TheoremProver.Context.BoogieExprTranslator.LookupVariable(v)),
vc);
}
//Console.WriteLine("TPQuery k={0}, l={1}, |Sp|={2}", k, l, finalreachvars.Count);
VCExpr vc21 = m_Checker.VCExprGen.Integer(BigNum.ZERO); // Ask: is the necessary or can we use the same instance term in two inequalities?
VCExpr vc22 = m_Checker.VCExprGen.Integer(BigNum.ZERO);
foreach (KeyValuePair <Expr, int> kvp in finalreachvars)
{
vc21 = m_Checker.VCExprGen.Add(vc21, m_Checker.TheoremProver.Context.BoogieExprTranslator.Translate(kvp.Key));
vc22 = m_Checker.VCExprGen.Add(vc22, m_Checker.TheoremProver.Context.BoogieExprTranslator.Translate(kvp.Key));
}
VCExpr post = m_Checker.VCExprGen.Gt(m_Checker.VCExprGen.Integer(BigNum.FromInt(l)), vc21);
if (k != -1)
{
post = m_Checker.VCExprGen.Or(
post, m_Checker.VCExprGen.Gt(vc22, m_Checker.VCExprGen.Integer(BigNum.FromInt(k)))
);
}
vc = (m_Checker.VCExprGen.Or(vc, (post)));
}
else
{
foreach (Variable v in lv)
{
vc = m_Checker.VCExprGen.Or(
m_Checker.VCExprGen.Eq(
m_Checker.VCExprGen.Integer(BigNum.ONE),
m_Checker.TheoremProver.Context.BoogieExprTranslator.LookupVariable(v)),
vc);
}
Contract.Assert(vc != null);
// Add the desired outcome of the reachability variables
foreach (KeyValuePair <Expr, int> kvp in finalreachvars)
{
vc = m_Checker.VCExprGen.Or(
m_Checker.VCExprGen.Neq(
m_Checker.VCExprGen.Integer(BigNum.FromInt(kvp.Value)),
m_Checker.TheoremProver.Context.BoogieExprTranslator.Translate(kvp.Key)),
vc);
}
}
// Todo: Check if vc is trivial true or false
outcome = ProverInterface.Outcome.Undetermined;
Contract.Assert(m_ErrorHandler != null);
try
{
m_Checker.BeginCheck(lv[0].Name, vc, m_ErrorHandler);
m_Checker.ProverTask.Wait();
outcome = m_Checker.ReadOutcome();
}
catch (UnexpectedProverOutputException e)
{
if (CommandLineOptions.Clo.TraceVerify)
{
Console.WriteLine("Prover is unable to check {0}! Reason:", lv[0].Name);
Console.WriteLine(e.ToString());
}
return(false);
}
finally
{
m_Checker.GoBackToIdle();
}
return(true);
}
public void ReadOutcome(ref ConditionGeneration.Outcome curOutcome, out bool proverFailed)
{
Contract.EnsuresOnThrow <UnexpectedProverOutputException>(true);
ProverInterface.Outcome outcome = cce.NonNull(checker).ReadOutcome();
if (CommandLineOptions.Clo.Trace && splitNum >= 0)
{
System.Console.WriteLine(" --> split #{0} done, [{1} s] {2}", splitNum,
checker.ProverRunTime.TotalSeconds, outcome);
}
if (CommandLineOptions.Clo.VcsDumpSplits)
{
DumpDot(splitNum);
}
proverFailed = false;
switch (outcome)
{
case ProverInterface.Outcome.Valid:
return;
case ProverInterface.Outcome.Invalid:
curOutcome = ConditionGeneration.Outcome.Errors;
return;
case ProverInterface.Outcome.OutOfMemory:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.OutOfMemory;
}
return;
case ProverInterface.Outcome.TimeOut:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.TimedOut;
}
return;
case ProverInterface.Outcome.OutOfResource:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.OutOfResource;
}
return;
case ProverInterface.Outcome.Undetermined:
if (curOutcome != ConditionGeneration.Outcome.Errors)
{
curOutcome = ConditionGeneration.Outcome.Inconclusive;
}
return;
default:
Contract.Assert(false);
throw new cce.UnreachableException();
}
}
bool BruteForceCESearch(Variable reachvar, Implementation impl, VerifierCallback callback,
Dictionary <Block, List <Cmd> > cmdbackup, int startidx, int endidx)
{
Contract.Requires(reachvar != null);
Contract.Requires(impl != null);
Contract.Requires(callback != null);
Contract.Requires(cce.NonNullElements(cmdbackup));
#region Modify implementation
for (int i = startidx; i <= endidx; i++)
{
if (_copiedBlock.Contains(impl.Blocks[i]))
{
continue;
}
List <Cmd> cs = new List <Cmd>();
cmdbackup.Add(impl.Blocks[i], impl.Blocks[i].Cmds);
foreach (Cmd c in impl.Blocks[i].Cmds)
{
Contract.Assert(c != null);
if (ContainsReachVariable(c))
{
cs.Add(c);
continue;
}
AssertCmd ac = c as AssertCmd;
AssumeCmd uc = c as AssumeCmd;
if (ac != null)
{
cs.Add(new AssertCmd(ac.tok, Expr.True));
}
else if (uc != null)
{
cs.Add(new AssertCmd(uc.tok, Expr.True));
}
else
{
cs.Add(c);
}
}
impl.Blocks[i].Cmds = cs;
}
#endregion
ProverInterface.Outcome outcome = ProverInterface.Outcome.Undetermined;
if (!ReCheckImpl(reachvar, impl, callback, out outcome))
{
UndoBlockModifications(impl, cmdbackup, startidx, endidx);
return(false);
}
if (outcome == ProverInterface.Outcome.Valid)
{
return(true);
}
else if (outcome == ProverInterface.Outcome.Invalid)
{
UndoBlockModifications(impl, cmdbackup, startidx, endidx);
int mid = startidx + (endidx - startidx) / 2;
if (startidx >= endidx)
{
// Now we found an interesting Block and we have to
// search for the interesting statements.
int cmdcount = impl.Blocks[endidx].Cmds.Length;
BruteForceCmd(impl.Blocks[endidx], 0, cmdcount / 2 - 1, reachvar, impl, callback);
BruteForceCmd(impl.Blocks[endidx], cmdcount / 2, cmdcount - 1, reachvar, impl, callback);
return(true);
}
else
{
BruteForceCESearch(reachvar, impl, callback, cmdbackup, startidx, mid);
BruteForceCESearch(reachvar, impl, callback, cmdbackup, mid + 1, endidx);
return(true);
}
}
else
{
UndoBlockModifications(impl, cmdbackup, startidx, endidx);
return(false);
}
}
// This method is called to inform about the prover outcome for the previous GetNextBlock call. abstract public bool SetCurrentResult(List <Variable> reachvar, ProverInterface.Outcome outcome, DoomErrorHandler cb);
bool BruteForceCmd(Block b, int startidx, int endidx, Variable reachvar,
Implementation impl, VerifierCallback callback)
{
Contract.Requires(b != null);
Contract.Requires(reachvar != null);
Contract.Requires(impl != null);
Contract.Requires(callback != null);
#region Modify Cmds
List <Cmd> backup = b.Cmds;
Contract.Assert(backup != null);
List <Cmd> cs = new List <Cmd>();
for (int i = 0; i < startidx; i++)
{
cs.Add(b.Cmds[i]);
}
for (int i = startidx; i <= endidx; i++)
{
Cmd c = b.Cmds[i];
if (ContainsReachVariable(c))
{
cs.Add(c);
continue;
}
cs.Add(new AssertCmd(c.tok, Expr.True));
}
for (int i = endidx + 1; i < b.Cmds.Length; i++)
{
cs.Add(b.Cmds[i]);
}
b.Cmds = cs;
#endregion
#region Recheck
ProverInterface.Outcome outcome = ProverInterface.Outcome.Undetermined;
if (!ReCheckImpl(reachvar, impl, callback, out outcome))
{
b.Cmds = backup;
return(false);
}
#endregion
if (outcome == ProverInterface.Outcome.Valid)
{
return(true);
}
else if (outcome == ProverInterface.Outcome.Invalid)
{
b.Cmds = backup;
if (startidx >= endidx)
{
if (!ContainsReachVariable(b.Cmds[endidx]))
{
// Console.Write(" Witness (");
//
// ConsoleColor col = Console.ForegroundColor;
// Console.ForegroundColor = ConsoleColor.White;
// Console.Write("{0};{1}", b.Cmds[endidx].tok.line, b.Cmds[endidx].tok.col );
// Console.ForegroundColor = col;
// Console.Write("): ");
// Console.ForegroundColor = ConsoleColor.Yellow;
// b.Cmds[endidx].Emit(new TokenTextWriter("<console>", Console.Out, false), 0);
// Console.ForegroundColor = col;
m_doomedCmds.Add(b.Cmds[endidx]);
return(true);
}
else
{
return(false);
}
}
else
{
int mid = startidx + (endidx - startidx) / 2;
BruteForceCmd(b, startidx, mid, reachvar, impl, callback);
BruteForceCmd(b, mid + 1, endidx, reachvar, impl, callback);
return(false); // This is pure random
}
}
else
{
b.Cmds = backup;
return(false);
}
}
protected override bool UpdateAssignmentWorkList(ProverInterface.Outcome outcome,
List <Counterexample> errors)
{
Contract.Assume(currentHoudiniState.Implementation != null);
bool dequeue = true;
switch (outcome)
{
case ProverInterface.Outcome.Valid:
//yeah, dequeue
break;
case ProverInterface.Outcome.Invalid:
Contract.Assume(errors != null);
foreach (Counterexample error in errors)
{
RefutedAnnotation refutedAnnotation = ExtractRefutedAnnotation(error);
// some candidate annotation removed
if (refutedAnnotation != null)
{
refutedSharedAnnotations.TryAdd(refutedAnnotation.Constant.Name, refutedAnnotation);
AddRelatedToWorkList(refutedAnnotation);
UpdateAssignment(refutedAnnotation);
dequeue = false;
#region Extra debugging output
if (CommandLineOptions.Clo.Trace)
{
using (var cexWriter = new System.IO.StreamWriter(cexTraceFile, true)) {
cexWriter.WriteLine("Counter example for " + refutedAnnotation.Constant);
cexWriter.Write(error.ToString());
cexWriter.WriteLine();
using (var writer = new Microsoft.Boogie.TokenTextWriter(cexWriter))
foreach (Microsoft.Boogie.Block blk in error.Trace)
{
blk.Emit(writer, 15);
}
//cexWriter.WriteLine();
}
}
#endregion
}
}
if (ExchangeRefutedAnnotations())
{
dequeue = false;
}
break;
default:
if (CommandLineOptions.Clo.Trace)
{
Console.WriteLine("Timeout/Spaceout while verifying " + currentHoudiniState.Implementation.Name);
}
HoudiniSession houdiniSession;
houdiniSessions.TryGetValue(currentHoudiniState.Implementation, out houdiniSession);
foreach (Variable v in houdiniSession.houdiniAssertConstants)
{
if (CommandLineOptions.Clo.Trace)
{
Console.WriteLine("Removing " + v);
}
currentHoudiniState.Assignment.Remove(v);
currentHoudiniState.Assignment.Add(v, false);
this.NotifyConstant(v.Name);
}
currentHoudiniState.addToBlackList(currentHoudiniState.Implementation.Name);
break;
}
return(dequeue);
}
