public virtual void DefineMacro(Macro fun, VCExpr vc)
{
throw new NotImplementedException();
}
public override void DefineMacro(Macro f, VCExpr vc) {
DeclCollector.AddFunction(f);
string printedName = Namer.GetQuotedName(f, f.Name);
var argTypes = f.InParams.Cast<Variable>().MapConcat(p => DeclCollector.TypeToStringReg(p.TypedIdent.Type), " ");
string decl = "(define-fun " + printedName + " (" + argTypes + ") " + DeclCollector.TypeToStringReg(f.OutParams[0].TypedIdent.Type) + " " + VCExpr2String(vc, 1) + ")";
AssertAxioms();
SendThisVC(decl);
}
private void GenVC(Implementation impl)
{
ModelViewInfo mvInfo;
Dictionary<int, Absy> label2absy;
var collector = new ICEHoudiniCounterexampleCollector(this);
collector.OnProgress("HdnVCGen", 0, 0, 0.0);
if (CommandLineOptions.Clo.Trace)
{
Console.WriteLine("Generating VC of {0}", impl.Name);
}
vcgen.ConvertCFG2DAG(impl);
var gotoCmdOrigins = vcgen.PassifyImpl(impl, out mvInfo);
// Inline functions
(new InlineFunctionCalls()).VisitBlockList(impl.Blocks);
ExtractQuantifiedExprs(impl);
StripOutermostForall(impl);
//CommandLineOptions.Clo.PrintInstrumented = true;
//var tt = new TokenTextWriter(Console.Out);
//impl.Emit(tt, 0);
//tt.Close();
// Intercept the FunctionCalls of the existential functions, and replace them with Boolean constants
var existentialFunctionNames = new HashSet<string>(existentialFunctions.Keys);
var fv = new ReplaceFunctionCalls(existentialFunctionNames);
fv.VisitBlockList(impl.Blocks);
impl2functionsAsserted.Add(impl.Name, fv.functionsAsserted);
impl2functionsAssumed.Add(impl.Name, fv.functionsAssumed);
fv.functionsAssumed.Iter(f => function2implAssumed[f].Add(impl.Name));
fv.functionsAsserted.Iter(f => function2implAsserted[f].Add(impl.Name));
impl2FuncCalls.Add(impl.Name, fv.functionsUsed);
fv.functionsUsed.Iter(tup => constant2FuncCall.Add(tup.Item2.Name, tup.Item3));
HashSet<string> constantsAssumed = new HashSet<string>();
fv.functionsUsed.Where(tup => impl2functionsAssumed[impl.Name].Contains(tup.Item1)).Iter(tup => constantsAssumed.Add(tup.Item2.Name));
var gen = prover.VCExprGen;
VCExpr controlFlowVariableExpr = CommandLineOptions.Clo.UseLabels ? null : gen.Integer(Microsoft.Basetypes.BigNum.ZERO);
var vcexpr = vcgen.P_GenerateVC(impl, constantsAssumed, controlFlowVariableExpr, out label2absy, prover.Context);
//var vcexpr = vcgen.GenerateVC(impl, controlFlowVariableExpr, out label2absy, prover.Context);
if (!CommandLineOptions.Clo.UseLabels)
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(gen.Integer(Microsoft.Basetypes.BigNum.ZERO), gen.Integer(Microsoft.Basetypes.BigNum.ZERO));
VCExpr eqExpr = gen.Eq(controlFlowFunctionAppl, gen.Integer(Microsoft.Basetypes.BigNum.FromInt(impl.Blocks[0].UniqueId)));
vcexpr = gen.Implies(eqExpr, vcexpr);
}
ProverInterface.ErrorHandler handler = null;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Local)
handler = new VCGen.ErrorReporterLocal(gotoCmdOrigins, label2absy, impl.Blocks, vcgen.incarnationOriginMap, collector, mvInfo, prover.Context, program);
else
handler = new VCGen.ErrorReporter(gotoCmdOrigins, label2absy, impl.Blocks, vcgen.incarnationOriginMap, collector, mvInfo, prover.Context, program);
impl2ErrorHandler.Add(impl.Name, Tuple.Create(handler, collector));
//Console.WriteLine("VC of {0}: {1}", impl.Name, vcexpr);
// Create a macro so that the VC can sit with the theorem prover
Macro macro = new Macro(Token.NoToken, impl.Name + "Macro", new List<Variable>(), new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Bpl.Type.Bool), false));
prover.DefineMacro(macro, vcexpr);
//Console.WriteLine("Function " + impl.Name + ":\n" + vcexpr.ToString());
// Store VC
impl2VC.Add(impl.Name, gen.Function(macro));
// HACK: push the definitions of constants involved in function calls
// It is possible that some constants only appear in function calls. Thus, when
// they are replaced by Boolean constants, it is possible that (get-value) will
// fail if the expression involves such constants. All we need to do is make sure
// these constants are declared, because otherwise, semantically we are doing
// the right thing.
foreach (var tup in fv.functionsUsed)
{
// Ignore ones with bound varibles
if (tup.Item2.InParams.Count > 0) continue;
var tt = prover.Context.BoogieExprTranslator.Translate(tup.Item3);
tt = prover.VCExprGen.Or(VCExpressionGenerator.True, tt);
prover.Assert(tt, true);
}
}
public HoudiniSession(Houdini houdini, VCGen vcgen, ProverInterface proverInterface, Program program, Implementation impl, HoudiniStatistics stats, int taskID = -1)
{
this.descriptiveName = impl.Name;
this.stats = stats;
collector = new ConditionGeneration.CounterexampleCollector();
collector.OnProgress("HdnVCGen", 0, 0, 0.0);
vcgen.ConvertCFG2DAG(impl, taskID: taskID);
ModelViewInfo mvInfo;
var gotoCmdOrigins = vcgen.PassifyImpl(impl, out mvInfo);
ExistentialConstantCollector ecollector;
ExistentialConstantCollector.CollectHoudiniConstants(houdini, impl, out ecollector);
this.houdiniAssertConstants = ecollector.houdiniAssertConstants;
this.houdiniAssumeConstants = ecollector.houdiniAssumeConstants;
this.explainConstantsNegative = ecollector.explainNegative;
this.explainConstantsPositive = ecollector.explainPositive;
this.constantToControl = ecollector.constToControl;
houdiniConstants = new HashSet<Variable>();
houdiniConstants.UnionWith(houdiniAssertConstants);
houdiniConstants.UnionWith(houdiniAssumeConstants);
var exprGen = proverInterface.Context.ExprGen;
VCExpr controlFlowVariableExpr = CommandLineOptions.Clo.UseLabels ? null : exprGen.Integer(BigNum.ZERO);
Dictionary<int, Absy> label2absy;
conjecture = vcgen.GenerateVC(impl, controlFlowVariableExpr, out label2absy, proverInterface.Context);
if (!CommandLineOptions.Clo.UseLabels) {
VCExpr controlFlowFunctionAppl = exprGen.ControlFlowFunctionApplication(exprGen.Integer(BigNum.ZERO), exprGen.Integer(BigNum.ZERO));
VCExpr eqExpr = exprGen.Eq(controlFlowFunctionAppl, exprGen.Integer(BigNum.FromInt(impl.Blocks[0].UniqueId)));
conjecture = exprGen.Implies(eqExpr, conjecture);
}
Macro macro = new Macro(Token.NoToken, descriptiveName, new List<Variable>(), new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Type.Bool), false));
proverInterface.DefineMacro(macro, conjecture);
conjecture = exprGen.Function(macro);
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Local) {
handler = new VCGen.ErrorReporterLocal(gotoCmdOrigins, label2absy, impl.Blocks, vcgen.incarnationOriginMap, collector, mvInfo, proverInterface.Context, program);
}
else {
handler = new VCGen.ErrorReporter(gotoCmdOrigins, label2absy, impl.Blocks, vcgen.incarnationOriginMap, collector, mvInfo, proverInterface.Context, program);
}
}
