public bool LookupState(IMethodResult <Variable> mr, APC pc, out SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> astate) { astate = null; ContainerAnalysis an = mr as ContainerAnalysis; if (an == null) { return(false); } return(an.PreStateLookup(pc, out astate)); }
public bool AssignInParallel(IMethodResult <Variable> mr, ref SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> astate, Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > mapping, Converter <BoxedVariable <Variable>, BoxedExpression> convert) { ContainerAnalysis an = mr as ContainerAnalysis; if (an == null) { return(false); } astate.AssignInParallel(mapping, convert); return(true); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Ldelema(APC pc, Type type, bool @readonly, Variable dest, Variable array, Variable index, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { var indexes = this.indexesAnalysis.Ldelema(pc, type, @readonly, dest, array, index, data.Left); var contents = data.Right; return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Newarray <ArgList>(APC pc, Type type, Variable dest, ArgList lengths, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { var indexes = this.indexesAnalysis.Newarray <ArgList>(pc, type, dest, lengths, data.Left); var contents = data.Right; if (lengths.Count > 1) { return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); } else { contents = HandleAllocations(pc, type, dest, lengths[0], contents); } return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Binary(APC pc, BinaryOperator op, Variable dest, Variable s1, Variable s2, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { var indexes = this.indexesAnalysis.Binary(pc, op, dest, s1, s2, data.Left); var contents = data.Right; if (OperatorExtensions.IsComparisonBinaryOperator(op)) { // TODO: if s1 or s2 includes an array term, gaurd must be take into account return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); } else if (OperatorExtensions.IsBooleanBinaryOperator(op)) { // TODO: see above return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); } else { var leftAsExp = ToBoxedExpressionWithConstantRefinement(pc, s1); var rightAsExp = ToBoxedExpressionWithConstantRefinement(pc, s2); // adapt BoxedExpression rightOfAssignment; if (TryRepackAssignment(op, leftAsExp, rightAsExp, out rightOfAssignment)) { SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> prePartitions; SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> postPartitions; if (this.partitions.TryPartitionAt(pc, out prePartitions)) { var arraysToRefine = prePartitions.arraysWithPartitionDefinedOnASubsetExpressionOf(rightOfAssignment); // NOTE: this does not means that each array in arraysToRefine are in the current state, BUT they should be foreach (var arrayAsExp in arraysToRefine) { if (this.partitions.TryPartitionAt(this.Context.Post(pc), out postPartitions)) { IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> prePartition; IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> postPartition; if (prePartitions.TryGetValue(arrayAsExp, out prePartition)) { if (postPartitions.TryGetValue(arrayAsExp, out postPartition)) { contents = AdaptPartition(arrayAsExp, contents, prePartition, postPartition); } } //refinedDomain = HandleIndexAssignment("", pc, arrayAsExp, destAsExp, rightOfAssignment, assignmentKnowledge, refinedDomain); } } } } } return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(indexes, contents)); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Castclass(APC pc, Type type, Variable dest, Variable obj, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { if (isOneDimensionalArray(pc, dest)) { return(GenericArrayHandling(pc, dest, data)); } return(data); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Ldfld(APC pc, Field field, bool @volatile, Variable dest, Variable obj, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { if (isOneDimensionalArray(pc, dest)) { return(GenericArrayHandling(pc, dest, data)); } return(data); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Ldarg(APC pc, Parameter argument, bool isOld, Variable dest, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { // TODO: what is isOld for ? if (isOneDimensionalArray(pc, dest)) { return(GenericArrayHandling(pc, dest, data)); } return(data); }
/// <summary> /// /// </summary> private SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> GenericArrayHandling(APC pc, Variable array, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { Variable arrayLengthVar; //var type = this.Context.GetType(pc, dest); if (this.Context.TryGetArrayLength(this.Context.Post(pc), array, out arrayLengthVar)) { var arrayB = new BoxedVariable <Variable>(array); // if a symbolic value is assigned twice, thanks to symbolic values semantics, its equivalent to nop. // So we keep the arraysProperties such as they are. if (!data.Right.ContainsKey(arrayB)) { var arrayType = this.Context.GetType(this.Context.Post(pc), array); if (arrayType.IsNormal) { var type = this.DecoderForMetaData.ElementType(arrayType.Value); var contents = data.Right; contents = HandleAllocations(pc, type, array, arrayLengthVar, contents); return(new SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression>(data.Left, contents, this.Decoder, this.Encoder)); } else { throw new AbstractInterpretationException(); } } return(data); } Debug.Assert(false, "ArrayLength of an array must be known"); return(data); }
public override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> Assume(APC pc, string tag, Variable source, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> data) { var result = base.Assume(pc, tag, source, data); var contents = result.Right; // TODO : before calling normalize see if invovled variables are into the partition //var refinedExp = ToBoxedExpression(pc, source); SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> postPartitions; if (this.partitions.TryPartitionAt(this.Context.Post(pc), out postPartitions)) { IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> postPartition; var arrays = new List <BoxedVariable <Variable> >(contents.Keys); foreach (var array in arrays) { if (postPartitions.TryGetValue(array, out postPartition)) { contents = Normalize(array, contents, result.Left, postPartition); } } } return(result); }
public override void HelperForAssignInParallel(SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> state, Pair <APC, APC> edge, Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap, Converter <BoxedVariable <Variable>, BoxedExpression> convert) { //state.Left.AssignInParallel(refinedMap); // Warning : multiple assigned vriables can have different post partitions, because they are the result // of the whole analysis, and some merge could have happenned for only one of the multiple assigned. // tht is why you assign in pralle before adapt arrayProperties var originalArrays = new List <BoxedVariable <Variable> >(state.Right.Keys); base.HelperForAssignInParallel(state, edge, refinedMap, convert); SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> prePartitions; if (this.partitions.TryPartitionAt(edge.One, out prePartitions)) { var contents = state.Right; foreach (var array in originalArrays) { // if the array is kept if (refinedMap.ContainsKey(array)) { IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> prePartition; if (prePartitions.TryGetValue(array, out prePartition)) { var prePartitionRebinded = prePartition.PartialAssignInParallel(refinedMap, convert); SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> postPartitions; if (this.partitions.TryPartitionAt(edge.Two, out postPartitions)) { IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> postPartition; //arrayRebinded = refinedMap[array].Head; foreach (var arrayRebinded in refinedMap[array].GetEnumerable()) { if (postPartitions.TryGetValue(arrayRebinded, out postPartition)) { var transformMap = prePartitionRebinded.TransformationMapFor(postPartition); contents.TransformArray(arrayRebinded, transformMap); contents = Normalize(arrayRebinded, contents, state.Left, postPartition); } else { // no partition in postState ... // TODO : make the arrayproperties attached to the array disappear. contents.RemoveElement(arrayRebinded); //throw new AbstractInterpretationException(); } } } else { throw new AbstractInterpretationException(); } } } } //state = new SimpleArrayAbstractDomain<BoxedVariable<Variable>, BoxedExpression>( } else { throw new AbstractInterpretationException(); } //base.HelperForAssignInParallel(state, edge, refinedMap); //state.Right.AssignInParallel(refinedMap); }
protected override SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> HelperForJoin(SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> newState, SimpleArrayAbstractDomain <BoxedVariable <Variable>, BoxedExpression> prevState, Pair <APC, APC> edge) { /// - that an array can be null, and in his case not appearing into the environment var keep = new Set <BoxedVariable <Variable> >(); foreach (var array in prevState.Right.Variables) { SimplePartitionAbstractDomain <BoxedVariable <Variable>, BoxedExpression> postPartitions; if (this.partitions.TryPartitionAt(edge.Two, out postPartitions)) { IPartitionAbstraction <BoxedVariable <Variable>, BoxedExpression> postPartition; if (postPartitions.TryGetValue(array, out postPartition)) { keep.Add(array); } } else { throw new AbstractInterpretationException(); } } var result = newState.Join(prevState, keep); //return base.HelperForJoin(newState, prevState, edge); return(result); }