/// <summary>
/// Provide program for the next procedure (for the global declarations).
/// </summary>
public static void Program(Program p)
{
if (boogieGlobalData == null)
{
boogieGlobalData = new BoogieGlobalData(p.Functions, p.Axioms, p.GlobalVariables, p.Constants);
var methodData = BoogieMethodData.CreateOnlyGlobal(boogieGlobalData);
var fixedVarTranslation = new DeBruijnFixedVarTranslation(methodData);
var fixedTyVarTranslation = new DeBruijnFixedTVarTranslation(methodData);
var factory =
new DeBruijnVarFactory(fixedVarTranslation, fixedTyVarTranslation, boogieGlobalData);
var globalDataTheoryName = "global_data";
var globalDataConfig = new IsaProgramGeneratorConfig(null, true, true, true, false, SpecsConfig.None, false);
globalDataProgAccess = new IsaProgramGenerator().GetIsaProgram(
globalDataTheoryName,
"proc",
methodData, globalDataConfig, factory,
null,
out var declsGlobalData,
!CommandLineOptions.Clo.GenerateIsaProgNoProofs,
true
);
var globalDataTheory = new Theory(globalDataTheoryName,
new List <string> {
"Boogie_Lang.Semantics", "Boogie_Lang.TypeSafety", "Boogie_Lang.Util"
},
declsGlobalData);
ProofGenerationOutput.StoreTheoriesTopLevel(new List <Theory> {
globalDataTheory
});
}
}
/// <summary>
/// Provide source CFG for passification phase
/// </summary>
public static void BeforePassification(Implementation impl)
{
if (CommandLineOptions.Clo.GenerateIsaProgNoProofs)
{
return;
}
var config = new CFGReprConfigBuilder().SetIsAcyclic(true).SetBlockCopy(true).SetDesugarCalls(true)
.Build();
beforePassificationCfg = CFGReprTransformer.GetCfgRepresentation(
impl,
config,
out beforePassiveOrigBlock,
out var newVarsFromDesugaring
);
cfgToDagHintManager.AfterDagToOrig = beforePassiveOrigBlock;
beforePassiveData = MethodDataFromImpl(impl, boogieGlobalData, newVarsFromDesugaring);
passificationHintManager = new PassificationHintManager(beforePassiveOrigBlock);
initialVarMapping = new Dictionary <Block, IDictionary <Variable, Expr> >();
// compute mapping between copied blocks (before dag -> after dag)
var origToAfterDag = beforePassiveOrigBlock.InverseDict();
beforeDagAfterDagBlock = DictionaryComposition(beforeDagOrigBlock, origToAfterDag);
}
public VcPhaseLemmaManager(VCInstantiation <Block> vcinst,
BoogieMethodData methodData,
IEnumerable <Function> vcFunctions,
IsaBlockInfo isaBlockInfo,
IVariableTranslationFactory variableFactory)
{
this.vcinst = vcinst;
this.methodData = methodData;
programVariables = methodData.AllVariables();
initState = IsaBoogieTerm.Normal(normalInitState);
this.isaBlockInfo = isaBlockInfo;
this.variableFactory = variableFactory;
boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName("\\<Lambda>"),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.TermIdentFromName("\\<Omega>")
);
var typeDeclTranslation = new ConcreteTypeDeclTranslation(boogieContext);
declToVCMapping = LemmaHelper.DeclToTerm(
((IEnumerable <NamedDeclaration>)methodData.Functions).Union(programVariables),
vcFunctions,
typeDeclTranslation,
uniqueNamer);
//separate unique namer for function interpretations (since they already have a name in uniqueNamer): possible clashes
funToInterpMapping = LemmaHelper.FunToTerm(methodData.Functions, new IsaUniqueNamer());
assmManager = new AssumptionManager(methodData.Functions, programVariables, variableFactory);
}
public VcAxiomLemmaManager(
VCInstantiation <VCExpr> vcAxiomInst,
BoogieMethodData methodData,
IEnumerable <Function> vcFunctions,
VcRewriteLemmaGen vcRewriteLemmaGen,
IVariableTranslationFactory variableFactory)
{
this.vcAxiomInst = vcAxiomInst;
this.methodData = methodData;
this.vcRewriteLemmaGen = vcRewriteLemmaGen;
this.variableFactory = variableFactory;
basicCmdIsaVisitor = new BasicCmdIsaVisitor(variableFactory);
boogieContext = new BoogieContextIsa(IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"), IsaCommonTerms.TermIdentFromName("\\<Lambda>"),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"), IsaCommonTerms.TermIdentFromName("\\<Omega>"));
var typeDeclTranslation = new ConcreteTypeDeclTranslation(boogieContext);
declToVCMapping =
LemmaHelper.DeclToTerm(
((IEnumerable <NamedDeclaration>)methodData.Functions).Union(methodData.Constants), vcFunctions,
typeDeclTranslation, uniqueNamer);
//separate unique namer for function interpretations (since they already have a name in uniqueNamer): possible clashes
funToInterpMapping = LemmaHelper.FunToTerm(methodData.Functions, new IsaUniqueNamer());
assmManager = new AssumptionManager(methodData.Functions, methodData.Constants, variableFactory);
}
private DefDecl MethodDefinition(IProgramAccessor programAccessor, BoogieMethodData methodData, SpecsConfig specConfig)
{
var modifiedVarsTerm = new TermList(
methodData.ModifiedVars.Select(id =>
{
if (varTranslation.VarTranslation.TryTranslateVariableId(id.Decl, out Term idTerm, out _))
{
return(idTerm);
}
/// <summary>
/// Provide source CFG for CFG-to-DAG phase
/// </summary>
public static void BeforeCFGToDAG(Implementation impl)
{
var config = new CFGReprConfigBuilder().SetIsAcyclic(false).SetBlockCopy(true).SetDesugarCalls(true)
.Build();
beforeDagCfg = CFGReprTransformer.GetCfgRepresentation(impl,
config,
out beforeDagOrigBlock,
out var newVarsFromDesugaring);
beforeDagData = MethodDataFromImpl(impl, boogieGlobalData, newVarsFromDesugaring);
uniqueExitBlockOrig = null;
}
/// <summary>
/// Provide target CFG for passification phase, construct global version map.
/// </summary>
/// <param name="impl">source CFG after passification phase</param>
/// <exception cref="ProofGenUnexpectedStateException">thrown if global version map is incorrect
/// (should never happen). </exception>
public static void AfterPassificationCheckGlobalMap(Implementation impl)
{
afterPassificationImpl = impl;
if (CommandLineOptions.Clo.GenerateIsaProgNoProofs)
{
return;
}
finalProgData = MethodDataFromImpl(impl, boogieGlobalData);
var config = new CFGReprConfigBuilder().SetIsAcyclic(true).SetBlockCopy(true).SetDesugarCalls(false)
.SetDeepCopyPredCmd(TypeCheckBeforeVcMaybeRewritesCmd).Build();
afterPassificationCfg =
CFGReprTransformer.GetCfgRepresentation(impl, config, out afterPassificationToOrigBlock, out _);
var passiveBlocks = new List <Block>(afterPassificationCfg.GetBlocksBackwards());
var origToAfterPassificationBlock = afterPassificationToOrigBlock.InverseDict();
beforePassiveToAfterPassiveBlock =
DictionaryComposition(beforePassiveOrigBlock, origToAfterPassificationBlock);
var globalVersion = new GlobalVersion();
passiveRelationGen = new PassiveRelationGen(
beforePassificationCfg,
passificationHintManager,
initialVarMapping,
beforePassiveOrigBlock,
beforePassiveToAfterPassiveBlock,
ProofGenLiveVarAnalysis.ComputeLiveVariables(beforePassificationCfg, beforePassiveData)
);
//all variables before passification are the initial versions and already constrained
globalVersionMap = globalVersion.GlobalVersionMap(
passiveRelationGen,
beforePassiveData.AllVariables(),
afterPassificationCfg.entry,
passiveBlocks);
//Console.WriteLine("Version map: " + string.Join(Environment.NewLine, globalVersionMap));
var versionMapCorrect =
GlobalVersionChecker.CheckVersionMap(globalVersionMap, passiveRelationGen, beforePassificationCfg,
beforePassiveToAfterPassiveBlock);
if (!versionMapCorrect)
{
throw new ProofGenUnexpectedStateException(typeof(ProofGenerationLayer), "Incorrect version map");
}
}
public DeBruijnFixedTVarTranslation(BoogieMethodData methodData)
{
methodTyVarMapping = new Dictionary <TypeVariable, int>();
var id = 0;
void AddVarsToMapping(IEnumerable <TypeVariable> vars, IDictionary <TypeVariable, int> dict)
{
foreach (var v in vars)
{
if (dict.ContainsKey(v))
{
throw new ProofGenUnexpectedStateException(GetType(), "duplicate variables");
}
dict.Add(v, id);
id++;
}
}
//order important
AddVarsToMapping(methodData.TypeParams, methodTyVarMapping);
}
public DeBruijnFixedVarTranslation(BoogieMethodData methodData, bool globalsBeforeLocals = true)
{
paramsAndLocalMapping = new Dictionary <Variable, int>();
globalsMapping = new Dictionary <Variable, int>();
var id = 0;
void AddVarsToMapping(IEnumerable <Variable> vars, IDictionary <Variable, int> dict)
{
foreach (var v in vars)
{
if (dict.ContainsKey(v))
{
throw new ProofGenUnexpectedStateException(GetType(), "duplicate variables");
}
dict.Add(v, id);
id++;
}
}
//order important
if (globalsBeforeLocals)
{
AddVarsToMapping(methodData.Constants, globalsMapping);
AddVarsToMapping(methodData.GlobalVars, globalsMapping);
AddVarsToMapping(methodData.InParams, paramsAndLocalMapping);
AddVarsToMapping(methodData.Locals, paramsAndLocalMapping);
}
else
{
AddVarsToMapping(methodData.InParams, paramsAndLocalMapping);
AddVarsToMapping(methodData.Locals, paramsAndLocalMapping);
AddVarsToMapping(methodData.Constants, globalsMapping);
AddVarsToMapping(methodData.GlobalVars, globalsMapping);
}
}
public BoogieVariableTranslation CreateEmptyTranslation()
{
return(new BoogieVariableTranslation(
new DeBruijnTranslation <Variable>(varTranslation, valueVarConstructor, false),
new DeBruijnTranslation <TypeVariable>(new DeBruijnFixedTVarTranslation(BoogieMethodData.CreateEmpty()),
typeVarConstructor, true)
));
}
public static Theory PassificationProof(
string theoryName,
string boogieToVcTheoryName,
bool generateEndToEndLemma,
LemmaDecl boogieToVcLemma,
Term vcAssm,
CFGRepr beforePassificationCfg,
IDictionary <Block, Block> nonPassiveToPassiveBlock,
PassiveRelationGen relationGen,
IProgramAccessor beforePassiveProgAccess,
IProgramAccessor passiveProgAccess,
BoogieMethodData beforePassiveData,
IVariableTranslationFactory beforePassiveFactory,
IVariableTranslationFactory passiveFactory)
{
var varContextName = "\\<Lambda>1";
var passiveVarContextName = "\\<Lambda>2";
var varContextNonPassivePassive = Tuple.Create(varContextName, passiveVarContextName);
var oldGlobalVars = GetOldGlobalVariables(beforePassificationCfg);
var oldRelationData =
OldRelation(
oldGlobalVars,
beforePassiveFactory.CreateTranslation().VarTranslation,
out var oldRelListDecl);
var passificationProofDecls = new List <OuterDecl>();
passificationProofDecls.AddRange(oldRelListDecl);
passificationProofDecls.AddRange(oldRelationData.VarToLookupLemma.Values);
if (oldRelationData.VarToLookupLemma.Any())
{
passificationProofDecls.Add(new LemmasDecl(allOldLookupLemmasName,
oldRelationData.VarToLookupLemma.Values.Select(lemma => lemma.Name).ToList()));
}
var beforePassiveLemmaManager = new PassificationLemmaManager(
beforePassificationCfg,
nonPassiveToPassiveBlock,
beforePassiveProgAccess,
passiveProgAccess,
varContextNonPassivePassive,
oldRelationData,
relationGen,
beforePassiveFactory,
passiveFactory
);
var lemmaNamer = new IsaUniqueNamer();
var varContextAbbrev = new AbbreviationDecl(
varContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), beforePassiveProgAccess.VarContext())
);
var passiveVarContextAbbrev = new AbbreviationDecl(
passiveVarContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), passiveProgAccess.VarContext())
);
passificationProofDecls.Add(varContextAbbrev);
passificationProofDecls.Add(passiveVarContextAbbrev);
passificationProofDecls.AddRange(beforePassiveLemmaManager.Prelude());
var cfgLemmas = new List <OuterDecl>();
foreach (var block in beforePassificationCfg.GetBlocksBackwards())
{
var localAndCfgLemma =
beforePassiveLemmaManager.GenerateBlockLemma(
block,
GetLemmaName(block, lemmaNamer),
b => GetCfgLemmaName(b, lemmaNamer));
passificationProofDecls.Add(localAndCfgLemma.Item1);
cfgLemmas.Add(localAndCfgLemma.Item2);
}
//add cfg lemmas at the end
passificationProofDecls.AddRange(cfgLemmas);
if (generateEndToEndLemma)
{
var endToEnd = new PassificationEndToEnd();
passificationProofDecls.AddRange(endToEnd.EndToEndProof(
GetCfgLemmaName(beforePassificationCfg.entry, lemmaNamer),
boogieToVcTheoryName + "." + boogieToVcLemma.Name,
vcAssm,
beforePassiveProgAccess,
passiveProgAccess,
varContextNonPassivePassive,
oldRelationData,
beforePassificationCfg,
relationGen.LiveVarsBeforeBlock(beforePassificationCfg.entry),
passiveFactory.CreateTranslation().VarTranslation
));
}
var imports = new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", beforePassiveProgAccess.TheoryName(),
passiveProgAccess.TheoryName(), "Boogie_Lang.PassificationML",
boogieToVcTheoryName
};
if (generateEndToEndLemma)
{
imports.Add("Boogie_Lang.PassificationEndToEnd");
}
return(new Theory(theoryName, imports, passificationProofDecls));
}
public IProgramAccessor GetIsaProgram(
string theoryName,
string procName,
BoogieMethodData methodData,
IsaProgramGeneratorConfig config,
IVariableTranslationFactory varTranslationFactory,
CFGRepr cfg,
out IList <OuterDecl> decls,
bool generateMembershipLemmas = true,
bool onlyGlobalData = false
)
{
this.varTranslationFactory = varTranslationFactory;
varTranslation = varTranslationFactory.CreateTranslation();
cmdIsaVisitor = new MultiCmdIsaVisitor(varTranslationFactory);
/*
* Term program = IsaBoogieTerm.Program(IsaCommonTerms.TermIdentFromName(funcs.name),
* new TermList(new List<Term>()),
* new TermList(new List<Term>()),
* IsaCommonTerms.TermIdentFromName(axiomsDecl.name),
* new List<Term>() { method });
*
* var list = new List<Tuple<IList<Term>, Term>>
* {
* new Tuple<IList<Term>, Term>(new List<Term>(), program)
* };
*/
//OuterDecl programDefinition = new DefDecl("ProgramM", new Tuple<IList<Term>, Term>(new List<Term>(), program));
decls = new List <OuterDecl>();
var isaGlobalProgramRepr = new IsaGlobalProgramRepr(
FunctionDeclarationsName(),
AxiomDeclarationsName(),
VariableDeclarationsName("globals"),
VariableDeclarationsName("constants")
);
var globalsMax = methodData.Constants.Count() + methodData.GlobalVars.Count() - 1;
// assume single versioning and order on constants, globals, params, locals
var localsMin = globalsMax + 1;
if (globalsMax < 0)
{
globalsMax = 0;
}
MembershipLemmaManager membershipLemmaManager;
if (onlyGlobalData)
{
membershipLemmaManager = new MembershipLemmaManager(
isaGlobalProgramRepr, globalsMax, varTranslationFactory, theoryName);
}
else
{
var outEdges = GetOutEdgesIsa(procName, cfg, out var edgeLemmas);
var blockInfo = BlockToInfo(theoryName, procName, cfg, edgeLemmas);
var isaProgramRepr = new IsaProgramRepr(
isaGlobalProgramRepr,
PreconditionDeclarationName(),
PostconditionDeclarationName(),
VariableDeclarationsName("params"),
VariableDeclarationsName("locals"),
cfgName,
procDefName);
membershipLemmaManager = new MembershipLemmaManager(config, isaProgramRepr, blockInfo,
Tuple.Create(globalsMax, localsMin), varTranslationFactory, theoryName);
var nodesToBlocks = GetNodeToBlocksIsa(cfg, blockInfo.BlockCmdsDefs);
decls.AddRange(blockInfo.BlockCmdsDefs.Values);
Term entry = new IntConst(BigNum.FromInt(cfg.GetUniqueIntLabel(cfg.entry)));
var methodBodyCFG =
IsaBoogieTerm.MethodCFGBody(
entry, IsaCommonTerms.TermIdentFromName(outEdges.Name),
IsaCommonTerms.TermIdentFromName(nodesToBlocks.Name)
);
var methodBodyDecl = GetMethodBodyCFGDecl(procName, methodBodyCFG);
decls.AddRange(
new List <OuterDecl>
{
outEdges, nodesToBlocks, methodBodyDecl
});
decls.AddRange(blockInfo.BlockCmdsLemmas.Values);
decls.AddRange(blockInfo.BlockOutEdgesLemmas.Values);
if (config.specsConfig != SpecsConfig.None)
{
OuterDecl preconditions;
OuterDecl postconditions;
if (config.specsConfig == SpecsConfig.AllPreCheckedPost)
{
preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions.Select(pre => pre.Item1));
postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions.Where(post => !post.Item2).Select(post => post.Item1));
}
else
{
preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions);
postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions);
}
decls.Add(preconditions);
decls.Add(postconditions);
}
if (config.generateParamsAndLocals)
{
decls.Add(GetVariableDeclarationsIsa("params", methodData.InParams));
decls.Add(GetVariableDeclarationsIsa("locals", methodData.Locals));
}
/* membership lemmas might still be added even if the parameter and local variable definitions are not generated
* at this point (since the variable context may still be different, which requires other lookup lemmas)
*/
if (generateMembershipLemmas)
{
membershipLemmaManager.AddVariableMembershipLemmas(methodData.InParams, VarKind.ParamOrLocal);
membershipLemmaManager.AddVariableMembershipLemmas(methodData.Locals, VarKind.ParamOrLocal);
}
}
if (config.generateAxioms)
{
decls.Add(GetAxioms(methodData.Axioms));
if (generateMembershipLemmas)
{
membershipLemmaManager.AddAxiomMembershipLemmas(methodData.Axioms);
}
}
if (config.generateFunctions)
{
decls.Add(GetFunctionDeclarationsIsa(methodData.Functions));
if (generateMembershipLemmas)
{
membershipLemmaManager.AddFunctionMembershipLemmas(methodData.Functions);
}
}
if (config.generateGlobalsAndConstants)
{
decls.Add(GetVariableDeclarationsIsa("globals", methodData.GlobalVars));
decls.Add(GetVariableDeclarationsIsa("constants", methodData.Constants));
}
if (generateMembershipLemmas)
{
membershipLemmaManager.AddVariableMembershipLemmas(methodData.GlobalVars, VarKind.Global);
membershipLemmaManager.AddVariableMembershipLemmas(methodData.Constants, VarKind.Constant);
decls.AddRange(membershipLemmaManager.OuterDecls());
}
if (config.specsConfig != SpecsConfig.None)
{
DefDecl methodDef = MethodDefinition(membershipLemmaManager, methodData, config.specsConfig);
decls.Add(methodDef);
}
return(membershipLemmaManager);
}
public static LocaleDecl ConvertVC(
string localeName,
VCExpr vc,
IEnumerable <VCExpr> vcAxioms,
IActiveDeclGenerator activeDeclGenerator,
Boogie2VCExprTranslator translator,
TypeAxiomBuilderPremisses axiomBuilder,
BoogieMethodData methodData,
CFGRepr cfg,
out VCInstantiation <Block> vcinst,
out VCInstantiation <VCExpr> vcinstAxiom,
out IVCVarFunTranslator vcTranslator,
out IEnumerable <Function> vcTypeFunctions)
{
var vcLet = vc as VCExprLet;
Contract.Assert(vcLet != null);
var uniqueNamer = new IsaUniqueNamer();
var blockToVC = VCBlockExtractor.BlockToVCMapping(vcLet, cfg);
var declCollector = new VCFunDeclCollector();
var funToVCfun =
declCollector.CollectFunDeclarations(new List <VCExpr> {
vc
}.Concat(vcAxioms), methodData.Functions);
IVCVarFunTranslator varTranslator =
new VCVarFunTranslator(methodData.AllVariables(), funToVCfun, translator, axiomBuilder);
var activeDeclsPerBlock =
activeDeclGenerator.GetActiveDeclsPerBlock(blockToVC, varTranslator, cfg, out var blockToNewVars);
#region temporary: extend vc instantiation to support vc functions
IList <Function> otherFunctions = new List <Function>();
ISet <Function> otherFunctionsSet = new HashSet <Function>();
foreach (var decl in activeDeclsPerBlock[cfg.entry])
{
if (decl is Function fun && !varTranslator.TranslateBoogieFunction(fun, out _))
{
otherFunctions.Add(fun);
otherFunctionsSet.Add(fun);
}
}
//also record functions that are used elswhere (type axiom related functions)
var collector = new VCExprDeclCollector();
var vcExprs = vcAxioms.ToList();
foreach (var ax in vcExprs)
{
var decls = collector.CollectNamedDeclarations(ax, varTranslator);
foreach (var d in decls)
{
if (d is Function fun && !varTranslator.TranslateBoogieFunction(fun, out _) &&
!otherFunctions.Contains(d))
{
otherFunctions.Add(fun);
}
}
}
#endregion
IDictionary <Block, IList <NamedDeclaration> > activeDeclsPerBlockSorted =
SortActiveDecls(activeDeclsPerBlock, methodData.Functions.Union(otherFunctions), varTranslator,
out var activeVarsPerBlock);
var blockToNewVCVars = ConvertVariableToVCExpr(blockToNewVars, varTranslator);
var blockToIsaTranslator = new VCBlockToIsaTranslator(uniqueNamer);
var blockToVCExpr =
blockToIsaTranslator.IsaDefsFromVC(blockToVC, activeVarsPerBlock, cfg, blockToNewVCVars);
//add vc definitions of blocks in correct order
IList <OuterDecl> vcOuterDecls = new List <OuterDecl>();
foreach (var block in cfg.GetBlocksBackwards())
{
vcOuterDecls.Add(blockToVCExpr[block]);
}
vcinst = new VCInstantiation <Block>(blockToVCExpr, activeDeclsPerBlockSorted, localeName);
/*
*
* //reason for using second reference: cannot use out parameters in lambda expressions
* var vcinstInternal = vcinst;
*
* LemmaDecl vcCorrectLemma = new LemmaDecl("vc_correct",
* new TermApp(vcinstInternal.GetVCObjRef(cfg.entry, false),
* activeVarsPerBlock[cfg.entry].Select(v => (Term) IsaCommonTerms.TermIdentFromName(uniqueNamer.GetName(v, v.Name))).ToList()),
* new Proof(
* new List<string>() {
* "apply (simp only: " +
* cfg.GetBlocksForwards().Select(b => vcinstInternal.GetVCObjNameRef(b, false) + "_def").Concat(" ")
+ ")",
+ "oops"
+ }
+ ));
+
+ vcOuterDecls.Add(vcCorrectLemma);
*/
//axioms
var activeDeclsPerAxiom = VCInstAxioms(vcExprs, varTranslator);
IDictionary <VCExpr, IList <NamedDeclaration> > activeDeclsPerAxiomSorted =
SortActiveDecls(activeDeclsPerAxiom, methodData.Functions.Union(otherFunctions), varTranslator,
out var activeVarsPerAxiom);
var axiomToDef = new Dictionary <VCExpr, DefDecl>();
var vcExprIsaTranslator = new VCExprToIsaTranslator(uniqueNamer);
if (activeDeclsPerAxiomSorted.Count != vcExprs.Count())
{
throw new ProofGenUnexpectedStateException(typeof(VCToIsaInterface), "count not in-sync");
}
var axId = 0;
foreach (var vcAx in activeDeclsPerAxiomSorted.Keys)
{
IList <Term> args = activeVarsPerAxiom[vcAx].Select(v => vcExprIsaTranslator.Translate(v)).ToList();
var rhs = vcExprIsaTranslator.Translate(vcAx);
var def = new DefDecl("vcax_" + axId, new Tuple <IList <Term>, Term>(args, rhs));
axiomToDef.Add(vcAx, def);
axId++;
}
vcinstAxiom = new VCInstantiation <VCExpr>(axiomToDef, activeDeclsPerAxiomSorted, localeName);
vcOuterDecls.AddRange(axiomToDef.Values);
var vcFunctions = methodData.Functions.Where(f => varTranslator.TranslateBoogieFunction(f, out var result))
.Select(f =>
{
if (varTranslator.TranslateBoogieFunction(f, out var result))
{
return(result);
}
throw new InvalidOperationException();
}).Union(otherFunctions);
vcTranslator = varTranslator;
vcTypeFunctions = otherFunctions;
return(new LocaleDecl(localeName, ContextElem.CreateWithFixedVars(GetVarsInVC(vcFunctions, uniqueNamer)),
vcOuterDecls));
}
public static Theory ProgramToVcProof(
string theoryName,
bool generateEndToEndProof,
CFGRepr finalCfg,
CFGRepr afterPassificationCfg,
IDictionary <Block, Block> afterPassiveToFinalBlock,
IDictionary <Block, Block> afterPassiveToOrigBlock,
IProgramAccessor passiveProgAccess,
IProgramAccessor beforePassiveProgAccess,
BoogieMethodData methodData,
ProgramVcProofData vcProofData,
IVariableTranslationFactory varFactory,
TypePremiseEraserFactory eraserFactory,
VCExpressionGenerator gen,
out Term vcAssm,
out LemmaDecl endToEndLemma)
{
var lemmaNamer = new IsaUniqueNamer();
var passiveLemmaManager = new VcPhaseLemmaManager(
vcProofData.VcBoogieInfo.VcInst,
methodData,
vcProofData.VcFunctions,
passiveProgAccess.BlockInfo(),
varFactory);
var afterPassiveReachableBlocks = ReachableBlocks(afterPassificationCfg);
var finalProgramLemmas =
GenerateVCLemmas(afterPassificationCfg, finalCfg, afterPassiveToFinalBlock, afterPassiveToOrigBlock,
afterPassiveReachableBlocks, passiveLemmaManager, vcProofData.VcHintManager, lemmaNamer);
var cfgProgramLemmas =
GenerateCfgLemmas(afterPassificationCfg, finalCfg, afterPassiveToFinalBlock,
afterPassiveReachableBlocks, finalProgramLemmas, passiveLemmaManager, passiveProgAccess.CfgDecl(),
lemmaNamer);
var afterPassificationDecls = new List <OuterDecl>();
foreach (var v in finalProgramLemmas.Values)
{
afterPassificationDecls.AddRange(v);
}
afterPassificationDecls.AddRange(cfgProgramLemmas.Values);
var afterPassificationLocale =
GenerateLocale("passification", passiveLemmaManager, afterPassificationDecls);
var passiveOuterDecls = new List <OuterDecl> {
vcProofData.VcLocale
};
passiveOuterDecls.Add(afterPassificationLocale);
//generate axiom
var axiomUniqueNamer = new IsaUniqueNamer();
var axId = 0;
var axiomToLemma = new Dictionary <Axiom, OuterDecl>();
var vcRewriteLemmaGen =
new VcRewriteLemmaGen(eraserFactory, VCExprToIsaTranslator.CreateNameBasedTranslator(new IsaUniqueNamer()));
var vcAxiomLemmaManager = new VcAxiomLemmaManager(
vcProofData.VcBoogieInfo.VcInstAxiom,
methodData,
vcProofData.VcFunctions,
vcRewriteLemmaGen, varFactory);
var axiomLocaleRequiredDecls = new List <OuterDecl>();
foreach (var axiom in vcProofData.VcBoogieInfo.VcAxiomsInfo)
{
if (axiom is VcBoogieAxiomInfo vcBoogieAxiom)
{
var axiomVcLemma =
vcAxiomLemmaManager.AxiomVcLemma(
axiomUniqueNamer.GetName(axiom, "axiom_vc_" + axId),
vcBoogieAxiom.Axiom,
vcBoogieAxiom.Expr,
out var requiredDecls);
axiomToLemma.Add(vcBoogieAxiom.Axiom, axiomVcLemma);
axiomLocaleRequiredDecls.AddRange(requiredDecls);
}
}
/* we add the required declarations for the axiom locale to the outer theory, since the axiom locale fixes variables that could clash
* with the declarations */
passiveOuterDecls.AddRange(axiomLocaleRequiredDecls);
var axiomLocale = GenerateLocale("axioms", vcAxiomLemmaManager, axiomToLemma.Values.ToList());
passiveOuterDecls.Add(axiomLocale);
if (generateEndToEndProof)
{
var endToEnd = new EndToEndVCProof(
methodData,
passiveProgAccess,
vcProofData.VcFunctions,
vcProofData.VcBoogieInfo,
afterPassificationCfg,
finalCfg,
afterPassificationLocale.Name + "." + cfgProgramLemmas[afterPassificationCfg.entry].Name,
axiomLocale.Name,
ax => axiomLocale.Name + "." + axiomToLemma[ax].Name,
varFactory,
vcProofData.VcTranslator,
eraserFactory,
gen);
passiveOuterDecls.AddRange(endToEnd.GenerateProof(out vcAssm, out endToEndLemma));
}
else
{
vcAssm = null;
endToEndLemma = null;
}
return
(new Theory(theoryName,
new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", "Boogie_Lang.VCHints", "Boogie_Lang.VCPhaseML",
passiveProgAccess.TheoryName(), beforePassiveProgAccess.TheoryName()
},
passiveOuterDecls));
}
//cfg must be acyclic
public static IDictionary <Block, IEnumerable <Variable> > ComputeLiveVariables(CFGRepr cfg,
BoogieMethodData methodData)
{
var liveVarsBefore = new Dictionary <Block, IEnumerable <Variable> >();
var allVarsSet = new HashSet <Variable>(methodData.AllVariables());
foreach (var b in cfg.GetBlocksBackwards())
{
var bCurLiveVars = new HashSet <Variable>();
foreach (var bSuc in cfg.GetSuccessorBlocks(b))
{
bCurLiveVars.UnionWith(liveVarsBefore[bSuc]);
}
for (var idx = b.cmds.Count - 1; idx >= 0; idx--)
{
UpdateLiveSet(b.cmds[idx], bCurLiveVars);
}
//due to the VariableCollector's implementation bound variables may also have been included
bCurLiveVars.RemoveWhere(v => !allVarsSet.Contains(v));
liveVarsBefore.Add(b, bCurLiveVars);
}
return(liveVarsBefore);
}
/**
* cases:
* 1) is loop head block
* 2) is back edge block
* 3) successor is loop head block
*
* any combination is possible
*/
public static Theory CfgToDagProof(
PhasesTheories phasesTheories,
bool generateEndToEndLemma,
Term vcAssm,
CFGRepr beforeDagCfg,
CFGRepr afterDagCfg,
Block afterUniqueExit,
BoogieMethodData beforeDagData,
CfgToDagHintManager hintManager,
IDictionary <Block, Block> beforeToAfter,
IProgramAccessor beforeDagProgAccess,
IProgramAccessor afterDagProgAccess,
IVariableTranslationFactory varFactory)
{
var afterToBefore = beforeToAfter.InverseDict();
//track mapping from blocks to loops that the block is contained in and for which it is not the loop head
IDictionary <Block, IList <Block> > blocksToLoops = new Dictionary <Block, IList <Block> >();
foreach (var afterBlock in afterDagCfg.GetBlocksBackwards())
{
if (afterToBefore.TryGetValue(afterBlock, out var beforeBlock))
{
var loops = new HashSet <Block>();
foreach (var bSuc in beforeDagCfg.GetSuccessorBlocks(beforeBlock))
{
if (blocksToLoops.TryGetValue(bSuc, out var loopsSuc))
{
//if successor inside of a loop L and the block is not the loop head of L, then the block is also inside L
foreach (var loopSuc in loopsSuc)
{
if (!loopSuc.Equals(beforeBlock))
{
loops.Add(loopSuc);
}
}
}
}
/* a node is inside all loops for which it has an out-going backedge
* if a node has a backedge to itself (i.e., it is also a loop head), then we do not add this loop
*/
if (hintManager.TryIsBackedgeNode(beforeBlock, out var backedgeLoops))
{
foreach (var backedgeLoop in backedgeLoops)
{
if (beforeBlock != backedgeLoop)
{
loops.Add(backedgeLoop);
}
}
}
var loopsList = loops.ToList();
blocksToLoops.Add(beforeBlock, loopsList);
}
}
var varContextName = "\\<Lambda>1";
var varContextAbbrev = new AbbreviationDecl(
varContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), beforeDagProgAccess.VarContext())
);
var funContextWfName = "Wf_Fun";
var boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName(varContextName),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.EmptyList);
var lemmaManager = new CfgToDagLemmaManager(
beforeDagProgAccess,
afterDagProgAccess,
boogieContext,
afterDagCfg,
funContextWfName,
hintManager,
blocksToLoops,
beforeToAfter,
beforeDagData,
afterUniqueExit,
varFactory);
var lemmaNamer = new IsaUniqueNamer();
var outerDecls = new List <OuterDecl>();
outerDecls.Add(varContextAbbrev);
outerDecls.Add(new DeclareDecl("Nat.One_nat_def[simp del]"));
if (afterUniqueExit != null)
{
outerDecls.AddRange(lemmaManager.UnifiedExitLemma(GetCfgLemmaName(afterUniqueExit, lemmaNamer)));
}
foreach (var afterBlock in afterDagCfg.GetBlocksBackwards())
{
if (afterToBefore.TryGetValue(afterBlock, out var beforeBlock))
{
//if the node's only edge is a backedge, then an "assume false" will be added
var singleCutEdge = hintManager.TryIsBackedgeNode(beforeBlock, out var _) &&
beforeDagCfg.NumOfSuccessors(beforeBlock) == 1;
var(localLemmas, cfgLemma) =
lemmaManager.BlockLemma(
beforeBlock,
afterBlock,
beforeDagCfg.GetSuccessorBlocks(beforeBlock),
block => GetLemmaName(block, lemmaNamer),
block => GetCfgLemmaName(block, lemmaNamer),
singleCutEdge
);
outerDecls.AddRange(localLemmas);
outerDecls.Add(cfgLemma);
}
else
{
//block was added as part of transformation
if (afterBlock == afterDagCfg.entry)
{
//entry lemma handled elsewhere
continue;
}
var afterBlockSuccessors = afterDagCfg.GetSuccessorBlocks(afterBlock);
var afterBlockSuccessorsList = afterBlockSuccessors.ToList();
if (!afterBlockSuccessorsList.Any())
{
//this must be the unique node
if (afterUniqueExit == null)
{
throw new ProofGenUnexpectedStateException(
"unique exit block added, but only exit block existed before cfg-to-dag");
}
continue;
}
if (afterBlockSuccessorsList.Count != 1)
{
throw new ProofGenUnexpectedStateException(
"Block added in CFG-to-DAG phase does not have a unique successor");
}
var afterUniqueSuc = afterBlockSuccessorsList.First();
if (afterToBefore.TryGetValue(afterUniqueSuc, out var beforeUniqueSuc))
{
hintManager.IsLoopHead(beforeUniqueSuc, out var hint);
var lemma = lemmaManager.NewBlockLemma(
GetCfgLemmaName(afterBlock, lemmaNamer),
afterBlock,
afterUniqueSuc,
hint
);
outerDecls.Add(lemma);
}
else if (hintManager.IsNewBackedgeBlock(afterBlock, out var loopHeadHint))
{
if (afterDagCfg.GetSuccessorBlocks(afterUniqueSuc).Any())
{
throw new ProofGenUnexpectedStateException(
"New backedge node has successor that is not the exit node.");
}
//afterUniqueSuc is a successor to a backedge node for which all edges were eliminated
var lemma = lemmaManager.NewBlockLemma(
GetCfgLemmaName(afterBlock, lemmaNamer),
afterBlock,
null,
loopHeadHint
);
outerDecls.Add(lemma);
}
else
{
throw new ProofGenUnexpectedStateException(
"CFG-to-DAG: Unique successor of added block cannot be mapped to original block");
}
}
}
var entryLemma = lemmaManager.EntryLemma("entry_lemma", beforeDagCfg.entry, afterDagCfg.entry,
b => GetCfgLemmaName(b, lemmaNamer));
outerDecls.Add(entryLemma);
var absValType = new VarType("a");
var cfgToDagLemmasLocale = new LocaleDecl(
"cfg_to_dag_lemmas",
new ContextElem(
new List <Tuple <TermIdent, TypeIsa> >
{
Tuple.Create((TermIdent)boogieContext.absValTyMap,
IsaBoogieType.AbstractValueTyFunType(absValType)),
Tuple.Create((TermIdent)boogieContext.funContext, IsaBoogieType.FunInterpType(absValType))
},
new List <Term>
{
IsaBoogieTerm.FunInterpWf(boogieContext.absValTyMap, beforeDagProgAccess.FunctionsDecl(),
boogieContext.funContext)
},
new List <string> {
funContextWfName
}
),
outerDecls
);
var theoryOuterDecls = new List <OuterDecl>();
theoryOuterDecls.Add(cfgToDagLemmasLocale);
if (generateEndToEndLemma)
{
var endToEndManager = new CfgToDagEndToEnd();
var endToEndDecls = endToEndManager.EndToEndProof(
cfgToDagLemmasLocale.Name + "." + entryLemma.Name,
phasesTheories.EndToEndLemmaName(PhasesTheories.Phase.Passification, true),
vcAssm,
beforeDagProgAccess,
beforeDagCfg
);
theoryOuterDecls.AddRange(endToEndDecls);
}
return(new Theory(
phasesTheories.TheoryName(PhasesTheories.Phase.CfgToDag),
new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", "Boogie_Lang.BackedgeElim", "Boogie_Lang.TypingML",
beforeDagProgAccess.TheoryName(),
afterDagProgAccess.TheoryName(), phasesTheories.TheoryName(PhasesTheories.Phase.Passification),
phasesTheories.TheoryName(PhasesTheories.Phase.Vc)
},
theoryOuterDecls
));
}
