Merge pull request #77540 from gottesmm/add-cache

[region-isolation] Cache getUnderlyingTrackedValue.

Author: gottesmm

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -295,13 +295,52 @@ class RegionAnalysisValueMap {
   /// into this map
   llvm::DenseMap<RepresentativeValue, TrackableValueState>
       equivalenceClassValuesToState;
+
+  /// The inverse map of equivalenceClassValuesToState.
   llvm::DenseMap<unsigned, RepresentativeValue> stateIndexToEquivalenceClass;
 
+  /// State that the value -> representative computation yields to us.
+  struct UnderlyingTrackedValueInfo {
+    SILValue value;
+
+    /// Only used for addresses.
+    std::optional<ActorIsolation> actorIsolation;
+
+    explicit UnderlyingTrackedValueInfo(SILValue value) : value(value) {}
+
+    UnderlyingTrackedValueInfo() : value(), actorIsolation() {}
+
+    UnderlyingTrackedValueInfo(const UnderlyingTrackedValueInfo &newVal)
+        : value(newVal.value), actorIsolation(newVal.actorIsolation) {}
+
+    UnderlyingTrackedValueInfo &
+    operator=(const UnderlyingTrackedValueInfo &newVal) {
+      value = newVal.value;
+      actorIsolation = newVal.actorIsolation;
+      return *this;
+    }
+
+    UnderlyingTrackedValueInfo(SILValue value,
+                               std::optional<ActorIsolation> actorIsolation)
+        : value(value), actorIsolation(actorIsolation) {}
+
+    operator bool() const { return value; }
+  };
+
+  /// A map from a SILValue to its equivalence class representative.
+  llvm::DenseMap<SILValue, UnderlyingTrackedValueInfo> valueToEquivalenceClass;
+
   SILFunction *fn;
 
 public:
   RegionAnalysisValueMap(SILFunction *fn) : fn(fn) { }
 
+  /// Maps a value to its representative value if one exists. Return an empty
+  /// representative value if we do not find one.
+  SILValue getRepresentative(SILValue value) const {
+    return getUnderlyingTrackedValue(value).value;
+  }
+
   /// Returns the value for this instruction if it isn't a fake "represenative
   /// value" to inject actor isolatedness. Asserts in such a case.
   SILValue getRepresentative(Element trackableValueID) const;
@@ -354,6 +393,30 @@ class RegionAnalysisValueMap {
   /// {TrackableValue(), false}.
   std::pair<TrackableValue, bool>
   initializeTrackableValue(SILValue value, SILIsolationInfo info) const;
+
+  /// A helper function that performs the actual getUnderlyingTrackedValue
+  /// computation that is cached in getUnderlyingTrackedValue(). Please never
+  /// call this directly! Only call it from getUnderlyingTrackedValue.
+  UnderlyingTrackedValueInfo
+  getUnderlyingTrackedValueHelper(SILValue value) const;
+
+  UnderlyingTrackedValueInfo getUnderlyingTrackedValue(SILValue value) const {
+    // Use try_emplace so we only construct underlying tracked value info on
+    // success and only lookup once in the hash table.
+    auto *self = const_cast<RegionAnalysisValueMap *>(this);
+    auto iter = self->valueToEquivalenceClass.try_emplace(
+        value, UnderlyingTrackedValueInfo());
+
+    // Didn't insert... we have a value!
+    if (!iter.second)
+      return iter.first->getSecond();
+
+    // Otherwise, update with the actual tracked value info.
+    iter.first->getSecond() = getUnderlyingTrackedValueHelper(value);
+
+    // And return the value.
+    return iter.first->getSecond();
+  }
 };
 
 class RegionAnalysisFunctionInfo {
@@ -485,7 +548,9 @@ class RegionAnalysisFunctionInfo {
 
   bool isClosureCaptured(SILValue value, Operand *op);
 
-  static SILValue getUnderlyingTrackedValue(SILValue value);
+  SILValue getUnderlyingTrackedValue(SILValue value) {
+    return getValueMap().getRepresentative(value);
+  }
 
 private:
   void runDataflow();