public override bool VisitConstant(Expression left, Void data) { Int32 value; if (this.Decoder.TryValueOf <Int32>(left, ExpressionType.Int32, out value)) { result = NormalizedExpression <Variable> .For(value); return(true); } return(false); }
public override bool VisitAddition(Expression left, Expression right, Expression original, Void data) { NormalizedExpression <Variable> leftNorm, rightNorm; if (this.TryConvert(left, out leftNorm)) { Contract.Assert(leftNorm != null); if (this.TryConvert(right, out rightNorm)) { Contract.Assert(rightNorm != null); // All the cases. We declare all the variables here, // so to leverage the definite assignment analysis of // the compiler to check we are doing everything right int leftConst, rightCont; Variable leftVar, rightVar; if (leftNorm.IsConstant(out leftConst)) { // K + K if (rightNorm.IsConstant(out rightCont)) { result = NormalizedExpression <Variable> .For(leftConst + rightCont); // Can overflow, we do not care has it may be the concrete semantics return(true); } // K + V if (rightNorm.IsVariable(out rightVar)) { result = NormalizedExpression <Variable> .For(rightVar, leftConst); return(true); } } else if (leftNorm.IsVariable(out leftVar)) { // V + K if (rightNorm.IsConstant(out rightCont)) { result = NormalizedExpression <Variable> .For(leftVar, rightCont); return(true); } } } } return(Default(data)); }
public override void AssignInParallel(Dictionary <Variable, FList <Variable> > sourcesToTargets, Converter <Variable, Expression> convert) { var newMaps = this.Factory(); foreach (var pair in this.Elements) { FList <Variable> newNames; if (sourcesToTargets.TryGetValue(pair.Key, out newNames)) { Contract.Assume(pair.Value != null); ArraySegmentation <AbstractDomain, Variable, Expression> renamedElement; if (pair.Value.TryAssignInParallelFunctional(sourcesToTargets, convert, out renamedElement)) { renamedElement = renamedElement.Simplify(); foreach (var name in newNames.GetEnumerable()) { newMaps.AddElement(name, renamedElement); } } } // else, it is abstracted away... } // We need constants.... // So we want to add all the knowledge const == var the possible var decoder = this.ExpressionManager.Decoder; foreach (var pair in sourcesToTargets) { int value; var sourceExp = convert(pair.Key); if (decoder.TryValueOf(sourceExp, ExpressionType.Int32, out value)) { var k = NormalizedExpression <Variable> .For(value); var eq = new Set <NormalizedExpression <Variable> >(); foreach (var v in pair.Value.GetEnumerable()) { eq.Add(NormalizedExpression <Variable> .For(v)); } newMaps = newMaps.TestTrueEqualAsymmetric(eq, k); } } this.CopyAndTransferOwnership(newMaps); }
public SegmentLimit <Variable> AssignInParallel <Expression>(Dictionary <Variable, FList <Variable> > sourceToTargets, Converter <Variable, Expression> convert, IExpressionDecoder <Variable, Expression> decoder) { #region Contracts Contract.Requires(sourceToTargets != null); Contract.Requires(convert != null); Contract.Requires(decoder != null); Contract.Ensures(Contract.Result <SegmentLimit <Variable> >() != null); #endregion var newSet = new Set <NormalizedExpression <Variable> >(); foreach (var x in expressions) { Contract.Assume(x != null); FList <Variable> targets; int value; Variable var; if (x.IsConstant(out value)) { newSet.Add(x); } else if (x.IsVariable(out var)) { if (sourceToTargets.TryGetValue(var, out targets)) { Contract.Assume(targets != null); foreach (var newName in targets.GetEnumerable()) { newSet.Add(NormalizedExpression <Variable> .For(newName)); } } } else if (x.IsAddition(out var, out value)) { if (sourceToTargets.TryGetValue(var, out targets)) { Contract.Assume(targets != null); foreach (var newName in targets.GetEnumerable()) { newSet.Add(NormalizedExpression <Variable> .For(newName, value)); } } // This is a special case to handle renaming for a[p++] = ... // We have (var + value) --> var Variable source; if (IsATarget(var, sourceToTargets, out source)) { Variable v; int k; if (decoder.TryMatchVarPlusConst(convert(source), out v, out k) && v.Equals(var) && k == value) { newSet.Add(NormalizedExpression <Variable> .For(var)); } } } } return(new SegmentLimit <Variable>(newSet, this.IsConditional)); }
public override bool VisitVariable(Variable variable, Expression original, Void data) { result = NormalizedExpression <Variable> .For(variable); return(true); }