public override bool SuggestAnalysisSpecificPostconditions( ContractInferenceManager inferenceManager, IFixpointInfo <APC, ArrayState> fixpointInfo, List <BoxedExpression> postconditions) { return(false); }
public override bool SuggestAnalysisSpecificPostconditions( ContractInferenceManager inferenceManager, IFixpointInfo <APC, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> > fixpointInfo, List <BoxedExpression> postconditions) { return(false); }
public override void SuggestPrecondition(ContractInferenceManager inferenceManager, IFixpointInfo <APC, ArrayState> fixpointInfo) { Contract.Assume(inferenceManager != null); ArrayState postState; var pc = this.Context.MethodContext.CFG.NormalExit; if (PreState(pc, fixpointInfo, out postState)) { Contract.Assume(postState != null); var mySubState = Select(postState); if (mySubState.IsNormal()) { foreach (var segmentation in mySubState.Elements) { Contract.Assume(segmentation.Key != null); Contract.Assume(segmentation.Value != null); if (segmentation.Value.IsNormal()) { foreach (var pre in GetForAllVisibleOutsideOfTheMethod(segmentation.Key, segmentation.Value)) { var pcAfterRequires = this.Context.MethodContext.CFG.EntryAfterRequires; inferenceManager.AddPreconditionOrAssume(new EmptyProofObligation(pcAfterRequires), new List <BoxedExpression>() { pre }, ProofOutcome.Top); } } } } } }
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query) { Contract.Requires(output != null); Contract.Requires(inferenceManager != null); Contract.Requires(query != null); throw new NotImplementedException(); }
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query) { var result = 0.0; // is this used? foreach (var obl in this.underlying) { obl.Validate(output, inferenceManager, query); } return(result); }
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query) { var options = output.LogOptions; var total_obligations = 0; var validated = 0; var outcomes = new List <Pair <ProofObligation, ProofOutcome> >(); foreach (var obl in obligations) { if (obl.IsAlreadyValidated) { continue; } var outcome = obl.Validate(query, inferenceManager, output); // Discard unreached implicit obligations in contracts if (outcome == ProofOutcome.Bottom && obl.PC.InsideContract) { continue; } total_obligations++; if (outcome == ProofOutcome.True) { validated++; } this.stats.Add(outcome); outcomes.Add(new Pair <ProofObligation, ProofOutcome>(obl, outcome)); } foreach (var pair in outcomes) { if (options.PrintOutcome(pair.Two)) { pair.One.EmitOutcome(pair.Two, output); } } return(total_obligations != 0 ? ((double)validated) / total_obligations : 1.0); }
public ProofOutcome Validate(IFactQuery <Expression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { ProofOutcome outcome; if (query.IsUnreachable(this.PCForValidation)) { outcome = ProofOutcome.Bottom; } else { outcome = ValidateInternal(query, inferenceManager, output); if (outcome == ProofOutcome.Top || outcome == ProofOutcome.False) { if (this.Condition != null && this.TryInferPrecondition && !output.IsMasked(this.GetWitness(outcome))) { InferredConditions inferredPreConditions; var inferencer = inferenceManager.PreCondition.Inference; if (inferencer.TryInferConditions(this, inferenceManager.CodeFixesManager, out inferredPreConditions)) { var context = inferredPreConditions.PushToContractManager(inferenceManager, inferencer.ShouldAddAssumeFalse, this, ref outcome, output.LogOptions); this.HasASufficientAndNecessaryCondition = inferredPreConditions.HasASufficientCondition; this.AdditionalInformationOnTheWarning.AddRange(context); } else if (inferencer.ShouldAddAssumeFalse) { inferenceManager.Assumptions.AddEntryAssumes(this, new BoxedExpression[] { BoxedExpression.ConstFalse }); } } } } this.Outcome = outcome; return(outcome); }
protected override ProofOutcome ValidateInternal(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { return(query.IsTrue(this.PC, this.condition)); }
protected override sealed ProofOutcome ValidateInternal(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { if (this.MethodDriver.Options.TraceChecks) { output.WriteLine("Validating proof obligation: {0}", this.Condition != null ? this.Condition.ToString() : "<null?>"); } var result = ValidateInternalSpecific(query, inferenceManager, output); if (result != ProofOutcome.Top) { return(result); } var condition = this.Condition; if (condition != null) { WeakestPreconditionProver.AdditionalInfo why; if (TryDischargeProofObligationWithWeakestPreconditions(condition, query, inferenceManager, output, out why)) { return(ProofOutcome.True); } else { this.AdditionalInformationOnTheWarning.AddRange(WarningContextFetcher.InferContext(this.PC, condition, this.Context, this.DecoderForMetaData.IsBoolean)); this.AdditionalInformationOnTheWarning.AddRange(why.GetWarningContexts()); } } return(ProofOutcome.Top); }
public override void SuggestPrecondition(ContractInferenceManager inferenceManager, IFixpointInfo <APC, ArrayState> fixpointinfo) { Contract.Assume(inferenceManager != null, "Assume for inheritance"); if ( !this.Options.LogOptions.SuggestRequiresPurityForArrays && !this.Options.LogOptions.PropagateRequiresPurityForArrays) { return; } ArrayState returnState; if (PreState(this.Context.MethodContext.CFG.NormalExit, fixpointinfo, out returnState)) { Contract.Assume(returnState != null); var mySubState = Select(returnState); #pragma warning disable 0219 var first = true; // used in the commented part below #pragma warning restore foreach (var element in mySubState.Elements) { #if false // Make it true to debug the content of the result state if (ContainsUnModifiedSegment(element.Value)) { if (first) { Console.WriteLine("Method: {0}", this.Context.MethodContext.CurrentMethod); first = false; } var arrayName = this.VariablesToPrettyNames(this.Context.MethodContext.CFG.EntryAfterRequires, element.Key); if (arrayName != null) { var preconditions = element.Value.PrettyPrint( arrayName, (var => this.VariablesToPrettyNames(this.Context.MethodContext.CFG.EntryAfterRequires, var)), (ael => this.PrettyPrint(arrayName, ael)) ); foreach (var str in preconditions) { output.WriteLine("Effect on the input array segment: {0}", str); } } } #endif var exp = ToBoxedExpression(this.Context.MethodContext.CFG.Entry, element.Key); var pre = PreconditionSuggestion.ExpressionInPreState(exp, this.Context, this.DecoderForMetaData, this.Context.MethodContext.CFG.EntryAfterRequires, allowedKinds: ExpressionInPreStateKind.MethodPrecondition); Contract.Assume(element.Value != null); if (pre != null && AllSegmentsUnmodified(element.Value) && !this.DecoderForContracts.IsPure(this.Context.MethodContext.CurrentMethod) ) { Parameter p; int pos; Contract.Assume(element.Key != null, "Assuming the precondition"); if (TryParameterFor(element.Key, out p, out pos) && !this.DecoderForMetaData.IsPure(this.Context.MethodContext.CurrentMethod, p)) { // TODO: wire those suggestions to the contract inference manager if (this.Options.LogOptions.SuggestRequiresPurityForArrays) { inferenceManager.Output.Suggestion(ClousotSuggestion.Kind.Requires, ClousotSuggestion.Kind.Requires.Message(), this.Context.MethodContext.CFG.EntryAfterRequires, string.Format("Consider adding the [Pure] attribute to the parameter {0}", pre.ToString()), null, ClousotSuggestion.ExtraSuggestionInfo.None); } if (this.Options.LogOptions.PropagateRequiresPurityForArrays && pos <= 64) { this.DecoderForMetaData.AddPure(this.Context.MethodContext.CurrentMethod, pos); } } } } } }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { // First, we check if arg != MinValue object value; if (!this.DecoderForMetaData.TryGetMinValueForType(this.typeOfArg, out value)) { return(ProofOutcome.Top); } var condition = this.Condition; if (condition != null) // this.Condition may return null { var result = query.IsTrue(this.PC, condition); if (result != ProofOutcome.Top) { return(result); } } // We check a sufficient condition: if arg is >= 0, then it is not the negation of a negative "extreme" var greaterThanZero = query.IsGreaterEqualToZero(this.PC, this.arg); return((greaterThanZero == ProofOutcome.True || greaterThanZero == ProofOutcome.Bottom) ? greaterThanZero : ProofOutcome.Top); }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { // We check the condition var condition = this.Condition; if (condition == null) { return(ProofOutcome.Top); } return(query.IsTrue(this.PC, condition)); }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { return(query.IsNonZero(this.PC, this.denominator)); }
private bool TryDischargeProofObligationWithWeakestPreconditions(BoxedExpression condition, IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output, out WeakestPreconditionProver.AdditionalInfo why) { var options = output.LogOptions; // Try to validate the assertion by WP inference if (options.UseWeakestPreconditions) { var driver = this.MethodDriver; bool messageAlreadyPrinted; if (driver.SyntacticComplexity.ShouldAvoidWPComputation(out messageAlreadyPrinted)) { if (!messageAlreadyPrinted) { output.WriteLine("Skipping backwards computation for this method ({0}) as cccheck thinks it will cause a timeout", driver.MetaDataDecoder.Name(driver.CurrentMethod)); } this.AdditionalInformationOnTheWarning.Add(new WarningContext(WarningContext.ContextType.WPSkippedBecauseAdaptiveAnalysis)); } else { var path = WeakestPreconditionProver.Discharge(this.PC, condition, options.MaxPathSize, this.MethodDriver, query, inferenceManager, out why); return(path == null); } } why = WeakestPreconditionProver.AdditionalInfo.None; return(false); }
virtual public void SuggestPrecondition(ContractInferenceManager inferenceManager, IFixpointInfo <APC, ArrayState> fixpointInfo) { // does nothing by default }
/// <summary> /// Does nothing, as a plugin as no fixpoint /// </summary> public override void SuggestPrecondition(ContractInferenceManager inferenceManager) { return; }
protected override ProofOutcome ValidateInternal(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { ProofOutcome outcome; if ((outcome = query.IsVariableDefinedForType(this.PC, this.value, this.type)) != ProofOutcome.Top) { return(outcome); } return(ProofOutcome.Top); }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { Contract.Assume(query != null, "should be a precondition"); if (this.uncheckable) { return(ProofOutcome.Top); } return(query.IsTrue(this.PC, condition)); }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { // Check if size >= 0 return(query.IsGreaterEqualToZero(this.PC, this.size)); }
public override bool SuggestAnalysisSpecificPostconditions(ContractInferenceManager inferenceManager, IFixpointInfo <APC, DisjunctiveRefinement> fixpointInfo, List <BoxedExpression> postconditions) { // does nothing return(false); }
/// <summary> /// If we cannot validate the precision of the operands, we try to suggest an explicit cast /// </summary> protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { var outcome = query.HaveSameFloatType(PC, this.left, this.right); switch (outcome) { case ProofOutcome.Top: { ConcreteFloat leftType, rightType; if (query.TryGetFloatType(this.PC, this.left, out leftType) && query.TryGetFloatType(this.PC, this.right, out rightType)) { APC conditionPC; if (!this.MethodDriver.AdditionalSyntacticInformation.VariableDefinitions.TryGetValue(this.var, out conditionPC)) { conditionPC = this.PC; } if (inferenceManager.CodeFixesManager.TrySuggestFloatingPointComparisonFix(this, conditionPC, this.left, this.right, leftType, rightType)) { // do something? Returning true seems a bad idea } } return(outcome); } default: { return(outcome); } } }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { // Check if expForIndex >= 0 return(query.IsGreaterEqualToZero(this.PC, index)); #if false // Try to use weakest preconditions if (result == ProofOutcome.Top) { if (CanAssumeLowerBoundPrecondition(output, this.index)) { result = ProofOutcome.True; } else { // if we have lb <= i, then we can suggest 0 <= lb // foreach (Variable lb in query.LowerBounds(this.PC, index, false)) { BoxedExpression lbbox = BoxedExpression.Var(lb); if (CanAssumeLowerBoundPrecondition(output, lbbox)) { result = ProofOutcome.True; } } } } return(result); #endif }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { object minValue; if (!this.DecoderForMetaData.TryGetMinValueForType(this.TypeOp1, out minValue)) { return(ProofOutcome.Top); } // first, we check that Op1 != MinValue var condition1 = BoxedExpression.Binary(BinaryOperator.Cne_Un, this.Op1, BoxedExpression.Const(minValue, this.TypeOp1, this.DecoderForMetaData)); var resultOp1 = query.IsTrue(this.PC, condition1); // second, we check Op2 != -1 var condition2 = BoxedExpression.Binary(BinaryOperator.Cne_Un, this.Op2, BoxedExpression.Const(-1, this.DecoderForMetaData.System_Int32, this.DecoderForMetaData)); var resultOp2 = query.IsTrue(this.PC, condition2); // One of the two conditions is true, so it is ok! if (resultOp1 == ProofOutcome.True || resultOp2 == ProofOutcome.True) { return(ProofOutcome.True); } // Both conditions are false, so division is definitely an overflow if (resultOp1 == ProofOutcome.False && resultOp2 == ProofOutcome.False) { return(ProofOutcome.False); } return(ProofOutcome.Top); }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { var outcome = query.IsLessThan(this.PC, this.left, this.right); switch (outcome) { case ProofOutcome.Top: { // Let us see if there is a possible off-by-one var offByOne = query.IsTrue(this.PC, BoxedExpression.Binary(BinaryOperator.Cle, this.left, this.right)); if (offByOne == ProofOutcome.True) { this.AdditionalInformationOnTheWarning.Add(new WarningContext(WarningContext.ContextType.OffByOne)); } return(outcome); } case ProofOutcome.Bottom: case ProofOutcome.False: case ProofOutcome.True: { return(outcome); } default: { Contract.Assert(false); return(outcome); // unreached } } }
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output) { // If it is a variable or a constant, then there is nothing to do, and we return true. if (this.exp.IsConstant || this.exp.IsVariable) { return(ProofOutcome.True); } return(base.ValidateInternalSpecific(query, inferenceManager, output)); }
public override bool SuggestAnalysisSpecificPostconditions( ContractInferenceManager inferenceManager, IFixpointInfo <APC, ArrayState> fixpointInfo, List <BoxedExpression> postconditions) { Contract.Assert(this.MethodDriver.CFG != null); var exitPC = this.MethodDriver.CFG.NormalExit; ArrayState exitState; if (fixpointInfo.PostState(exitPC, out exitState)) { var mySubState = Select(exitState); foreach (var pair in mySubState.Elements) { // Try to get a variable name for it var variable = ReadVariableInPostState(exitPC, pair.Key); if (variable == null) { // we fail to get a name in the post state, let us see if it is a constant Int64 k; var intv = exitState.Numerical.BoundsFor(pair.Key); if (intv.IsSingleton && intv.LowerBound.TryInt64(out k)) { variable = BoxedExpression.Const(k, this.DecoderForMetaData.System_Int64, this.DecoderForMetaData); } else { continue; } } Contract.Assert(variable != null); Contract.Assume(pair.Value != null); if (pair.Value.IsNormal() && pair.Value.IsUnmodifiedFromEntry.IsTrue()) { foreach (var arrayBoxed in pair.Value.Left.Values) { Contract.Assume(arrayBoxed != null); var arrayType = GetTypeOrObject(exitPC, arrayBoxed); var array = ReadVariableInPostState(exitPC, arrayBoxed); if (array != null) { // If we have one or more definite values for the index expression, we use them if (pair.Value.Right.IsNormal()) { foreach (var indexBoxed in pair.Value.Right.Values) { BoxedExpression newPost = null; Contract.Assume(indexBoxed != null); var index = ReadVariableInPostState(exitPC, indexBoxed); if (index == null) { newPost = GenerateTheExists(exitPC, variable, arrayType, array); } else { #region Generate arr[index] == variable var arrayLoad = new BoxedExpression.ArrayIndexExpression <Type>(array, index, arrayType); newPost = BoxedExpression.Binary(BinaryOperator.Ceq, arrayLoad, variable); #endregion } postconditions.AddIfNotNull(newPost); } } // else, if we know it is top, we can simp,y project over it else if (pair.Value.Right.IsTop) { postconditions.AddIfNotNull(GenerateTheExists(exitPC, variable, arrayType, array)); } } } } } } return(false); }
public override bool SuggestAnalysisSpecificPostconditions(ContractInferenceManager inferenceManager, IFixpointInfo <APC, SimpleStringAbstractDomain <BoxedVariable <Variable>, BoxedExpression> > fixpointInfo, List <BoxedExpression> postconditions) { // does nothing return(false); }
/// <summary> /// Try to validate the embodied proof obligation and return the outcome. /// The IFactQuery interface is for future logic based implementation of fact querying. /// The validation can make queries or use internal state to answer the outcome. /// </summary> protected abstract ProofOutcome ValidateInternal(IFactQuery <Expression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output);
protected override ProofOutcome ValidateInternal(IFactQuery <Exp, Var> query, ContractInferenceManager inferenceManager, IOutputResults output) { Contract.Requires(query != null); Contract.Requires(inferenceManager != null); throw new NotImplementedException(); }
abstract protected ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager contractManager, IOutputResults output);