/// <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>
/// Generate all proofs for the current procedure.
/// </summary>
/// <param name="vc">WP of the procedure body</param>
/// <param name="vcAxioms">VC assumptions for the Boogie axioms</param>
/// <param name="typeAxioms">VC assumptions for the Boogie type encoding</param>
/// <param name="typeAxiomInfo">Hints about the type encoding</param>
/// <param name="gen"></param>
/// <param name="translator"></param>
/// <param name="axiomBuilder"></param>
/// <exception cref="ArgumentException">
/// axiom builder must be null iff types are not erased (since no polymorphism in vc), otherwise exception is
/// thrown
/// </exception>
public static void VCGenerateAllProofs(
VCExpr vc,
VCExpr vcAxioms,
VCExpr typeAxioms,
List <VCAxiomInfo> typeAxiomInfo,
VCExpressionGenerator gen,
Boogie2VCExprTranslator translator,
TypeAxiomBuilderPremisses axiomBuilder)
{
var uniqueNamer = new IsaUniqueNamer();
var theories = new List <Theory>();
if (axiomBuilder == null && typeAxioms != null)
{
throw new ArgumentException("type axioms can only be null if axiom builder is null");
}
/* Since in the proofs calls are desugared, there can be more variables in "beforePassiveData". If only
* the progam should be generaed, then these variables should be ignored. */
var mainData = CommandLineOptions.Clo.GenerateIsaProgNoProofs ? beforeDagData : beforePassiveData;
var fixedVarTranslation2 = new DeBruijnFixedVarTranslation(mainData);
var fixedTyVarTranslation2 = new DeBruijnFixedTVarTranslation(mainData);
var varTranslationFactory2 =
new DeBruijnVarFactory(fixedVarTranslation2, fixedTyVarTranslation2, boogieGlobalData);
#region before cfg to dag program
var beforeCfgToDagTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_before_cfg_to_dag_prog");
//Hack: specs config used to distinguish between all (free + checks) (--> expression tuples) or just checked (no tuples)
var specsConfig = CommandLineOptions.Clo.GenerateIsaProgNoProofs ? SpecsConfig.All : SpecsConfig.AllPreCheckedPost;
var beforeCfgToDagConfig = new IsaProgramGeneratorConfig(globalDataProgAccess, false, false, false, true, specsConfig, true);
var beforeCfgToDagProgAccess = new IsaProgramGenerator().GetIsaProgram(
beforeCfgToDagTheoryName,
afterPassificationImpl.Name,
mainData, beforeCfgToDagConfig, varTranslationFactory2,
beforeDagCfg,
out var programDeclsBeforeCfgToDag,
!CommandLineOptions.Clo.GenerateIsaProgNoProofs);
procNameToTopLevelPrograms.Add(afterPassificationImpl.Proc.Name, beforeCfgToDagProgAccess);
var beforeCfgToDagProgTheory = new Theory(beforeCfgToDagTheoryName,
new List <string> {
"Boogie_Lang.Semantics", "Boogie_Lang.TypeSafety", "Boogie_Lang.Util", "\"../" + globalDataProgAccess.TheoryName() + "\""
},
programDeclsBeforeCfgToDag);
theories.Add(beforeCfgToDagProgTheory);
#endregion
if (CommandLineOptions.Clo.GenerateIsaProgNoProofs)
{
StoreResult("program_" + afterPassificationImpl.Proc.Name, theories);
return;
}
#region before passive program
var beforePassiveProgTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_before_passive_prog");
var beforePassiveConfig =
new IsaProgramGeneratorConfig(beforeCfgToDagProgAccess, false, false, false, false, SpecsConfig.None, false);
var beforePassiveProgAccess = new IsaProgramGenerator().GetIsaProgram(beforePassiveProgTheoryName,
afterPassificationImpl.Name,
mainData, beforePassiveConfig, varTranslationFactory2,
beforePassificationCfg,
out var programDeclsBeforePassive,
!CommandLineOptions.Clo.GenerateIsaProgNoProofs);
#endregion
var vcAllAxioms = AxiomHandler.AxiomInfo(
axiomBuilder != null,
boogieGlobalData.Axioms,
vcAxioms,
typeAxioms,
typeAxiomInfo,
out var allAxiomsInfo);
var vcLocale = VCToIsaInterface.ConvertVC(
"vc",
vc,
vcAllAxioms,
new StandardActiveDecl(),
translator,
axiomBuilder,
finalProgData,
afterUnreachablePruningCfg,
out var vcinst,
out var vcinstAxiom,
out var vcTranslator,
out var vcFunctions);
//use global version map for translation
var fixedVarTranslation = new SimpleFixedVarTranslation(globalVersionMap);
var fixedTyVarTranslation = new DeBruijnFixedTVarTranslation(finalProgData);
varTranslationFactory =
new DeBruijnVarFactory(fixedVarTranslation, fixedTyVarTranslation, boogieGlobalData);
var finalProgTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_passive_prog");
var passiveProgConfig =
new IsaProgramGeneratorConfig(beforePassiveProgAccess, false, false, false, true, SpecsConfig.None, false);
var passiveProgAccess = new IsaProgramGenerator().GetIsaProgram(finalProgTheoryName,
afterPassificationImpl.Name,
finalProgData, passiveProgConfig, varTranslationFactory,
//we use the CFG before the peep-hole transformations, so that we can directly use the VC to program proof in the passification phase
afterPassificationCfg,
out var programDecls,
!CommandLineOptions.Clo.GenerateIsaProgNoProofs);
var finalProgTheory =
new Theory(finalProgTheoryName,
new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", beforePassiveProgAccess.TheoryName()
},
programDecls);
theories.Add(finalProgTheory);
var vcBoogieInfo = new VcBoogieInfo(vcinst, vcinstAxiom, vcAllAxioms, allAxiomsInfo);
var vcProofData = new ProgramVcProofData(
vcFunctions,
vcBoogieInfo,
vcHintManager,
vcLocale,
vcTranslator
);
var phasesTheories = new PhasesTheories(afterPassificationImpl.Name);
var theoryPassive = VcPhaseManager.ProgramToVcProof(
phasesTheories.TheoryName(PhasesTheories.Phase.Vc),
_proofGenConfig.GenerateVcE2E,
afterUnreachablePruningCfg,
afterPassificationCfg,
afterPassificationToAfterUnreachableBlock,
afterPassificationToOrigBlock,
passiveProgAccess,
beforePassiveProgAccess,
finalProgData,
vcProofData,
varTranslationFactory,
typePremiseEraserFactory,
gen,
out var vcAssm,
out var endToEndLemma
);
theories.Add(theoryPassive);
#region before passive
var passificationProgTheory = new Theory(beforePassiveProgTheoryName,
new List <string> {
"Boogie_Lang.Semantics", "Boogie_Lang.Util", beforeCfgToDagTheoryName
},
programDeclsBeforePassive);
theories.Add(passificationProgTheory);
/*
* Console.WriteLine("Passive prog mapping: " + fixedVarTranslation.OutputMapping());
* Console.WriteLine("Before passive prog mapping: " + fixedVarTranslation2.OutputMapping());
*/
var passificationProofTheory = PassificationManager.PassificationProof(
phasesTheories.TheoryName(PhasesTheories.Phase.Passification),
theoryPassive.TheoryName,
_proofGenConfig.GeneratePassifE2E,
endToEndLemma,
vcAssm,
beforePassificationCfg,
beforePassiveToAfterPassiveBlock,
passiveRelationGen,
beforePassiveProgAccess,
passiveProgAccess,
mainData,
varTranslationFactory2,
varTranslationFactory
);
theories.Add(passificationProofTheory);
#endregion
#region cfg to dag
var uniqueExitBlock =
uniqueExitBlockOrig != null
? beforePassiveOrigBlock.First(kv => kv.Value == uniqueExitBlockOrig).Key
: null;
var cfgToDagProofTheory = CfgToDagManager.CfgToDagProof(
phasesTheories,
_proofGenConfig.GenerateCfgDagE2E,
vcAssm,
beforeDagCfg,
beforePassificationCfg,
uniqueExitBlock,
beforeDagData,
cfgToDagHintManager,
beforeDagAfterDagBlock,
beforeCfgToDagProgAccess,
beforePassiveProgAccess,
varTranslationFactory2);
theories.Add(cfgToDagProofTheory);
#endregion
StoreResult(afterPassificationImpl.Proc.Name, theories);
}