/// <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); }