/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
var isFullyVerified = false;
if (ac.VerifiedUnder != null)
{
var litExpr = ac.VerifiedUnder as LiteralExpr;
isFullyVerified = litExpr != null && litExpr.IsTrue;
}
if (!isFullyVerified)
{
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
VCExpr VU = null;
if (!isFullyVerified)
{
if (ac.VerifiedUnder != null)
{
VU = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.VerifiedUnder);
}
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr R = null;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
R = gen.Implies(C, N);
}
else
{
var subsumption = Subsumption(ac);
if (subsumption == CommandLineOptions.SubsumptionOption.Always ||
(subsumption == CommandLineOptions.SubsumptionOption.NotForQuantifiers && !(C is VCExprQuantifier)))
{
N = gen.ImpliesSimp(C, N, false);
}
if (isFullyVerified)
{
return(N);
}
else if (VU != null)
{
C = gen.OrSimp(VU, C);
}
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N);
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
R = gen.AndSimp(gen.Implies(assertFailure, C), N);
}
else
{
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N);
}
}
}
return(R);
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
else
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
switch (Subsumption(ac))
{
case CommandLineOptions.SubsumptionOption.Never:
break;
case CommandLineOptions.SubsumptionOption.Always:
N = gen.Implies(C, N);
break;
case CommandLineOptions.SubsumptionOption.NotForQuantifiers:
if (!(C is VCExprQuantifier))
{
N = gen.Implies(C, N);
}
break;
default:
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case
}
// (MSchaef) Hack: This line might be useless, but at least it is not harmful
// need to test it
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N));
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
return(gen.AndSimp(gen.Implies(assertFailure, C), N));
}
else
{
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N));
}
}
}
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate");
if (pname != null)
{
return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr P_Cmd(Block b, HashSet <string> constantsAssumed, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
else
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
switch (Subsumption(ac))
{
case CommandLineOptions.SubsumptionOption.Never:
break;
case CommandLineOptions.SubsumptionOption.Always:
N = gen.Implies(C, N);
break;
case CommandLineOptions.SubsumptionOption.NotForQuantifiers:
if (!(C is VCExprQuantifier))
{
N = gen.Implies(C, N);
}
break;
default:
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case
}
// (MSchaef) Hack: This line might be useless, but at least it is not harmful
// need to test it
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N));
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
return(gen.AndSimp(gen.Implies(assertFailure, C), N));
}
else
{
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N));
}
}
}
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
Contract.Assert(false);
throw new System.Exception(string.Format("VC Generation in ICE-learning does not handle stratified inlining"));
var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate");
if (pname != null)
{
return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
//return gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N);
else
{
if (constantsAssumed == null)
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
// check if the assume command contains any of the constantsAssumed (corresponding to existential function calls)?
var funcsUsed = FunctionCollector.Collect(ac.Expr);
bool hasAnyConstantAssumed = false;
foreach (var tup in funcsUsed)
{
var constantFunc = tup.Item1;
if (constantsAssumed.Contains(constantFunc.Name))
{
hasAnyConstantAssumed = true;
break;
}
}
if (hasAnyConstantAssumed)
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
//ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
else
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
/*VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
* Contract.Assert(controlFlowFunctionAppl != null);
* VCExpr assumeFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
* if (ctxt.Label2absy == null)
* {
* throw new System.Exception(string.Format("Dont know how to handle labels for the assume cmd"));
* //return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N);
* }
* else
* {
* return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N);
* }
*/
}
}
else
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
}
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
internal static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
var isFullyVerified = false;
if (ac.VerifiedUnder != null)
{
var litExpr = ac.VerifiedUnder as LiteralExpr;
isFullyVerified = litExpr != null && litExpr.IsTrue;
}
if (!isFullyVerified)
{
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
VCExpr VU = null;
if (!isFullyVerified)
{
if (ac.VerifiedUnder != null)
{
VU = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.VerifiedUnder);
if (CommandLineOptions.Clo.RunDiagnosticsOnTimeout)
{
ctxt.Ctxt.TimeoutDiagnosticIDToAssertion[ctxt.Ctxt.TimoutDiagnosticsCount] = new Tuple <AssertCmd, TransferCmd>(ac, b.TransferCmd);
VU = gen.Or(VU, gen.Function(VCExpressionGenerator.TimeoutDiagnosticsOp, gen.Integer(BigNum.FromInt(ctxt.Ctxt.TimoutDiagnosticsCount++))));
}
}
else if (CommandLineOptions.Clo.RunDiagnosticsOnTimeout)
{
ctxt.Ctxt.TimeoutDiagnosticIDToAssertion[ctxt.Ctxt.TimoutDiagnosticsCount] = new Tuple <AssertCmd, TransferCmd>(ac, b.TransferCmd);
VU = gen.Function(VCExpressionGenerator.TimeoutDiagnosticsOp, gen.Integer(BigNum.FromInt(ctxt.Ctxt.TimoutDiagnosticsCount++)));
}
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr R = null;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
R = gen.Implies(C, N);
}
else
{
var subsumption = Subsumption(ac);
if (subsumption == CommandLineOptions.SubsumptionOption.Always ||
(subsumption == CommandLineOptions.SubsumptionOption.NotForQuantifiers && !(C is VCExprQuantifier)))
{
N = gen.ImpliesSimp(C, N, false);
}
if (isFullyVerified)
{
return(N);
}
else if (VU != null)
{
C = gen.OrSimp(VU, C);
}
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N);
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
R = gen.AndSimp(gen.Implies(assertFailure, C), N);
}
else
{
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N);
}
}
}
return(R);
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(MaybeWrapWithOptimization(ctxt, gen, ac.Attributes, gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)));
}
}
}
var expr = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
var aid = QKeyValue.FindStringAttribute(ac.Attributes, "id");
if (aid != null)
{
var isTry = QKeyValue.FindBoolAttribute(ac.Attributes, "try");
var v = gen.Variable((isTry ? "try$$" : "assume$$") + aid, Microsoft.Boogie.Type.Bool);
expr = gen.Function(VCExpressionGenerator.NamedAssumeOp, v, gen.ImpliesSimp(v, expr));
}
var soft = QKeyValue.FindBoolAttribute(ac.Attributes, "soft");
var softWeight = QKeyValue.FindIntAttribute(ac.Attributes, "soft", 0);
if ((soft || 0 < softWeight) && aid != null)
{
var v = gen.Variable("soft$$" + aid, Microsoft.Boogie.Type.Bool);
expr = gen.Function(new VCExprSoftOp(Math.Max(softWeight, 1)), v, gen.ImpliesSimp(v, expr));
}
return(MaybeWrapWithOptimization(ctxt, gen, ac.Attributes, gen.ImpliesSimp(expr, N)));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
