public static INumericalAbstractDomain <Variable, Expression> TestTrueEqual <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, SetOfConstraints <Variable> equalities, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(equalities != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); if (equalities.IsNormal()) { var newSet = new Set <Expression>(); foreach (var v in equalities.Values) { newSet.Add(encoder.VariableFor(v)); } return(aState.TestTrueEqual(exp, newSet)); } else { return(aState); } }
public SimpleArrayPropertiesAbstractDomain(IExpressionEncoder <Variable, Expression> encoder, IExpressionDecoder <Variable, Expression> decoder) : base() { this.arrayAbstractor = new SimpleArrayAbstraction <Variable, Expression>(encoder, decoder); this.encoder = encoder; this.decoder = decoder; }
public static INumericalAbstractDomain <Variable, Expression> AssumeInInterval <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, Interval intv, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(intv != null); Contract.Requires(encoder != null); if (aState.IsBottom || intv.IsTop) { return(aState); } if (intv.IsBottom) { return(aState.Bottom as INumericalAbstractDomain <Variable, Expression>); } // a <= exp if (!intv.LowerBound.IsInfinity) { aState = aState.TestTrueLessEqualThan(intv.LowerBound.ToExpression(encoder), exp); } // b <= exp if (!intv.UpperBound.IsInfinity) { aState = aState.TestTrueLessEqualThan(exp, intv.UpperBound.ToExpression(encoder)); } return(aState); }
public static INumericalEnvironmentDomain <TVar, TExpr> AssumeInInterval <TVar, TExpr> ( this INumericalEnvironmentDomain <TVar, TExpr> domain, TExpr expr, Interval intv, IExpressionEncoder <TVar, TExpr> encoder) { if (!domain.IsNormal()) { return(domain); } if (intv.IsBottom) { return(domain.Bottom); } if (!intv.LowerBound.IsInfinity) { domain = domain.AssumeLessEqualThan(intv.LowerBound.ToExpression(encoder), expr); } if (!intv.UpperBound.IsInfinity) { domain = domain.AssumeLessEqualThan(expr, intv.LowerBound.ToExpression(encoder)); } return(domain); }
public override Expression Convert <Expression>(IExpressionEncoder <Variable, Expression> encoder) { return(encoder.CompoundExpressionFor(ExpressionType.Int32, ExpressionOperator.Addition, encoder.VariableFor(var), encoder.ConstantFor(value))); }
public SubPoly(IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder) { IntervalEnvironment <Expression> intv = new IntervalEnvironment <Expression>(decoder, encoder); LinearEqualitiesEnvironment <Expression> lineq = new LinearEqualitiesEnvironment <Expression>(decoder, encoder, true, false); this.subpoly = new SubPolyhedra <Expression>(lineq, intv, decoder, encoder); }
public SimpleArrayPropertiesAbstractDomain(SimpleArrayPropertiesAbstractDomain <Variable, Expression> source) : base(source) { this.arrayAbstractor = source.arrayAbstractor; this.encoder = source.encoder; this.decoder = source.decoder; }
public bool TryGetEncoder(out IExpressionEncoder <Variable, Expression> encoder) { Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out encoder) != null); encoder = this.encoder; return(encoder != null); }
/// <summary> /// Construct an empty abstract domain of symbolic expressions /// </summary> public SymbolicExpressionsAbstractDomain(IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder) { this.decoder = decoder; this.encoder = encoder; this.var2exp = new SimpleFunctional <Expression, FlatAbstractDomainWithComparer <Expression> >(); InitStaticFields(); }
public static void Init(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder) { linearfactory = new LinearExpFactory <Expression>(decoder, encoder); propfactory = new PropFactory <Expression>(decoder, encoder); UnderlyingPolyhedra = new AI.PolyhedraLattice(linearfactory, propfactory); UnderlyingPolyhedra.Validate(); }
public StripeForUnsafeCode( BoxedExpressionDecoder decoder, IExpressionEncoder <BoxedExpression> encoder, IExpressionContext <APC, Local, Parameter, Method, Field, Type, ExternalExpression, Variable> context, IDecodeMetaData <Local, Parameter, Method, Field, Property, Type, Attribute, Assembly> mdDecoder) : base(decoder, mdDecoder, encoder) { this.context = context; this.decoder = decoder; }
public SubPolyhedraAnalysisForUnsafeCode( string methodName, IMethodDriver <APC, Local, Parameter, Method, Field, Property, Type, Attribute, Assembly, ExternalExpression, Variable, ILogOptions> mdriver, List <Analyzers.Unsafe.UnsafeOptions> options, IOverallUnsafeStatistics overallStats ) : base(methodName, mdriver, options, overallStats) { this.encoder = BoxedExpressionEncoder.Encoder(this.DecoderForMetaData, this.Context); }
public static INumericalAbstractDomain <Variable, Expression> TestTrue <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Variable v, NonRelationalValueAbstraction <Variable, Expression> nonRelationalValue, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(v != null); Contract.Requires(aState != null); Contract.Requires(nonRelationalValue != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); if (nonRelationalValue.IsBottom) { Contract.Assume(aState.Bottom as INumericalAbstractDomain <Variable, Expression> != null); // F: Adding the assumption as we do not track types return(aState.Bottom as INumericalAbstractDomain <Variable, Expression>); } if (nonRelationalValue.IsTop) { return(aState); } var result = aState; // Assume the interval if (nonRelationalValue.Interval.IsNormal()) { result.AssumeInDisInterval(v, nonRelationalValue.Interval); } var vExp = encoder.VariableFor(v); // Assume the equalities if (nonRelationalValue.Equalities.IsNormal()) { result = result.TestTrueEqual(vExp, nonRelationalValue.Equalities, encoder); } // Assume the strict upper bounds if (nonRelationalValue.StrictUpperBounds.IsNormal()) { result = result.TestTrueLessThan(vExp, nonRelationalValue.StrictUpperBounds, encoder); } // Assume the weak upper bounds if (nonRelationalValue.WeakUpperBounds.IsNormal()) { result = result.TestTrueLessEqualThan(vExp, nonRelationalValue.WeakUpperBounds, encoder); } return(result); }
private SimpleDisequalities(SimpleDisequalities <Variable, Expression> original) : base(original) { decoder = original.decoder; encoder = original.encoder; evalConstant = original.evalConstant; testTrueVisitor = original.testTrueVisitor; testFalseVisitor = original.testFalseVisitor; checkIfHoldsVisitor = original.checkIfHoldsVisitor; }
public static INumericalAbstractDomain <Variable, Expression> TestTrueLessThan <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, Set <Variable> uppBounds, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(uppBounds != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); return(aState.TestTrueLessThan(exp, uppBounds.ConvertAll(v => encoder.VariableFor(v)))); }
private PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder, AI.PolyhedraLattice.Element value, IntervalEnvironment <Variable, Expression> intv) { this.decoder = decoder; this.encoder = encoder; embedded = value; this.intv = intv; testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder); testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder); testTrueVisitor.FalseVisitor = testFalseVisitor; testFalseVisitor.TrueVisitor = testTrueVisitor; }
public PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder) { this.decoder = decoder; this.encoder = encoder; embedded = UnderlyingPolyhedra.Top; intv = new IntervalEnvironment <Variable, Expression>(decoder, encoder); testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder); testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder); testTrueVisitor.FalseVisitor = testFalseVisitor; testFalseVisitor.TrueVisitor = testTrueVisitor; }
public StripeIntervalsKarrForUnsafeCode( StripeWithIntervalsForUnsafeCode /*!*/ left, LinearEqualitiesForUnsafeCode /*!*/ right, BoxedExpressionDecoder <Type, ExternalExpression> decoder, IExpressionEncoder <BoxedExpression> encoder, IExpressionContext <APC, Local, Parameter, Method, Field, Type, ExternalExpression, Variable> context, IDecodeMetaData <Local, Parameter, Method, Field, Property, Type, Attribute, Assembly> mdDecoder ) : base(left, right, decoder, encoder) { this.decoder = decoder; this.context = context; this.mdDecoder = mdDecoder; }
/// <summary> /// Construct left - right, or left iff right == 0 /// </summary> public static Expression SmartSubtraction <Variable, Expression>(this IExpressionEncoder <Variable, Expression> encoder, Expression left, Expression right, IExpressionDecoder <Variable, Expression> decoder) { Contract.Requires(decoder != null); Contract.Requires(encoder != null); int value; if (decoder.IsConstantInt(right, out value) && value == 0) { return(left); } return(encoder.CompoundExpressionFor(ExpressionType.Int32, ExpressionOperator.Subtraction, left, right)); }
/// <summary> /// Construct a new domain /// </summary> public SimpleDisequalities(IExpressionDecoder <Variable, Expression> /*!*/ decoder, IExpressionEncoder <Variable, Expression> /*!*/ encoder) { this.decoder = decoder; this.encoder = encoder; evalConstant = new ConstantVisitor(decoder); testTrueVisitor = new SimpleDisequalitiesTestTrueVisitor(this.decoder, evalConstant); testFalseVisitor = new SimpleDisequalitiesTestFalseVisitor(this.decoder); testTrueVisitor.FalseVisitor = testFalseVisitor; testFalseVisitor.TrueVisitor = testTrueVisitor; checkIfHoldsVisitor = new SimpleDisequalitiesCheckIfHoldsVisitor(this.decoder, evalConstant); }
public ExpressionManager(TimeOutChecker timeout, IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder = null, Logger log = null) { Contract.Requires(decoder != null); Contract.Ensures(this.decoder == decoder); Contract.Ensures(this.encoder == encoder); Contract.Ensures(this.TimeOut != null); this.TimeOut = timeout ?? DFARoot.TimeOut; Contract.Assume(this.TimeOut != null, "weakeness with ?? ?"); this.decoder = decoder; this.encoder = encoder; this.Log = log == null ? VoidLogger.Log : log; }
/// <summary> /// Given the length of a pointer that is null in one of the two branches of a join, add it to the domain all the contraints /// of the length that are on the other branch of the join /// </summary> /// <param name="pc">The pc at the join point</param> /// <param name="length">The length of the null pointer</param> /// <param name="result">The state on which we have to add the constraints</param> private void RefineWithNullPointerInformation(APC pc, BoxedExpression length, LinearEqualitiesForUnsafeCode thiscloned, LinearEqualitiesForUnsafeCode prevcloned, ref LinearEqualitiesForUnsafeCode result) { Set <Polynomial <BoxedExpression> > eq = thiscloned.EqualsTo(length); foreach (Polynomial <BoxedExpression> pol in eq) { IExpressionEncoder <BoxedExpression> encoder = BoxedExpressionEncoder.Encoder(this.mdDecoder, this.context); BoxedExpression right = pol.ToPureExpression(encoder); result = new LinearEqualitiesForUnsafeCode(result.TestTrueEqual(length, right), this.bdecoder, this.context, this.mdDecoder); } eq = prevcloned.EqualsTo(length); foreach (Polynomial <BoxedExpression> pol in eq) { IExpressionEncoder <BoxedExpression> encoder = BoxedExpressionEncoder.Encoder(this.mdDecoder, this.context); BoxedExpression right = pol.ToPureExpression(encoder); result = new LinearEqualitiesForUnsafeCode(result.TestTrueEqual(length, right), this.bdecoder, this.context, this.mdDecoder); } }
public static TExpr ToExpression <TVar, TExpr>(this Rational value, IExpressionEncoder <TVar, TExpr> encoder) { if (value.IsInteger) { return(encoder.ConstantFor((long)value)); } if (value.IsPlusInfinity) { return(encoder.CompoundFor(ExpressionType.Int32, ExpressionOperator.Div, encoder.ConstantFor(1L), encoder.ConstantFor(0L))); } if (value.IsMinusInfinity) { return(encoder.CompoundFor(ExpressionType.Int32, ExpressionOperator.Div, encoder.ConstantFor(-1L), encoder.ConstantFor(0L))); } TExpr l = encoder.ConstantFor(value.Up); TExpr r = encoder.ConstantFor(value.Down); return(encoder.CompoundFor(ExpressionType.Int32, ExpressionOperator.Div, l, r)); }
public StripeIntervalsKarr(StripeWithIntervals <Variable, Expression, MetaDataDecoder> /*!*/ left, LinearEqualitiesEnvironment <Variable, Expression> /*!*/ right, IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder, Logger Log) : base(left, right, Log) { this.decoder = decoder; this.encoder = encoder; }
/// <summary> /// Perform some rewritings to the boxed expressions, so that is is simplified, and it is nicer for a human reader /// </summary> public static BoxedExpression MakeItPrettier <Variable>(this BoxedExpression be, IExpressionDecoder <BoxedVariable <Variable>, BoxedExpression> decoder, IExpressionEncoder <BoxedVariable <Variable>, BoxedExpression> encoder) { Contract.Requires(encoder != null); var result = be; // 0. Do not do any work on MinValue <= exp, as -exp <= -MinValue is wrong BinaryOperator bop; BoxedExpression left, right; int maybeMinInt; long maybeMinLong; if (be.IsBinaryExpression(out bop, out left, out right) && (bop == BinaryOperator.Cle || bop == BinaryOperator.Clt || bop == BinaryOperator.Cle_Un || bop == BinaryOperator.Clt_Un) && ((left.IsConstantInt(out maybeMinInt) && maybeMinInt == Int32.MinValue) || (left.IsConstantInt64(out maybeMinLong) && maybeMinLong == Int64.MinValue)) ) { return(result); } // 1. If it is a polynomial, do some arithmetic simplification, puts all the variables on one side, etc. Polynomial <BoxedVariable <Variable>, BoxedExpression> pol; if (Polynomial <BoxedVariable <Variable>, BoxedExpression> .TryToPolynomialForm(be, decoder, out pol)) { if (pol.IsTautology) { return(encoder.ConstantFor(true)); } // m1 - m2 == 0 becomes m1 == m2 BoxedVariable <Variable> x, y; Rational k; if (pol.TryMatch_XMinusYEqualk3(out x, out y, out k) && k.IsZero) { var xExp = encoder.VariableFor(x); var yExp = encoder.VariableFor(y); return(encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.Equal, xExp, yExp)); } result = pol.ToPureExpression(encoder); } // To do: add some more pretty printing there result = MakeItPrettier(result, x => encoder.ConstantFor(x)); return(result); }
public IntervalsForUnsafeCode(BoxedExpressionDecoder decoder, IExpressionEncoder <BoxedExpression> encoder, IExpressionContext <APC, Local, Parameter, Method, Field, Type, ExternalExpression, Variable> context) : base(decoder, encoder) { this.decoder = decoder; this.context = context; }
public SimpleArrayAbstraction(SimpleArrayAbstraction <Variable, Expression> source) { this.encoder = source.encoder; this.decoder = source.decoder; this.content = new Dictionary <int, IAbstractDomainForEnvironments <Variable, Expression> >(source.content); }
public SimpleArrayAbstraction(IExpressionEncoder <Variable, Expression> encoder, IExpressionDecoder <Variable, Expression> decoder) { this.encoder = encoder; this.decoder = decoder; this.content = new Dictionary <int, IAbstractDomainForEnvironments <Variable, Expression> >(); }
public SimpleArrayAbstractDomain(INumericalAbstractDomain <Variable, Expression> indexes, SimpleArrayPropertiesAbstractDomain <Variable, Expression> contents, IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder) : base(indexes, contents) { this.encoder = encoder; this.decoder = decoder; }
private SymbolicExpressionsAbstractDomain(FunctionalAbstractDomain <Expression, FlatAbstractDomainWithComparer <Expression> > var2exp, IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder) { this.decoder = decoder; this.encoder = encoder; this.var2exp = var2exp; }