/// <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) { HashSet <Value> values = new HashSet <Value>(); foreach (var operationData in operation.Indexes) { MemoryIndex index = operationData.Item1; Snapshot snapshot = operationData.Item2; MemoryEntry entry = snapshot.Infos.GetMemoryEntry(index); HashSetTools.AddAll(values, entry.PossibleValues); } if (Structure.HasArray(operation.TargetIndex)) { mergeArrays(operation); } if (operation.IsUndefined) { values.Add(targetSnapshot.UndefinedValue); } Structure.SetMemoryEntry(operation.TargetIndex, new MemoryEntry(values)); }
/// <summary> /// Compares this structure object with given copy of old data and applies widening operation on memory entry which differs. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool widenNotEqualData(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { HashSet <MemoryIndex> indexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(indexes, this.IndexData.Keys); HashSetTools.AddAll(indexes, oldValue.IndexData.Keys); IndexData emptyData = new CopyMemoryModel.IndexData(null, null, null); bool areEqual = true; foreach (MemoryIndex index in indexes) { if (index is TemporaryIndex) { continue; } IndexData newData = getDataOrUndefined(index, this, emptyData); IndexData oldData = getDataOrUndefined(index, oldValue, emptyData); Data.DataWiden(oldValue.Data, index, assistant); if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant)) { areEqual = false; } } return(areEqual); }
/// <summary> /// Compares this structure object with given copy of old data. /// </summary> /// <param name="oldValue">The old value.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool compareData(SnapshotStructure oldValue) { HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(usedIndexes, this.IndexData.Keys); HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys); IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null); foreach (MemoryIndex index in usedIndexes) { if (index is TemporaryIndex) { continue; } IndexData newStructure = getDataOrUndefined(index, this, emptyStructure); IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure); if (!newStructure.DataEquals(oldStructure)) { return(false); } if (!Data.DataEquals(oldValue.Data, index)) { return(false); } } return(true); }
/// <summary> /// Compares this structure object with given copy of old data and applies simplify limit when new memory entry is bigger than given simplify limit. /// </summary> /// <param name="oldValue">The old value.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns> private bool compareDataAndSimplify(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant) { HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(usedIndexes, this.IndexData.Keys); HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys); IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null); bool areEqual = true; foreach (MemoryIndex index in usedIndexes) { if (index is TemporaryIndex) { continue; } IndexData newStructure = getDataOrUndefined(index, this, emptyStructure); IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure); if (!newStructure.DataEquals(oldStructure)) { areEqual = false; } if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant)) { areEqual = false; } } return(areEqual); }
/// <summary> /// Determines whether this container contains the same definitions as the given one. /// </summary> /// <param name="other">The other.</param> /// <returns>True whether this container contains the same definitions as the given one.</returns> internal bool DataEquals(DeclarationContainer <T> other) { HashSet <QualifiedName> names = new HashSet <QualifiedName>(); HashSetTools.AddAll(names, this.declarations.Keys); HashSetTools.AddAll(names, other.declarations.Keys); foreach (var name in names) { HashSet <T> otherDecl, thisDecl; if (!other.declarations.TryGetValue(name, out otherDecl)) { return(false); } if (!this.declarations.TryGetValue(name, out thisDecl)) { return(false); } if (!HashSetTools.EqualsSet(thisDecl, otherDecl)) { return(false); } } return(true); }
/// <summary> /// Assigns new value into specified index. /// </summary> /// <param name="index">The index.</param> private void assign(MemoryIndex index) { HashSet <Value> newValues = new HashSet <Value>(); if (!isMust) { MemoryEntry oldEntry = snapshot.Structure.GetMemoryEntry(index); HashSetTools.AddAll(newValues, oldEntry.PossibleValues); } HashSetTools.AddAll(newValues, entry.PossibleValues); snapshot.Structure.SetMemoryEntry(index, entry); }
/// <summary> /// Visits the information value location. /// </summary> /// <param name="location">The location.</param> public void VisitInfoValueLocation(InfoValueLocation location) { MemoryEntry oldEntry = snapshot.Structure.GetMemoryEntry(location.ContainingIndex); HashSet <Value> newValues = new HashSet <Value>(); HashSetTools.AddAll(newValues, oldEntry.PossibleValues); IEnumerable <Value> values = location.WriteValues(snapshot.MemoryAssistant, entry); newValues.Add(location.Value); snapshot.Structure.SetMemoryEntry(location.ContainingIndex, new MemoryEntry(newValues)); }
internal bool DataEquals(MemoryAlias other) { if (other == null) { return(this.MayAliasses.Count == 0 && this.MustAliasses.Count == 0); } if (this.MayAliasses.Count != other.MayAliasses.Count || this.MustAliasses.Count != other.MustAliasses.Count) { return(false); } return(HashSetTools.EqualsSet(this.MustAliasses, other.MustAliasses) || HashSetTools.EqualsSet(this.MayAliasses, other.MayAliasses)); }
/// <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) { IndexData data = snapshot.Structure.GetIndexData(mayIndex); HashSet <Value> values = new HashSet <Value>(composedValues.Values); if (composedValues.Objects.Count > 0) { HashSet <ObjectValue> objects = new HashSet <ObjectValue>(data.Objects); HashSetTools.AddAll(objects, composedValues.Objects); snapshot.Structure.SetObjects(mayIndex, new ObjectValueContainer(objects)); //if (data.Objects != null) HashSetTools.AddAll(values, data.Objects); } HashSetTools.AddAll(values, snapshot.Structure.GetMemoryEntry(mayIndex).PossibleValues); snapshot.Structure.SetMemoryEntry(mayIndex, new MemoryEntry(values)); }
/// <summary> /// Simplifies memory entries which is bigget than simplify limit and compares data of this data collection object with the given one. /// </summary> /// <param name="oldData">The old data.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="assistant">The assistant.</param> /// <returns>True whether compared data are the same.</returns> public bool DataEqualsAndSimplify(SnapshotData oldData, int simplifyLimit, MemoryAssistantBase assistant) { bool areEquals = true; HashSet <MemoryIndex> indexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(indexes, this.IndexData.Keys); HashSetTools.AddAll(indexes, oldData.IndexData.Keys); foreach (MemoryIndex index in indexes) { if (!DataEqualsAndSimplify(oldData, index, simplifyLimit, assistant)) { areEquals = false; } } return(areEquals); }
/// <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) { IndexData data = snapshot.Structure.GetIndexData(mustIndex); HashSet <Value> values = new HashSet <Value>(composedValues.Values); if (data.Array != null) { values.Add(data.Array); } if (composedValues.Objects.Count > 0) { snapshot.Structure.SetObjects(mustIndex, new ObjectValueContainer(composedValues.Objects)); if (data.Objects != null) { HashSetTools.AddAll(values, data.Objects); } } snapshot.Structure.SetMemoryEntry(mustIndex, new MemoryEntry(values)); }
/// <summary> /// Compares data of this data collection object with the given one. /// </summary> /// <param name="oldData">The old data.</param> /// <returns>True whether compared data are the same.</returns> public bool DataEquals(SnapshotData oldData) { if (this.IndexData.Count != oldData.IndexData.Count) { return(false); } HashSet <MemoryIndex> indexes = new HashSet <MemoryIndex>(); HashSetTools.AddAll(indexes, this.IndexData.Keys); HashSetTools.AddAll(indexes, oldData.IndexData.Keys); foreach (MemoryIndex index in indexes) { if (!DataEquals(oldData, index)) { return(false); } } return(true); }
/// <summary> /// Adds the aliases to must or may lists of indexes. /// </summary> private void addAliasesToIndexes() { HashSet <MemoryIndex> mustAliases = new HashSet <MemoryIndex>(); HashSet <MemoryIndex> mayAliases = new HashSet <MemoryIndex>(); foreach (MemoryIndex index in mustIndexesProcess) { MemoryAlias alias; if (snapshot.Structure.TryGetAliases(index, out alias)) { HashSetTools.AddAll(mustAliases, alias.MustAliasses); foreach (MemoryIndex mayIndex in alias.MayAliasses) { mayAliases.Add(mayIndex); } } } foreach (MemoryIndex index in mustAliases) { addToMust(index); } foreach (MemoryIndex index in mayIndexesProcess) { MemoryAlias alias; if (snapshot.Structure.TryGetAliases(index, out alias)) { HashSetTools.AddAll(mayAliases, alias.MustAliasses); HashSetTools.AddAll(mayAliases, alias.MayAliasses); } } foreach (MemoryIndex index in mayAliases) { addToMay(index); } }
/// <summary> /// Reads the values from locations specified by given collector. /// </summary> /// <param name="collector">The collector.</param> /// <returns>Memory entry with values from locations specified by given collector.</returns> public MemoryEntry ReadValue(IIndexCollector collector) { if (collector.MustIndexesCount == 1 && collector.IsDefined) { MemoryIndex index = collector.MustIndexes.First(); return(snapshot.Structure.GetMemoryEntry(index)); } else { HashSet <Value> values = new HashSet <Value>(); if (!collector.IsDefined) { values.Add(snapshot.UndefinedValue); } foreach (MemoryIndex index in collector.MustIndexes) { MemoryEntry entry = snapshot.Structure.GetMemoryEntry(index); HashSetTools.AddAll(values, entry.PossibleValues); } foreach (ValueLocation location in collector.MustLocation) { if (snapshot.CurrentMode == SnapshotMode.MemoryLevel) { HashSetTools.AddAll(values, location.ReadValues(snapshot.MemoryAssistant)); } else { InfoLocationVisitor visitor = new InfoLocationVisitor(snapshot); location.Accept(visitor); HashSetTools.AddAll(values, visitor.Value); } } return(new MemoryEntry(values)); } }
/// <summary> /// Adds the must alias. /// </summary> /// <param name="aliases">The aliases.</param> internal void AddMustAlias(IEnumerable <MemoryIndex> aliases) { HashSetTools.AddAll(MustAliasses, aliases); }
/// <summary> /// Sets all indexes to must. /// </summary> internal void SetAllToMust() { HashSetTools.AddAll(mustIndexes, mayIndexes); mayIndexes.Clear(); }