Bring back rc identity cache.

This takes off 0.7% of the 27.7% of the time we spent in SILoptimizer when building
Stdlib.

Author: trentxintong

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;
 }
 
 //===----------------------------------------------------------------------===//