Improve sil_combiner using subtyping information from CHA

include/swift/SILOptimizer/Analysis/Analysis.def

@@ -30,6 +30,7 @@ ANALYSIS(BasicCallee)
 ANALYSIS(Caller)
 ANALYSIS(ClassHierarchy)
 ANALYSIS(ClosureScope)
+ANALYSIS(ConcreteType)
 ANALYSIS(Destructor)
 ANALYSIS(Dominance)
 ANALYSIS(EpilogueARC)

include/swift/SILOptimizer/Analysis/ConcreteTypeAnalysis.h

@@ -0,0 +1,70 @@
+#ifndef SWIFT_SILOPTIMIZER_ANALYSIS_CONCRETETYPE_H
+#define SWIFT_SILOPTIMIZER_ANALYSIS_CONCRETETYPE_H
+
+#include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILValue.h"
+#include "swift/SILOptimizer/Analysis/Analysis.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Debug.h"
+
+namespace swift {
+
+class SILModule;
+class NominalTypeDecl;
+class ProtocolDecl;
+
+class ConcreteTypeAnalysis : public SILAnalysis {
+public:
+  typedef SmallVector<NominalTypeDecl *, 8> NominalTypeList;
+  typedef llvm::DenseMap<ProtocolDecl *, NominalTypeDecl *>
+      ProtocolSoleTypeImplementation;
+  typedef llvm::DenseMap<ProtocolDecl *, NominalTypeList>
+      ProtocolImplementations;
+
+  ConcreteTypeAnalysis(SILModule *Mod)
+      : SILAnalysis(AnalysisKind::ConcreteType), M(Mod) {
+    init();
+  }
+
+  ~ConcreteTypeAnalysis();
+
+  static bool classof(const SILAnalysis *S) {
+    return S->getKind() == AnalysisKind::ConcreteType;
+  }
+
+  /// Invalidate all information in this analysis.
+  virtual void invalidate() override {}
+
+  /// Invalidate all of the information for a specific function.
+  virtual void invalidate(SILFunction *F, InvalidationKind K) override {}
+
+  /// Notify the analysis about a newly created function.
+  virtual void notifyAddFunction(SILFunction *F) override {}
+
+  /// Notify the analysis about a function which will be deleted from the
+  /// module.
+  virtual void notifyDeleteFunction(SILFunction *F) override {}
+
+  /// Notify the analysis about changed witness or vtables.
+  virtual void invalidateFunctionTables() override {}
+
+  /// Get the sole class that implements a protocol.
+  NominalTypeDecl *getSoleTypeImplementingProtocol(ProtocolDecl *P) {
+    return ProtocolSoleTypeImplementationCache[P];
+  }
+
+private:
+  /// Compute inheritance properties.
+  void init();
+
+  /// The module.
+  SILModule *M;
+
+  /// A cache that maps a protocol to its sole class conforming to it.
+  ProtocolSoleTypeImplementation ProtocolSoleTypeImplementationCache;
+};
+
+} // namespace swift
+#endif

lib/SILOptimizer/Analysis/Analysis.cpp

@@ -17,6 +17,7 @@
 #include "swift/SILOptimizer/Analysis/IVAnalysis.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
+#include "swift/SILOptimizer/Analysis/ConcreteTypeAnalysis.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SILOptions.h"
 #include "swift/SIL/SILModule.h"
