/// <summary> /// Assigns the must memory index. /// </summary> /// <param name="mustIndex">Index of the must.</param> /// <param name="composedValues">The composed values.</param> private void assignMust(MemoryIndex mustIndex, CollectComposedValuesVisitor composedValues) { IIndexDefinition data = snapshot.Structure.Readonly.GetIndexDefinition(mustIndex); HashSet <Value> values = new HashSet <Value>(composedValues.Values); if (snapshot.CurrentMode == SnapshotMode.MemoryLevel) { if (data.Array != null) { values.Add(data.Array); } if (composedValues.Objects.Count > 0) { IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(snapshot.Structure.Writeable, composedValues.Objects); snapshot.Structure.Writeable.SetObjects(mustIndex, objects); if (data.Objects != null) { CollectionMemoryUtils.AddAll(values, data.Objects); } } } snapshot.CurrentData.Writeable.SetMemoryEntry(mustIndex, snapshot.CreateMemoryEntry(values)); }
/// <summary> /// Assigns the given memory entry into all collected indexes in the collector. /// Must indexes are strongly updated may indexes weakly. /// </summary> /// <param name="collector">The collector.</param> /// <param name="value">The value.</param> internal void Assign(AssignCollector collector, AnalysisFramework.Memory.MemoryEntry value) { CollectComposedValuesVisitor composedValues = new CollectComposedValuesVisitor(); composedValues.VisitMemoryEntry(value); foreach (MemoryIndex mustIndex in collector.MustIndexes) { assignMust(mustIndex, composedValues); } foreach (MemoryIndex mayIndex in collector.MayIndexes) { assignMay(mayIndex, composedValues); } if (snapshot.CurrentMode == SnapshotMode.InfoLevel) { InfoLocationVisitor mustVisitor = new InfoLocationVisitor(snapshot, value, true); foreach (ValueLocation mustLocation in collector.MustLocation) { mustLocation.Accept(mustVisitor); } InfoLocationVisitor mayVisitor = new InfoLocationVisitor(snapshot, value, false); foreach (ValueLocation mustLocation in collector.MayLocaton) { mustLocation.Accept(mayVisitor); } } }
/// <inheritdoc /> public IEnumerable <MemberIdentifier> GetIndexes(Snapshot snapshot, MemoryEntry values) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); visitor.VisitMemoryEntry(values); return(visitor.CollectIndexes(snapshot)); }
/// <inheritdoc /> public IEnumerable <VariableIdentifier> GetFields(Snapshot snapshot, MemoryEntry values) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); visitor.VisitMemoryEntry(values); return(visitor.CollectFields(snapshot)); }
/// <inheritdoc /> public IEnumerable <TypeValue> GetObjectType(Snapshot snapshot, MemoryEntry values) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); visitor.VisitMemoryEntry(values); return(visitor.ResolveObjectsTypes(snapshot)); }
public void MergeMemoryEntry(MemoryIndex targetIndex, MemoryEntry entry) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); visitor.VisitMemoryEntry(entry); arrayCount = visitor.Arrays.Count; HashSet <Value> values = getValues(targetIndex, visitor, false); processMerge(); targetSnapshot.CurrentData.Writeable.SetMemoryEntry(targetIndex, targetSnapshot.CreateMemoryEntry(values)); }
/// <summary> /// Gets all values which can be in target memory entry. If sources contains some arrays merge this arrays together /// and traverse their indexes. /// </summary> /// <param name="operation">The operation.</param> /// <param name="visitor">The visitor.</param> /// <returns>Values for the target memory entry.</returns> private HashSet <Value> getValues(MergeOperation operation, CollectComposedValuesVisitor visitor) { HashSet <Value> values = visitor.Values; bool noScalarValue = visitor.Values.Count == 0; if (visitor.Arrays.Count > 0) { values.Add(mergeArrays(operation)); } foreach (ObjectValue value in visitor.Objects) { values.Add(value); } return(values); }
/// <summary> /// Assigns the may memory index. /// </summary> /// <param name="mayIndex">Index of the may.</param> /// <param name="composedValues">The composed values.</param> private void assignMay(MemoryIndex mayIndex, CollectComposedValuesVisitor composedValues) { IIndexDefinition data = snapshot.Structure.Readonly.GetIndexDefinition(mayIndex); HashSet <Value> values = new HashSet <Value>(composedValues.Values); if (composedValues.Objects.Count > 0) { HashSet <ObjectValue> objectsSet = new HashSet <ObjectValue>(data.Objects); CollectionMemoryUtils.AddAll(objectsSet, composedValues.Objects); IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(snapshot.Structure.Writeable, composedValues.Objects); snapshot.Structure.Writeable.SetObjects(mayIndex, objects); //if (data.Objects != null) CollectionMemoryUtils.AddAll(values, data.Objects); } MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, mayIndex); CollectionMemoryUtils.AddAll(values, entry.PossibleValues); snapshot.CurrentData.Writeable.SetMemoryEntry(mayIndex, snapshot.CreateMemoryEntry(values)); }
/// <summary> /// Processes single merge operation - prepares all valid values and alias informations from the source indexes. /// When the source indexes contains some array values prepares operation for every descendant index and merge the /// array into one which will be stored in the target memory entry. /// </summary> /// <param name="operation">The operation.</param> private void processMergeOperation(MergeOperation operation) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); ReferenceCollector references = new ReferenceCollector(); // Collect all data from source indexes foreach (var operationData in operation.Indexes) { MemoryIndex index = operationData.Item1; Snapshot snapshot = operationData.Item2; MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, index); visitor.VisitMemoryEntry(entry); IMemoryAlias aliases; if (snapshot.Structure.Readonly.TryGetAliases(index, out aliases)) { references.CollectMust(aliases.MustAliases, targetSnapshotCallLevel); references.CollectMay(aliases.MayAliases, targetSnapshotCallLevel); } else { references.InvalidateMust(); } } references.SetAliases(operation.TargetIndex, this, !operation.IsUndefined); //repares the set of values - array values are traversed HashSet <Value> values = getValues(operation, visitor); // If some index in operation can be undefined add undefined value into result if (operation.IsUndefined) { values.Add(targetSnapshot.UndefinedValue); } Data.Writeable.SetMemoryEntry(operation.TargetIndex, targetSnapshot.CreateMemoryEntry(values)); writeableStrucure.SetObjects(operation.TargetIndex, Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(writeableStrucure, visitor.Objects)); }
private HashSet <Value> getValues(MemoryIndex targetIndex, CollectComposedValuesVisitor visitor, bool includeUndefined) { HashSet <Value> values = visitor.Values; bool noScalarValue = visitor.Values.Count == 0; if (visitor.Arrays.Count > 0) { bool mustBeArray = !includeUndefined && noScalarValue && visitor.Objects.Count == 0 && visitor.Arrays.Count == arrayCount; values.Add(mergeArrays(targetIndex, visitor.Arrays, !mustBeArray)); } if (visitor.Objects.Count > 0) { bool mustBeObject = !includeUndefined && noScalarValue && visitor.Arrays.Count == 0; mergeObjects(targetIndex, visitor.Objects, mustBeObject, values); } return(values); }
private MemoryEntry setNewMemoryEntry(MemoryIndex index, MemoryEntry currentEntry, MemoryEntry modifiedEntry) { CollectComposedValuesVisitor currentVisitor = new CollectComposedValuesVisitor(); currentVisitor.VisitMemoryEntry(currentEntry); CollectComposedValuesVisitor modifiedVisitor = new CollectComposedValuesVisitor(); modifiedVisitor.VisitMemoryEntry(modifiedEntry); if (currentVisitor.Arrays.Count != modifiedVisitor.Arrays.Count) { snapshot.DestroyArray(index); } if (modifiedVisitor.Objects.Count != currentVisitor.Objects.Count) { IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(newStructure.Writeable, currentVisitor.Objects); snapshot.Structure.Writeable.SetObjects(index, objects); } newData.Writeable.SetMemoryEntry(index, modifiedEntry); return(modifiedEntry); }
private void processMergeOperation(MergeOperation operation) { CollectComposedValuesVisitor visitor = new CollectComposedValuesVisitor(); ReferenceCollector references = new ReferenceCollector(); foreach (var item in operation.Indexes) { Snapshot snapshot = item.Item2; MemoryIndex index = item.Item1; MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, index); visitor.VisitMemoryEntry(entry); IMemoryAlias aliases; if (snapshot.Structure.Readonly.TryGetAliases(index, out aliases)) { references.CollectMust(aliases.MustAliases, snapshot.CallLevel); references.CollectMay(aliases.MayAliases, snapshot.CallLevel); } else { references.InvalidateMust(); } } if (references.HasAliases && !operation.IsRoot) { if (!operation.IsUndefined && operation.Indexes.Count == 1 && references.HasMustAliases) { if (targetSnapshot == operation.Indexes.First().Item2) { references.AddMustAlias(operation.Indexes.First().Item1); } } else { HashSet <MemoryIndex> referenceIndexes = new HashSet <MemoryIndex>(); foreach (var item in operation.Indexes) { MemoryIndex index = item.Item1; Snapshot snapshot = item.Item2; if (index != operation.TargetIndex && targetSnapshot == snapshot) { referenceIndexes.Add(index); } } references.CollectMay(referenceIndexes, targetSnapshot.CallLevel); } } references.SetAliases(operation.TargetIndex, targetSnapshot, !operation.IsUndefined); HashSet <Value> values = getValues(operation.TargetIndex, visitor, operation.IsUndefined); if (operation.IsUndefined) { values.Add(targetSnapshot.UndefinedValue); } targetSnapshot.CurrentData.Writeable.SetMemoryEntry(operation.TargetIndex, targetSnapshot.CreateMemoryEntry(values)); }