Пример #1
0
        private Dictionary <Variable, Expr> PassifyProgram(Implementation impl, ModelViewInfo mvInfo)
        {
            Contract.Requires(impl != null);
            Contract.Requires(mvInfo != null);
            Contract.Requires(this.exitBlock != null);
            Contract.Ensures(Contract.Result <Hashtable>() != null);

            CurrentLocalVariables = impl.LocVars;
            return(Convert2PassiveCmd(impl, mvInfo));
            //return new Hashtable();
        }
Пример #2
0
        /// <summary>
        /// As a side effect, updates "this.parent.CumulativeAssertionCount".
        /// </summary>
        public void BeginCheck(Checker checker, VerifierCallback callback, ModelViewInfo mvInfo, int no, int timeout, int rlimit)
        {
            Contract.Requires(checker != null);
            Contract.Requires(callback != null);

            splitNum = no;

            impl.Blocks = blocks;

            this.checker = checker;

            Dictionary <int, Absy> label2absy = new Dictionary <int, Absy>();

            ProverContext           ctx = checker.TheoremProver.Context;
            Boogie2VCExprTranslator bet = ctx.BoogieExprTranslator;
            var cc = new VCGen.CodeExprConversionClosure(label2absy, ctx);

            bet.SetCodeExprConverter(cc.CodeExprToVerificationCondition);

            var    exprGen = ctx.ExprGen;
            VCExpr controlFlowVariableExpr = exprGen.Integer(BigNum.ZERO);

            VCExpr vc = parent.GenerateVCAux(impl, controlFlowVariableExpr, label2absy, checker.TheoremProver.Context);

            Contract.Assert(vc != null);

            vc = QuantifierInstantiationEngine.Instantiate(impl, exprGen, bet, vc);

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

            vc       = exprGen.Implies(eqExpr, vc);
            reporter = new VCGen.ErrorReporter(gotoCmdOrigins, label2absy, impl.Blocks, parent.debugInfos, callback,
                                               mvInfo, this.Checker.TheoremProver.Context, parent.program);

            if (CommandLineOptions.Clo.TraceVerify && no >= 0)
            {
                Console.WriteLine("-- after split #{0}", no);
                Print();
            }

            string desc = cce.NonNull(impl.Name);

            if (no >= 0)
            {
                desc += "_split" + no;
            }
            checker.BeginCheck(desc, vc, reporter, timeout, rlimit, impl.RandomSeed);
        }
Пример #3
0
        /// <summary>
        /// As a side effect, updates "this.parent.CumulativeAssertionCount".
        /// </summary>
        public void BeginCheck(Checker checker, VerifierCallback callback, ModelViewInfo mvInfo, int no, int timeout, int rlimit)
        {
            Contract.Requires(checker != null);
            Contract.Requires(callback != null);

            splitNo = no;

            impl.Blocks = blocks;

            this.checker = checker;

            Dictionary <int, Absy> label2absy = new Dictionary <int, Absy>();

            ProverContext           ctx = checker.TheoremProver.Context;
            Boogie2VCExprTranslator bet = ctx.BoogieExprTranslator;
            var cc = new VCGen.CodeExprConversionClosure(label2absy, ctx);

            bet.SetCodeExprConverter(cc.CodeExprToVerificationCondition);

            var    exprGen = ctx.ExprGen;
            VCExpr controlFlowVariableExpr = exprGen.Integer(BigNum.ZERO);

            #region proofgen
            TypePremiseEraserFactory typePremiseEraserFactory;
            switch (CommandLineOptions.Clo.TypeEncodingMethod)
            {
            case CommandLineOptions.TypeEncoding.Predicates:
                typePremiseEraserFactory = new TypePremiseEraserFactory(checker.VCExprGen, bet, true);
                break;

            case CommandLineOptions.TypeEncoding.Monomorphic:
                typePremiseEraserFactory = new TypePremiseEraserFactory(checker.VCExprGen, bet, false);
                break;

            default:
                throw new NotImplementedException();
            }
            ProofGenerationLayer.SetTypeEraserFactory(typePremiseEraserFactory);
            #endregion

            /* PROOF GEN: we pass "null" as the control flow variable expression, such that labels are not produced as they are
             * not relevant for proof generation of programs that verify */
            VCExpr vc = parent.GenerateVCAux(impl, null, label2absy, checker.TheoremProver.Context);
            Contract.Assert(vc != null);

            #region proofgen
            if (!(ctx is DeclFreeProverContext))
            {
                throw new NotImplementedException("Proof Generation only supports DeclFreeProverContext as context.");
            }

            var declFreeProverContext = ctx as DeclFreeProverContext;
            var premiseEraserProvider = typePremiseEraserFactory?.NewEraser();

            VCExpr eraseVC(VCExpr vc, int polarity)
            {
                return(!premiseEraserProvider.ProgramIsPolymorphic ? vc : premiseEraserProvider.EraseAndSortLet(vc, polarity));
            }

            VCExpr erasedVC     = eraseVC(vc, 1);
            VCExpr erasedAxioms = eraseVC(declFreeProverContext.Axioms, -1);

            VCExpr             typeAxioms   = null;
            List <VCAxiomInfo> vcAxiomsInfo = null;
            if (premiseEraserProvider.ProgramIsPolymorphic)
            {
                typeAxioms = premiseEraserProvider.AxiomBuilder.GetNewAxiomsAndInfo(out vcAxiomsInfo);
            }

            ProofGenerationLayer.VCGenerateAllProofs(
                erasedVC,
                erasedAxioms,
                typeAxioms,
                vcAxiomsInfo,
                checker.TheoremProver.VCExprGen,
                checker.TheoremProver.Context.BoogieExprTranslator,
                premiseEraserProvider?.AxiomBuilder);
            #endregion

            /* PROOF GEN: comment out label specific parts
             * 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)));
             * vc = exprGen.Implies(eqExpr, vc);
             */
            reporter = new VCGen.ErrorReporter(gotoCmdOrigins, label2absy, impl.Blocks, parent.debugInfos, callback,
                                               mvInfo, this.Checker.TheoremProver.Context, parent.program);

            if (CommandLineOptions.Clo.TraceVerify && no >= 0)
            {
                Console.WriteLine("-- after split #{0}", no);
                Print();
            }

            string desc = cce.NonNull(impl.Name);
            if (no >= 0)
            {
                desc += "_split" + no;
            }
            checker.BeginCheck(desc, vc, reporter, timeout, rlimit, impl.RandomSeed);
        }