@@ -55,3 +56,7 @@ SILAnalysis *swift::createClassHierarchyAnalysis(SILModule *M) {
 SILAnalysis *swift::createBasicCalleeAnalysis(SILModule *M) {
   return new BasicCalleeAnalysis(M);
 }
+
+SILAnalysis *swift::createConcreteTypeAnalysis(SILModule *M) {
+  return new ConcreteTypeAnalysis(M);
+}

lib/SILOptimizer/Analysis/CMakeLists.txt

@@ -11,6 +11,7 @@ set(ANALYSIS_SOURCES
   Analysis/ClassHierarchyAnalysis.cpp
   Analysis/ClosureScope.cpp
   Analysis/ColdBlockInfo.cpp
+  Analysis/ConcreteTypeAnalysis.cpp
   Analysis/DestructorAnalysis.cpp
   Analysis/EscapeAnalysis.cpp
   Analysis/EpilogueARCAnalysis.cpp

lib/SILOptimizer/Analysis/ConcreteTypeAnalysis.cpp

@@ -0,0 +1,98 @@
+//===--- ConcreteTypeAnalysis.cpp - Protocol to Class inheritance ---------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILOptimizer/Analysis/ConcreteTypeAnalysis.h"
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTWalker.h"
+#include "swift/AST/Module.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SIL/SILValue.h"
+
+using namespace swift;
+
+namespace {
+/// A helper class to collect all nominal type declarations.
+class NominalTypeWalker : public ASTWalker {
+  ConcreteTypeAnalysis::ProtocolImplementations &ProtocolImplementationsCache;
+
+public:
+  NominalTypeWalker(ConcreteTypeAnalysis::ProtocolImplementations
+                        &ProtocolImplementationsCache)
+      : ProtocolImplementationsCache(ProtocolImplementationsCache) {}
+
+  bool walkToDeclPre(Decl *D) override {
+    auto *NTD = dyn_cast<NominalTypeDecl>(D);
+    if (!NTD || !NTD->hasInterfaceType())
+      return true;
+    auto Protocols = NTD->getAllProtocols();
+    // We are only interested in types implementing protocols.
+    if (!Protocols.empty()) {
+      for (auto &Protocol : Protocols) {
+        auto &K = ProtocolImplementationsCache[Protocol];
+        K.push_back(NTD);
+      }
+    }
+    return true;
+  }
+};
+} // end anonymous namespace
+
+void ConcreteTypeAnalysis::init() {
+
+  // We only do this in Whole-Module compilation mode.
+  if (!(M->isWholeModule()))
+    return;
+
+  // Process all types implementing protocols.
+  SmallVector<Decl *, 32> Decls;
+
+  // Store protocols and thier implementations in a dense map.
+  ProtocolImplementations ProtocolImplementationsCache;
+
+  M->getSwiftModule()->getTopLevelDecls(Decls);
+
+  /// This operation is quadratic and should only be performed
+  /// in whole module compilation.
+  NominalTypeWalker Walker(ProtocolImplementationsCache);
+  for (auto *D : Decls) {
+    D->walk(Walker);
+  }
+
+  for (auto *D : Decls) {
+    auto ProtoDecl = dyn_cast<ProtocolDecl>(D);
+    /// Check for protocols that are either internal or lower with whole module
+    /// compilation enabled.
+    if (ProtoDecl && ProtoDecl->hasAccess() &&
+        ProtocolImplementationsCache.count(ProtoDecl) &&
+        (ProtoDecl->getEffectiveAccess() <= AccessLevel::Internal)) {
+
+      /// Make sure one class/enum/struct implements this protocol.
+      SmallVector<NominalTypeDecl *, 8> ImplementedDeclList =
+          ProtocolImplementationsCache[ProtoDecl];
+      /// Bail if more than one type implements the protocol.
+      if (ImplementedDeclList.size() > 1)
+        continue;
+      auto NTD = *(ImplementedDeclList.begin());
+      /// Check the access level.
+      if (NTD->getEffectiveAccess() > AccessLevel::Internal)
+        continue;
+
+      /// Check if it is a class/struct/enum.
+      if (isa<ClassDecl>(NTD) || isa<StructDecl>(NTD) || isa<EnumDecl>(NTD)) {
+        ProtocolSoleTypeImplementationCache[ProtoDecl] = NTD;
+      }
+    }
+  }
+}
+
+ConcreteTypeAnalysis::~ConcreteTypeAnalysis() {}

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -25,6 +25,8 @@
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
+#include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
+#include "swift/SILOptimizer/Analysis/ConcreteTypeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SimplifyInstruction.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/Local.h"
@@ -345,11 +347,14 @@ class SILCombine : public SILFunctionTransform {
   void run() override {
     auto *AA = PM->getAnalysis<AliasAnalysis>();
     auto *DA = PM->getAnalysis<DominanceAnalysis>();
+    auto *CTA = PM->getAnalysis<ConcreteTypeAnalysis>();
+    auto *CHA = PM->getAnalysis<ClassHierarchyAnalysis>();
 
     // Create a SILBuilder with a tracking list for newly added
     // instructions, which we will periodically move to our worklist.
     SILBuilder B(*getFunction(), &TrackingList);
-    SILCombiner Combiner(B, AA, DA, getOptions().RemoveRuntimeAsserts);
+    SILCombiner Combiner(B, AA, DA, CTA, CHA,
+                         getOptions().RemoveRuntimeAsserts);
     bool Changed = Combiner.runOnFunction(*getFunction());
     assert(TrackingList.empty() &&
            "TrackingList should be fully processed by SILCombiner");

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -26,6 +26,8 @@
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
+#include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
+#include "swift/SILOptimizer/Analysis/ConcreteTypeAnalysis.h"
 #include "swift/SILOptimizer/Utils/Local.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
@@ -117,6 +119,10 @@ class SILCombiner :
 
   DominanceAnalysis *DA;
 
+  ConcreteTypeAnalysis *CTA;
+
+  ClassHierarchyAnalysis *CHA;
+
   /// Worklist containing all of the instructions primed for simplification.
   SILCombineWorklist Worklist;
 
@@ -135,10 +141,14 @@ class SILCombiner :
   /// Cast optimizer
   CastOptimizer CastOpt;
 
+  /// Set of ApplySites instrumented by concrete type analysis.
+  llvm::DenseSet<FullApplySite> VisitedAIForCTA;
+
 public:
   SILCombiner(SILBuilder &B, AliasAnalysis *AA, DominanceAnalysis *DA,
+              ConcreteTypeAnalysis *CTA, ClassHierarchyAnalysis *CHA,
               bool removeCondFails)
-      : AA(AA), DA(DA), Worklist(), MadeChange(false),
+      : AA(AA), DA(DA), CTA(CTA), CHA(CHA), Worklist(), MadeChange(false),
         RemoveCondFails(removeCondFails), Iteration(0), Builder(B),
         CastOpt(/* ReplaceInstUsesAction */
                 [&](SingleValueInstruction *I, ValueBase *V) {
@@ -295,6 +305,13 @@ class SILCombiner :
                                                          WitnessMethodInst *WMI);
   SILInstruction *propagateConcreteTypeOfInitExistential(FullApplySite AI);
 
+  /// Propagate concrete types from concrete type analysis.
+  SILInstruction *propagateConcreteTypeFromCTA(FullApplySite AI);
+  bool propagateConcreteTypeFromCTAInternal(
+      FullApplySite Apply, ProtocolDecl *Protocol, SILValue &Arg,
+      SILValue &NewArg, Optional<ProtocolConformanceRef> &ConformanceRef,
+      ArchetypeType *OpenedArchetype, CanType &ConcreteType);
+
   /// Perform one SILCombine iteration.
   bool doOneIteration(SILFunction &F, unsigned Iteration);