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