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)); }
public SimpleArrayAbstraction <Variable, Expression> Join(SimpleArrayAbstraction <Variable, Expression> right) { SimpleArrayAbstraction <Variable, Expression> trivialResult; if (AbstractDomainsHelper.TryTrivialJoin(this, right, out trivialResult)) { return(trivialResult); } SimpleArrayAbstraction <Variable, Expression> result = new SimpleArrayAbstraction <Variable, Expression>(this.encoder, this.decoder); foreach (var e in this.content) { IAbstractDomainForEnvironments <Variable, Expression> rightProperty; var leftProperty = e.Value; if (right.content.TryGetValue(e.Key, out rightProperty)) { result.content.Add(e.Key, (IAbstractDomainForEnvironments <Variable, Expression>)leftProperty.Join(rightProperty)); } else { throw new AbstractInterpretationException(); } } return(result); }
public IAbstractDomain /*!*/ Join(IAbstractDomain /*!*/ a) { IAbstractDomain /*!*/ result; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result)) { return(result); } Debug.Assert(a is SymbolicExpressionsAbstractDomain <Expression>, "Expecting an instance of SymbolicExpressionsAbstractDomain. Found " + a); //^ assert a is SymbolicExpressionsAbstractDomain<Expression>; SymbolicExpressionsAbstractDomain <Expression> right = a as SymbolicExpressionsAbstractDomain <Expression>; FunctionalAbstractDomain <Expression, FlatAbstractDomainWithComparer <Expression> > joinSymbolicExpressions = (FunctionalAbstractDomain <Expression, FlatAbstractDomainWithComparer <Expression> >) this.var2exp.Join(right.var2exp); // Join the symbolic expression bindings Debug.Assert(!joinSymbolicExpressions.IsBottom, "The join of two non-bottom expression environments cannot be bottom"); //^ assert !joinSymbolicExpressions.IsBottom; /* * if (joinSymbolicExpressions.IsTop) * { * return this.Top; * } * else * {*/ return(new SymbolicExpressionsAbstractDomain <Expression>(joinSymbolicExpressions, this.decoder, this.encoder)); //} }
public PolyhedraEnvironment <Expression> Join(PolyhedraEnvironment <Expression> right) { PolyhedraEnvironment <Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, right, out result)) { return(result); } else { return(Factory(UnderlyingPolyhedra.Join(embedded, right.embedded), intv.Join(right.intv))); } }
public SimpleArrayAbstractDomain <Variable, Expression> Join(SimpleArrayAbstractDomain <Variable, Expression> a, Set <Variable> keep) { SimpleArrayAbstractDomain <Variable, Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result)) { return(result); } var joinLeftPart = (INumericalAbstractDomain <Variable, Expression>) this.Left.Join(a.Left); var joinRightPart = this.Right.Join(a.Right, keep); return((SimpleArrayAbstractDomain <Variable, Expression>) this.Reduce(joinLeftPart, joinRightPart)); }
public PolyhedraEnvironment <Expression> Widening(PolyhedraEnvironment <Expression> prev) { PolyhedraEnvironment <Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result)) { return(result); } else { // Boogie's polyhedra has it in the other order return(Factory(UnderlyingPolyhedra.Widen(prev.embedded, embedded), intv.Widening(prev.intv))); } }
public SymbolicExpressionTracker <Variable, Expression> Join(SymbolicExpressionTracker <Variable, Expression> other) { Contract.Requires(other != null); Contract.Ensures(Contract.Result <SymbolicExpressionTracker <Variable, Expression> >() != null); SymbolicExpressionTracker <Variable, Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result)) { return(result); } other = UnifySlackVariableWith(other); return(new SymbolicExpressionTracker <Variable, Expression>(slackVar, symbolicConditions.Join(other.symbolicConditions))); }
public SegmentLimit <Variable> Join(SegmentLimit <Variable> other) { Contract.Requires(other != null); Contract.Ensures(Contract.Result <SegmentLimit <Variable> >() != null); SegmentLimit <Variable> result; if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result)) { return(result); } var set = expressions.Intersection(other.Expressions); var isconditional = this.IsConditional || other.IsConditional; return(new SegmentLimit <Variable>(set, isconditional)); }
public EnumDefined <Variable, Type, Expression> Join(EnumDefined <Variable, Type, Expression> other) { Contract.Requires(other != null); Contract.Ensures(Contract.Result <EnumDefined <Variable, Type, Expression> >() != null); EnumDefined <Variable, Type, Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result)) { return(result); } Contract.Assume(other.conditions != null); Contract.Assume(other.defined != null); return(new EnumDefined <Variable, Type, Expression>(conditions.Join(other.conditions), defined.Join(other.defined))); }
public ScalarFromArrayTracking Widening(ScalarFromArrayTracking prev) { Contract.Requires(prev != null); Contract.Ensures(Contract.Result <ScalarFromArrayTracking>() != null); ScalarFromArrayTracking result; if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result)) { return(result); } return(new ScalarFromArrayTracking( (SetOfConstraints <BoxedVariable <Variable> >) this.left.Widening(prev.left), (SetOfConstraints <BoxedVariable <Variable> >) this.right.Widening(prev.right), this.isUnmodifiedFromEntry.Join(prev.isUnmodifiedFromEntry), this.conditions.Join(prev.conditions))); }
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))); }
public override DisInterval Join(DisInterval a) { DisInterval trivial; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out trivial)) { return(trivial); } var joinIntervals = Join(this.intervals, a.intervals); if (joinIntervals.Count == 0) { return(Top); } return(new DisInterval(joinIntervals)); }
public ArrayState Widening(ArrayState a) { Contract.Requires(this.PluginsCount == a.PluginsCount); Contract.Ensures(Contract.Result <ArrayState>() != null); Contract.Ensures(Contract.Result <ArrayState>().PluginsCount == this.PluginsCount); ArrayState result; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result)) { return(result); } #if DEBUG // F: for debugging result = null; #endif ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array = null; INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical = null; #if PARALLELWIDENING var arrayTask = Task.Run(() => array = this.Array.Widening(a.Array)); var numericalTask = Task.Run(() => numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>); #else array = this.Array.Widening(a.Array); numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>; #endif var plugins = new IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> [this.PluginsCount]; for (var i = 0; i < this.PluginsCount; i++) { plugins[i] = this.PluginAbstractStateAt(i).Widening(a.PluginAbstractStateAt(i)) as IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>; } #if PARALLELWIDENING Task.WaitAll(arrayTask, numericalTask); #endif return(new ArrayState(array, numerical, plugins, this.mappings)); }
public NonRelationalValueAbstraction <Variable, Expression> Widening(NonRelationalValueAbstraction <Variable, Expression> prev) { Contract.Requires(prev != null); Contract.Ensures(Contract.Result <NonRelationalValueAbstraction <Variable, Expression> >() != null); NonRelationalValueAbstraction <Variable, Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result)) { return(result); } var intv = disInterval.Widening(prev.Interval); var symbolicConditions = this.symbolicConditions.Join(prev.symbolicConditions); Contract.Assume(weaklyRelationalDomains.Length == prev.weaklyRelationalDomains.Length); var newWeaklyDomains = ParallelOperation(weaklyRelationalDomains, prev.weaklyRelationalDomains, (x, y) => x.Widening(y)); return(new NonRelationalValueAbstraction <Variable, Expression>(intv, SymbolicConditions, newWeaklyDomains)); }
public NonRelationalValueAbstraction <Variable, Expression> Join(NonRelationalValueAbstraction <Variable, Expression> other) { Contract.Requires(other != null); Contract.Ensures(Contract.Result <NonRelationalValueAbstraction <Variable, Expression> >() != null); NonRelationalValueAbstraction <Variable, Expression> result; if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result)) { return(result); } var intv = this.disInterval.Join(other.Interval); var symbolicConditions = this.symbolicConditions.Join(other.symbolicConditions); Contract.Assume(this.weaklyRelationalDomains.Length == other.weaklyRelationalDomains.Length); var newWeaklyDomains = ParallelOperation(this.weaklyRelationalDomains, other.weaklyRelationalDomains, (x, y) => x.Join(y)); return(new NonRelationalValueAbstraction <Variable, Expression>(intv, symbolicConditions, newWeaklyDomains)); }
public IAbstractDomain /*!*/ Join(IAbstractDomain /*!*/ a) { IAbstractDomain tryResult; if (AbstractDomainsHelper.TryTrivialJoin(this, a, out tryResult)) { return(tryResult); } StringAbstraction right = a as StringAbstraction; //^ assert right != null; Debug.Assert(right != null, "I was expecting a " + this.GetType().ToString()); IAbstractDomain /*!*/ result; if (content == right.content) { switch (content) { #region All the cases case ContentType.Prefix: result = HelperForPrefixJoin(prefix, right.prefix); break; case ContentType.SetOfCharacters: result = HelperForSetOfCharactersJoin(characters, right.characters); break; case ContentType.String: result = HelperForStringJoin(fullstring, right.fullstring); break; case ContentType.Top: case ContentType.Bottom: default: // Impossible cases as they have already been checked before throw new AbstractInterpretationException("Impossible case?"); #endregion } } else { switch (content) { #region All the cases... case ContentType.Prefix: if (right.content == ContentType.SetOfCharacters) { result = this.Top; } else if (right.content == ContentType.String) { result = HelperForStringPrefixJoin(right.fullstring, prefix); } else { goto default; } break; case ContentType.SetOfCharacters: if (right.content == ContentType.Prefix) { result = this.Top; } else if (right.content == ContentType.String) { result = HelperForSetOfCharactersJoin(characters, AlphaToSetOfCharacters(right.fullstring)); } else { goto default; } break; case ContentType.String: if (right.content == ContentType.Prefix) { result = HelperForStringPrefixJoin(fullstring, right.prefix); } else if (right.content == ContentType.SetOfCharacters) { result = HelperForSetOfCharactersJoin(AlphaToSetOfCharacters(fullstring), right.characters); } else { goto default; } break; case ContentType.Top: case ContentType.Bottom: default: // Impossible cases as they have already been checked before throw new AbstractInterpretationException("Impossible case?"); #endregion } } return(result); }