SILOptimizer: Compute ClassHierarchyAnalysis cache lazily.

When serializing modules with `-experimental-skip-all-function-bodies`, this
analysis was eagerly populating a cache that would go unused since there is no
optimization to do. With `-experimental-lazy-typecheck`, this work would also
trigger unnecessary typechecking requests. NFC.

Author: tshortli

include/swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h

@@ -27,15 +27,10 @@ class ClassDecl;
 class ClassHierarchyAnalysis : public SILAnalysis {
 public:
   typedef SmallVector<ClassDecl *, 8> ClassList;
-  typedef SmallPtrSet<ClassDecl *, 32> ClassSet;
-  typedef SmallVector<NominalTypeDecl *, 8> NominalTypeList;
-  typedef llvm::DenseMap<ProtocolDecl *, NominalTypeList>
-      ProtocolImplementations;
+  typedef llvm::DenseMap<ClassDecl *, ClassList> ClassListMap;
 
   ClassHierarchyAnalysis(SILModule *Mod)
-      : SILAnalysis(SILAnalysisKind::ClassHierarchy), M(Mod) {
-    init();
-  }
+      : SILAnalysis(SILAnalysisKind::ClassHierarchy), M(Mod) {}
 
   ~ClassHierarchyAnalysis();
 
@@ -65,7 +60,8 @@ class ClassHierarchyAnalysis : public SILAnalysis {
   /// Returns a list of the known direct subclasses of a class \p C in
   /// the current module.
   const ClassList &getDirectSubClasses(ClassDecl *C) {
-    return DirectSubclassesCache[C];
+    populateDirectSubclassesCacheIfNecessary();
+    return (*DirectSubclassesCache)[C];
   }
 
   /// Returns a list of the known indirect subclasses of a class \p C in
@@ -81,7 +77,8 @@ class ClassHierarchyAnalysis : public SILAnalysis {
 
   /// Returns true if the class is inherited by another class in this module.
   bool hasKnownDirectSubclasses(ClassDecl *C) {
-    return DirectSubclassesCache.count(C);
+    populateDirectSubclassesCacheIfNecessary();
+    return DirectSubclassesCache->count(C);
   }
 
   /// Returns true if the class is indirectly inherited by another class
@@ -92,18 +89,19 @@ class ClassHierarchyAnalysis : public SILAnalysis {
   }
 
 private:
-  /// Compute inheritance properties.
-  void init();
   void getIndirectSubClasses(ClassDecl *Base,
                              ClassList &IndirectSubs);
   /// The module
   SILModule *M;
 
   /// A cache that maps a class to all of its known direct subclasses.
-  llvm::DenseMap<ClassDecl*, ClassList> DirectSubclassesCache;
+  llvm::Optional<ClassListMap> DirectSubclassesCache;
 
   /// A cache that maps a class to all of its known indirect subclasses.
-  llvm::DenseMap<ClassDecl*, ClassList> IndirectSubclassesCache;
+  ClassListMap IndirectSubclassesCache;
+
+  /// Populates `DirectSubclassesCache` if necessary.
+  void populateDirectSubclassesCacheIfNecessary();
 };
 
 }

lib/SILOptimizer/Analysis/ClassHierarchyAnalysis.cpp

@@ -19,7 +19,12 @@
 
 using namespace swift;
 
-void ClassHierarchyAnalysis::init() {
+void ClassHierarchyAnalysis::populateDirectSubclassesCacheIfNecessary() {
+  if (DirectSubclassesCache.has_value())
+    return;
+
+  DirectSubclassesCache.emplace();
+
   auto module = M->getSwiftModule();
 
   // For each class declaration in our V-table list:
@@ -42,7 +47,7 @@ void ClassHierarchyAnalysis::init() {
       // Find the superclass's list of direct subclasses.  If it's non-empty,
       // we've previously walked up to the class, so there's no reason to keep
       // walking from this point.
-      auto &list = DirectSubclassesCache[super];
+      auto &list = (*DirectSubclassesCache)[super];
       bool shouldVisitSuper = list.empty();
 
       // Check whether C is already in the list, which can happen