protected override INumericalAbstractDomain <BoxedExpression> HelperForWidening( INumericalAbstractDomain <BoxedExpression> newState, INumericalAbstractDomain <BoxedExpression> prevState, Pair <APC, APC> edge) { return((SubPolyhedra <BoxedExpression>)newState.Widening(prevState)); }
/// <summary> /// Must implement the join/widen operation /// </summary> /// <param name="edge"></param> /// <param name="newState"></param> /// <param name="prevState"></param> /// <param name="weaker">should return false if result is less than or equal prevState.</param> /// <param name="widen">true if this is a widen operation. For our INumericalAbstractDomain<Expression>, this makes no difference</param> public INumericalAbstractDomain <BoxedExpression> Join(Pair <APC, APC> edge, INumericalAbstractDomain <BoxedExpression> newState, INumericalAbstractDomain <BoxedExpression> prevState, out bool weaker, bool widen) { INumericalAbstractDomain <BoxedExpression> result = (INumericalAbstractDomain <BoxedExpression>)prevState.Join(newState); weaker = !prevState.LessEqual(newState); return(result); }
public IAbstractDomain Join(IAbstractDomain a) { IAbstractDomain result; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result)) { return(result); } BoundedDisjunction <Variable, Expression> asDisjunctionDomain = a as BoundedDisjunction <Variable, Expression>; Debug.Assert(asDisjunctionDomain != null); INumericalAbstractDomain <Variable, Expression>[] joinDisjuncts = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length + asDisjunctionDomain.disjuncts.Length]; // Copy both the domains for (int i = 0; i < this.disjuncts.Length; i++) { joinDisjuncts[i] = this.disjuncts[i]; } for (int i = 0; i < asDisjunctionDomain.disjuncts.Length; i++) { joinDisjuncts[this.disjuncts.Length + i] = asDisjunctionDomain.disjuncts[i]; } return(new BoundedDisjunction <Variable, Expression>(joinDisjuncts)); }
/// <summary> /// For the moment the reduction just get rid of the bottom elements /// </summary> private BoundedDisjunction <Variable, Expression> Reduce(INumericalAbstractDomain <Variable, Expression>[] domains) { bool[] isBottom = new bool[domains.Length]; int countBottom = 0; for (int i = 0; i < domains.Length; i++) { if (domains[i].IsBottom) { isBottom[i] = true; countBottom++; } } if (countBottom == 0 || countBottom == domains.Length) { return(new BoundedDisjunction <Variable, Expression>(domains)); } else { INumericalAbstractDomain <Variable, Expression>[] tmp = new INumericalAbstractDomain <Variable, Expression> [domains.Length - countBottom]; for (int i = 0, k = 0; i < domains.Length; i++) { if (!isBottom[i]) { tmp[k] = domains[i]; k++; } } return(new BoundedDisjunction <Variable, Expression>(tmp)); } }
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 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 ArrayState( ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array, INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical, Analyzers.NonNull.TypeBindings <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable> .Domain?nonnull, IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>[] otherStates, int[] mappings) { Contract.Requires(array != null); Contract.Requires(numerical != null); Contract.Requires(otherStates != null); Contract.Requires(mappings != null); Contract.Requires(Contract.ForAll(otherStates, x => x != null)); Contract.Ensures(this.arrayState == array); Contract.Ensures(this.numericalState == numerical); Contract.Ensures(this.nonnullState.Equals(nonnull)); Contract.Ensures(this.otherStates == otherStates); Contract.Ensures(this.mappings == mappings); this.arrayState = array; this.numericalState = numerical; this.nonnullState = nonnull; this.otherStates = otherStates; this.mappings = mappings; }
public static INumericalAbstractDomain <Variable, Expression> TestTrueEqual <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, IEnumerable <Expression> uppBounds) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(uppBounds != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); if (aState.IsBottom) { return(aState); } var result = aState; foreach (var upp in uppBounds) { Contract.Assume(upp != null); result = result.TestTrueEqual(exp, upp); } return(result); }
public ArrayState UpdateNumerical(INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> newNumerical) { Contract.Requires(newNumerical != null); Contract.Ensures(Contract.Result <ArrayState>() != null); return(new ArrayState(this.arrayState, newNumerical, this.nonnullState, this.otherStates, this.mappings)); }
public Pentagons <Variable, Expression> RemoveRedundanciesWith(INumericalAbstractDomain <Variable, Expression> oracle) { Contract.Requires(oracle != null); var left = this.Left.RemoveRedundanciesWith(oracle); var right = this.Right.RemoveRedundanciesWith(this.Right).RemoveRedundanciesWith(oracle); return(this.FactoryOfPentagons(left, right)); }
public bool AssignInParallel(IMethodResult<Variable> mr, ref INumericalAbstractDomain<BoxedVariable<Variable>, BoxedExpression> astate, Dictionary<BoxedVariable<Variable>, FList<BoxedVariable<Variable>>> mapping, Converter<BoxedVariable<Variable>, BoxedExpression> convert) { BufferAnalysis an = mr as BufferAnalysis; if (an == null) return false; astate.AssignInParallel(mapping, convert); return true; }
public bool LookupState(IMethodResult<Variable> mr, APC pc, out INumericalAbstractDomain<BoxedVariable<Variable>, BoxedExpression> astate) { astate = null; BufferAnalysis an = mr as BufferAnalysis; if (an == null) return false; return an.PreStateLookup(pc, out astate); }
public ArrayState( ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array, INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical, Analyzers.NonNull.TypeBindings <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable> .Domain?nonnull = null ) : this(array, numerical, nonnull, new IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> [0], new int[0]) { Contract.Requires(array != null); Contract.Requires(numerical != null); }
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); }
public object Clone() { INumericalAbstractDomain <Variable, Expression>[] cloned = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length]; for (int i = 0; i < this.disjuncts.Length; i++) { cloned[i] = (INumericalAbstractDomain <Variable, Expression>) this.disjuncts[i].Clone(); } return(new BoundedDisjunction <Variable, Expression>(cloned)); }
public INumericalAbstractDomain <Variable, Expression> TestTrueEqual(Expression exp1, Expression exp2) { var result = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length]; for (int i = 0; i < this.disjuncts.Length; i++) { result[i] = this.disjuncts[i].TestTrueEqual(exp1, exp2); } return(new BoundedDisjunction <Variable, Expression>(result)); }
public INumericalAbstractDomain <Variable, Expression> TestTrueGeqZero(Expression exp) { var result = new INumericalAbstractDomain <Variable, Expression> [disjuncts.Length]; for (int i = 0; i < disjuncts.Length; i++) { result[i] = disjuncts[i].TestTrueGeqZero(exp); } return(new BoundedDisjunction <Variable, Expression>(result)); }
public INumericalAbstractDomain <Variable, Expression> RemoveRedundanciesWith(INumericalAbstractDomain <Variable, Expression> oracle) { var result = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length]; for (int i = 0; i < this.disjuncts.Length; i++) { result[i] = this.disjuncts[i].RemoveRedundanciesWith(oracle); } return(new BoundedDisjunction <Variable, Expression>(result)); }
public IAbstractDomainForEnvironments <Variable, Expression> TestFalse(Expression guard) { INumericalAbstractDomain <Variable, Expression>[] result = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length]; for (int i = 0; i < this.disjuncts.Length; i++) { result[i] = (INumericalAbstractDomain <Variable, Expression>) this.disjuncts[i].TestFalse(guard); } return(Reduce(result)); }
public bool AssignInParallel(IMethodResult <Variable> mr, ref INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> astate, Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > mapping, Converter <BoxedVariable <Variable>, BoxedExpression> convert) { NumericalAnalysis <Options> an = mr as NumericalAnalysis <Options>; if (an == null) { return(false); } astate.AssignInParallel(mapping, convert); return(true); }
public bool LookupState(IMethodResult <Variable> mr, APC pc, out INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> astate) { astate = null; var an = mr as NumericalAnalysis <Options>; if (an == null) { return(false); } return(an.PreStateLookup(pc, out astate)); }
public bool LessEqual(IAbstractDomain a) { bool r; if (AbstractDomainsHelper.TryTrivialLessEqual(this, a, out r)) { return(r); } INumericalAbstractDomain <Variable, Expression> leftSmashed = SmashTogether(this, true); INumericalAbstractDomain <Variable, Expression> rightSmashed = SmashTogether(a, true); return(leftSmashed.LessEqual(rightSmashed)); }
public List<BoxedExpression> ExtractAssertions( IMethodResult<Variable> mr, INumericalAbstractDomain<BoxedVariable<Variable>, BoxedExpression> astate, IExpressionContext<Local, Parameter, Method, Field, Type, Expression, Variable> context, IDecodeMetaData<Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> metaDataDecoder) { BufferAnalysis an = mr as BufferAnalysis; if (an == null) return null; BoxedExpressionReader<Local, Parameter, Method, Field, Property, Event, Type, Variable, Expression, Attribute, Assembly> br = new BoxedExpressionReader<Local, Parameter, Method, Field, Property, Event, Type, Variable, Expression, Attribute, Assembly>(context, metaDataDecoder); return an.ToListOfBoxedExpressions(astate, br); }
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)))); }
public ArrayState( ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array, INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical, IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>[] otherStates, int[] mappings ) : this(array, numerical, null, otherStates, mappings) { Contract.Requires(array != null); Contract.Requires(numerical != null); Contract.Requires(otherStates != null); Contract.Requires(mappings != null); Contract.Requires(Contract.ForAll(otherStates, x => x != null)); }
private void AssignInParallel (WeakUpperBoundsEqual <Variable, Expression> wubeq, WeakUpperBounds <Variable, Expression> wub, Dictionary <Variable, FList <Variable> > sourcesToTargets, INumericalAbstractDomain <Variable, Expression> oracleDomain) { Contract.Requires(wubeq != null); Contract.Requires(wub != null); // adding the domain-generated variables to the map as identity var oldToNewMap = new Dictionary <Variable, FList <Variable> >(sourcesToTargets); if (!wubeq.IsTop) { foreach (var e in wubeq.SlackVariables) { oldToNewMap[e] = FList <Variable> .Cons(e, FList <Variable> .Empty); } } if (!wub.IsTop) { foreach (var e in wub.SlackVariables) { oldToNewMap[e] = FList <Variable> .Cons(e, FList <Variable> .Empty); } } // when x has several targets including itself, the canonical element shouldn't be itself foreach (var sourceToTargets in sourcesToTargets) { var source = sourceToTargets.Key; var targets = sourceToTargets.Value; Contract.Assume(targets != null); if (targets.Length() > 1 && targets.Head.Equals(source)) { var tail = targets.Tail; Contract.Assert(tail != null); var newTargets = FList <Variable> .Cons(tail.Head, FList <Variable> .Cons(source, tail.Tail)); oldToNewMap[source] = newTargets; } } AssignInParallelWUBSpecific(wub, oldToNewMap); AssignInParallelWUBEQSpecific(wubeq, sourcesToTargets, oldToNewMap); }
public static BoxedExpression Simplify <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> ( BoxedExpression exp, INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> oracle, IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver ) where Expression : IEquatable <Expression> where Variable : IEquatable <Variable> where LogOptions : IFrameworkLogOptions where Type : IEquatable <Type> { BoxedExpression simplified; SimplifyInternal(exp, oracle, mdriver, out simplified); return(simplified); }
public IAbstractDomain Meet(IAbstractDomain a) { IAbstractDomain result; if (AbstractDomainsHelper.TryTrivialMeet(this, a, out result)) { return(result); } BoundedDisjunction <Variable, Expression> asDisjunctionDomain = a as BoundedDisjunction <Variable, Expression>; Debug.Assert(asDisjunctionDomain != null); INumericalAbstractDomain <Variable, Expression> left = SmashTogether(disjuncts); INumericalAbstractDomain <Variable, Expression> right = SmashTogether(asDisjunctionDomain.disjuncts); return(new BoundedDisjunction <Variable, Expression>((INumericalAbstractDomain <Variable, Expression>)left.Meet(right))); }
public IAbstractDomain Widening(IAbstractDomain prev) { IAbstractDomain result; if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result)) { return(result); } BoundedDisjunction <Variable, Expression> asDisjunctionDomain = prev as BoundedDisjunction <Variable, Expression>; Debug.Assert(asDisjunctionDomain != null); INumericalAbstractDomain <Variable, Expression> left = SmashTogether(this.disjuncts); INumericalAbstractDomain <Variable, Expression> right = SmashTogether(asDisjunctionDomain.disjuncts); return(new BoundedDisjunction <Variable, Expression>((INumericalAbstractDomain <Variable, Expression>)left.Widening(right))); }
static private INumericalAbstractDomain <Variable, Expression> SmashTogether(IAbstractDomain boundedDisjunction, bool p) { INumericalAbstractDomain <Variable, Expression> asNumericalDomain = (INumericalAbstractDomain <Variable, Expression>)boundedDisjunction; Debug.Assert(boundedDisjunction != null); if (p) { // It is a BoundedDisjunction <Variable, Expression> asDisjunction = asNumericalDomain as BoundedDisjunction <Variable, Expression>; Debug.Assert(asDisjunction != null); return(SmashTogether(asDisjunction.disjuncts)); } else { return(asNumericalDomain); } }