Bring back RC identity cache

include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h

@@ -27,11 +27,16 @@
 
 namespace swift {
 
+/// Limit the size of the rc identity cache. We keep a cache per function.
+constexpr unsigned MaxRCIdentityCacheSize = 64;
+
 class DominanceAnalysis;
 
 /// This class is a simple wrapper around an identity cache.
 class RCIdentityFunctionInfo {
   llvm::DenseSet<SILArgument *> VisitedArgs;
+  // RC identity cache.
+  llvm::DenseMap<SILValue, SILValue> RCCache;
   DominanceAnalysis *DA;
 
   /// This number is arbitrary and conservative. At some point if compile time
@@ -50,6 +55,15 @@ class RCIdentityFunctionInfo {
   /// unchecked_trivial_bit_cast.
   void getRCUsers(SILValue V, llvm::SmallVectorImpl<SILInstruction *> &Users);
 
+  void handleDeleteNotification(ValueBase *V) {
+    // Check the cache. If we don't find it, there is nothing to do.
+    auto Iter = RCCache.find(SILValue(V));
+    if (Iter == RCCache.end())
+      return;
+    // Then erase Iter from the cache.
+    RCCache.erase(Iter);
+  }
+
 private:
   SILValue getRCIdentityRootInner(SILValue V, unsigned RecursionDepth);
   SILValue stripRCIdentityPreservingOps(SILValue V, unsigned RecursionDepth);
@@ -70,6 +84,18 @@ class RCIdentityAnalysis : public FunctionAnalysisBase<RCIdentityFunctionInfo> {
   RCIdentityAnalysis(const RCIdentityAnalysis &) = delete;
   RCIdentityAnalysis &operator=(const RCIdentityAnalysis &) = delete;
 
+  virtual void handleDeleteNotification(ValueBase *V) override {
+    // If the parent function of this instruction was just turned into an
+    // external declaration, bail. This happens during SILFunction destruction.
+    SILFunction *F = V->getParentBB()->getParent();
+    if (F->isExternalDeclaration()) {
+      return;
+    }
+    get(F)->handleDeleteNotification(V);
+  }
+
+  virtual bool needsNotifications() override { return true; }
+
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == AnalysisKind::RCIdentity;
   }

lib/SILOptimizer/Analysis/RCIdentityAnalysis.cpp

@@ -453,14 +453,24 @@ SILValue RCIdentityFunctionInfo::getRCIdentityRootInner(SILValue V,
 }
 
 SILValue RCIdentityFunctionInfo::getRCIdentityRoot(SILValue V) {
+  // Do we have it in the RCCache ?
+  auto Iter = RCCache.find(V);
+  if (Iter != RCCache.end())
+    return Iter->second;
+
   SILValue Root = getRCIdentityRootInner(V, 0);
   VisitedArgs.clear();
 
   // If we fail to find a root, return V.
   if (!Root)
     return V;
 
-  return Root;
+  // Make sure the cache does not grow too big.
+  if (RCCache.size() > MaxRCIdentityCacheSize)
+    RCCache.clear();
+
+  // Return and cache it.
+  return RCCache[V] = Root;
 }
 
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Transforms/RetainReleaseCodeMotion.cpp

@@ -224,16 +224,9 @@ class CodeMotionContext {
   /// we compute the genset and killset.
   llvm::SmallPtrSet<SILBasicBlock *, 8> InterestBlocks;
 
-  /// An RC-identity cache.
-  /// TODO: this should be cached in RCIdentity analysis.
-  llvm::DenseMap<SILValue, SILValue> RCCache;
-
   /// Return the rc-identity root of the SILValue.
   SILValue getRCRoot(SILValue R) {
-    auto Iter = RCCache.find(R);
-    if (Iter != RCCache.end())
-      return Iter->second;
-     return RCCache[R] = RCFI->getRCIdentityRoot(R);
+     return RCFI->getRCIdentityRoot(R);
   }
 
   /// Return the rc-identity root of the RC instruction, i.e.