Updated Existential Specializer code: (1) Remove old protocol analysis; (2) Perform transformation only if there are concrete types; (3) handle protocol and class compositions; (4) Test case covering a wide variety of scenarios

Author: Raj Barik

include/swift/AST/SILOptions.h

@@ -64,8 +64,8 @@ class SILOptions {
   /// Remove all runtime assertions during optimizations.
   bool RemoveRuntimeAsserts = false;
 
-  /// Enable protocol devirtualization optimization.
-  bool ProtocolDevirtualizer = false;
+  /// Enable existential specializer optimization.
+  bool ExistentialSpecializer = false;
 
   /// Controls whether the SIL ARC optimizations are run.
   bool EnableARCOptimizations = true;

include/swift/Option/FrontendOptions.td

@@ -390,8 +390,8 @@ def sil_unroll_threshold : Separate<["-"], "sil-unroll-threshold">,
   MetaVarName<"<250>">,
   HelpText<"Controls the aggressiveness of loop unrolling">;
 
-def sil_protocol_devirtualizer : Flag<["-"], "sil-protocol-devirtualizer">,
-  HelpText<"Enable SIL protocol devirtualizer optimization">;
+def sil_existential_specializer : Flag<["-"], "sil-existential-specializer">,
+  HelpText<"Enable SIL existential specializer optimization">;
 
 def sil_merge_partial_modules : Flag<["-"], "sil-merge-partial-modules">,
   HelpText<"Merge SIL from all partial swiftmodules into the final module">;

include/swift/SILOptimizer/Analysis/Analysis.def

@@ -39,7 +39,6 @@ ANALYSIS(LoopRegion)
 ANALYSIS(OptimizerStats)
 ANALYSIS(PostDominance)
 ANALYSIS(PostOrder)
-ANALYSIS(ProtocolDevirtualizer)
 ANALYSIS(RCIdentity)
 ANALYSIS(SideEffect)
 ANALYSIS(TypeExpansion)

include/swift/SILOptimizer/Analysis/ProtocolDevirtualizerAnalysis.h

@@ -150,8 +150,8 @@ PASS(DeadStoreElimination, "dead-store-elim",
      "Dead Store Elimination")
 PASS(GenericSpecializer, "generic-specializer",
      "Generic Function Specialization on Static Types")
-PASS(ProtocolDevirtualizer, "protocol-devirtualizer",
-     "Protocol Devirtualizer")
+PASS(ExistentialSpecializer, "existential-specializer",
+     "Existential Specializer")
 PASS(GlobalOpt, "global-opt",
      "SIL Global Optimization")
 PASS(GlobalPropertyOpt, "global-property-opt",

include/swift/SILOptimizer/PassManager/Passes.def

@@ -20,7 +20,6 @@
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
-#include "swift/SILOptimizer/Analysis/ProtocolDevirtualizerAnalysis.h"
 #include "swift/SILOptimizer/Utils/FunctionSignatureOptUtils.h"
 #include "swift/SILOptimizer/Utils/Local.h"
 #include "swift/SILOptimizer/Utils/SpecializationMangler.h"
@@ -302,9 +301,16 @@ class GenericFuncSpecializer {
   }
 };
 
-/// ProtocolDevirtualizer transformation class that creates a protocol 
+/// A descriptor to carry information from ExistentialTransform analysis 
+/// to transformation.
+struct ExistentialTransformArgumentDescriptor {
+  OpenedExistentialAccess AccessType;
+  bool DestroyAddrUse;
+};
+
+/// ExistentialSpecializer transformation class that creates a protocol 
 /// constrained generic and a thunk.
-class ProtocolDevirtualizerTransform {
+class ExistentialSpecializerTransform {
   /// The original function to analyze and transform.
   SILFunction *F;
 
@@ -314,49 +320,56 @@ class ProtocolDevirtualizerTransform {
   /// The function signature mangler we are using.
   Mangle::FunctionSignatureSpecializationMangler &Mangler;
 
-  /// Map Arguments to their ProtocolTypes.
-  llvm::SmallDenseMap<int, std::pair<ProtocolDecl *, ClassDecl *>> &Arg2DeclMap;
+  /// List of arguments and their descriptors to specialize
+  llvm::SmallDenseMap<int, ExistentialTransformArgumentDescriptor> &ExistentialArgDescriptor;
 
   /// Argument to Generic Type Map for NewF.
   llvm::SmallDenseMap<int, GenericTypeParamType *> Arg2GenericTypeMap;
 
+  /// Argument to Requirements Map for NewF.
+  llvm::SmallDenseMap<int, SmallVector<Requirement, 4>> Arg2RequirementsMap;
+
   // Allocate the argument descriptors.
   llvm::SmallVector<ArgumentDescriptor, 4> &ArgumentDescList;
 
+  /// List of argument indices to specialize
+  //llvm::SmallBitVector OpenedExistentialArgIndices;
+
   /// Create the Devirtualized Inner Function.
-  void createDevirtualizedProtocolFunction();
+  void createExistentialSpecializedFunction();
 
   /// Create a name for the inner function.
-  std::string createDevirtualizedFunctionName();
+  std::string createExistentialSpecializedFunctionName();
 
   /// Create the new devirtualized protocol function signature.
-  CanSILFunctionType createDevirtualizedFunctionType();
+  CanSILFunctionType createExistentialSpecializedFunctionType();
 
   /// Populate the body of NewF.
-  void populateProtocolConstrainedGenericFunction(const SILDebugScope *DS);
+  void populateSpecializedGenericFunction();
 
   /// Create the thunk.
   void populateThunkBody();
 
   public:
   /// Constructor.
-  ProtocolDevirtualizerTransform(
+  ExistentialSpecializerTransform(
               SILFunction *F,
               Mangle::FunctionSignatureSpecializationMangler &Mangler,
               llvm::SmallVector<ArgumentDescriptor, 4> &ADL,
-              llvm::SmallDenseMap<int, std::pair<ProtocolDecl *, ClassDecl *>> &Arg2DeclMap
-            ) : F(F), NewF(nullptr), Mangler(Mangler), Arg2DeclMap(Arg2DeclMap) , ArgumentDescList(ADL) {}
+              llvm::SmallDenseMap<int, ExistentialTransformArgumentDescriptor> &ExistentialArgDescriptor
+            ) : F(F), NewF(nullptr), Mangler(Mangler), ExistentialArgDescriptor(ExistentialArgDescriptor) , ArgumentDescList(ADL) {}
 
   /// Return the optimized iner function.
-  SILFunction *getDevirtualizedProtocolFunction() { return NewF; }
+  SILFunction *getExistentialSpecializedFunction() { return NewF; }
 
-  /// Run the optimization.
+  /// External function for the optimization.
   bool run() {
-    createDevirtualizedProtocolFunction();
+    createExistentialSpecializedFunction();
     return true;
   }
 };
 
+
 // =============================================================================
 // Prespecialized symbol lookup.
 // =============================================================================

include/swift/SILOptimizer/Utils/Generics.h

@@ -568,8 +568,8 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
       return true;
     }
   }
-  if (Args.hasArg(OPT_sil_protocol_devirtualizer)) {
-    Opts.ProtocolDevirtualizer = true;
+  if (Args.hasArg(OPT_sil_existential_specializer)) {
+    Opts.ExistentialSpecializer = true;
   }
   if (const Arg *A = Args.getLastArg(OPT_num_threads)) {
     if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) {

lib/Frontend/CompilerInvocation.cpp

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

lib/SILOptimizer/Analysis/Analysis.cpp

@@ -18,7 +18,6 @@ set(ANALYSIS_SOURCES
   Analysis/LoopAnalysis.cpp
   Analysis/LoopRegionAnalysis.cpp
   Analysis/MemoryBehavior.cpp
-  Analysis/ProtocolDevirtualizerAnalysis.cpp
   Analysis/RCIdentityAnalysis.cpp
   Analysis/SideEffectAnalysis.cpp
   Analysis/SimplifyInstruction.cpp

lib/SILOptimizer/Analysis/CMakeLists.txt

@@ -225,14 +225,17 @@ void addSSAPasses(SILPassPipelinePlan &P, OptimizationLevelKind OpLevel) {
   // Promote stack allocations to values.
   P.addMem2Reg();
 
+  // Run the existentail pecializer Pass.
+  P.addExistentialSpecializer();
+
   // Cleanup, which is important if the inliner has restarted the pass pipeline.
   P.addPerformanceConstantPropagation();
   P.addSimplifyCFG();
   P.addSILCombine();
 
   // Mainly for Array.append(contentsOf) optimization.
   P.addArrayElementPropagation();
-  
+
   // Run the devirtualizer, specializer, and inliner. If any of these
   // makes a change we'll end up restarting the function passes on the
   // current function (after optimizing any new callees).
@@ -331,9 +334,6 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
 
   // Add the outliner pass (Osize).
   P.addOutliner();
-
-  // Protocol Devirtualizer Pass.
-  P.addProtocolDevirtualizer();
 }
 
 static void addHighLevelEarlyLoopOptPipeline(SILPassPipelinePlan &P) {

lib/SILOptimizer/Analysis/ProtocolDevirtualizerAnalysis.cpp

@@ -29,6 +29,7 @@
 #include "swift/SILOptimizer/Utils/Local.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SmallBitVector.h"
 
 namespace swift {
 
@@ -107,6 +108,21 @@ class SILCombineWorklist {
   }
 };
 
+/// This struct carries information about arguments of apply instructions
+/// for concrete type propagation.
+struct ApplyArgumentDescriptor {
+  SILValue NewArg;
+  CanType ConcreteType;
+#if 0
+  Optional<ProtocolConformanceRef> Conformance;
+#else
+  ArrayRef<Optional<ProtocolConformanceRef>> Conformance;
+#endif
+  ArchetypeType *OpenedArchetype;
+  ApplyArgumentDescriptor() {}
+  ApplyArgumentDescriptor(SILValue NewArg, CanType ConcreteType, ArrayRef<Optional<ProtocolConformanceRef>> Conformance, ArchetypeType *OpenedArchetype) : NewArg(NewArg), ConcreteType(ConcreteType), Conformance(Conformance), OpenedArchetype(OpenedArchetype) {}
+};
+
 /// This is a class which maintains the state of the combiner and simplifies
 /// many operations such as removing/adding instructions and syncing them with
 /// the worklist.
@@ -295,6 +311,10 @@ class SILCombiner :
                                                          WitnessMethodInst *WMI);
   SILInstruction *propagateConcreteTypeOfInitExistential(FullApplySite AI);
 
+  /// Create Apply Instruction with concrete types for arguments.
+  SILInstruction *createApplyWithConcreteType(FullApplySite AI, llvm::SmallBitVector &RelevantArgIndices,
+                                         llvm::SmallDenseMap<SILValue, ApplyArgumentDescriptor> &ArgDesc);
+
   /// Propagate concrete types to all apply arguments.
   SILInstruction *propagateConcreteTypeOfInitExistentialToAllApplyArgs(FullApplySite AI);