Eliminate yet more SubstitutionLists from SIL in search of a steady-state

Author: DougGregor

include/swift/SIL/SILInstruction.h

@@ -1788,7 +1788,9 @@ class ApplyInstBase<Impl, Base, false> : public Base {
   }
 
   /// True if this application has generic substitutions.
-  bool hasSubstitutions() const { return !Substitutions.empty(); }
+  bool hasSubstitutions() const {
+    return Substitutions.hasAnySubstitutableParams();
+  }
 
   /// The substitutions used to bind the generic arguments of this function.
   SubstitutionList getSubstitutions() const { return Substitutions.toList(); }
@@ -2769,7 +2771,7 @@ class BuiltinInst final
   /// True if this builtin application has substitutions, which represent type
   /// parameters to the builtin.
   bool hasSubstitutions() const {
-    return !Substitutions.empty();
+    return Substitutions.hasAnySubstitutableParams();
   }
 
   /// Return the type parameters to the builtin.

include/swift/SIL/TypeSubstCloner.h

@@ -40,13 +40,6 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
     llvm_unreachable("Clients need to explicitly call a base class impl!");
   }
 
-  void computeSubsMap() {
-    if (auto genericSig = Original.getLoweredFunctionType()
-          ->getGenericSignature()) {
-      SubsMap = genericSig->getSubstitutionMap(ApplySubs);
-    }
-  }
-
   // A helper class for cloning different kinds of apply instructions.
   // Supports cloning of self-recursive functions.
   class ApplySiteCloningHelper {
@@ -141,27 +134,25 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
 
   TypeSubstCloner(SILFunction &To,
                   SILFunction &From,
-                  SubstitutionList ApplySubs,
+                  SubstitutionMap ApplySubs,
                   SILOpenedArchetypesTracker &OpenedArchetypesTracker,
                   bool Inlining = false)
     : SILClonerWithScopes<ImplClass>(To, OpenedArchetypesTracker, Inlining),
       SwiftMod(From.getModule().getSwiftModule()),
+      SubsMap(ApplySubs),
       Original(From),
-      ApplySubs(ApplySubs),
       Inlining(Inlining) {
-    computeSubsMap();
   }
 
   TypeSubstCloner(SILFunction &To,
                   SILFunction &From,
-                  SubstitutionList ApplySubs,
+                  SubstitutionMap ApplySubs,
                   bool Inlining = false)
     : SILClonerWithScopes<ImplClass>(To, Inlining),
       SwiftMod(From.getModule().getSwiftModule()),
+      SubsMap(ApplySubs),
       Original(From),
-      ApplySubs(ApplySubs),
       Inlining(Inlining) {
-    computeSubsMap();
   }
 
 
@@ -295,8 +286,6 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
   llvm::DenseMap<SILType, SILType> TypeCache;
   /// The original function to specialize.
   SILFunction &Original;
-  /// The substitutions used at the call site.
-  SubstitutionList ApplySubs;
   /// True, if used for inlining.
   bool Inlining;
 };

include/swift/SILOptimizer/Utils/GenericCloner.h

@@ -41,7 +41,7 @@ class GenericCloner : public TypeSubstCloner<GenericCloner> {
   GenericCloner(SILFunction *F,
                 IsSerialized_t Serialized,
                 const ReabstractionInfo &ReInfo,
-                SubstitutionList ParamSubs,
+                SubstitutionMap ParamSubs,
                 StringRef NewName,
                 CloneCollector::CallbackType Callback)
   : TypeSubstCloner(*initCloned(F, Serialized, ReInfo, NewName), *F,
@@ -55,7 +55,7 @@ class GenericCloner : public TypeSubstCloner<GenericCloner> {
   cloneFunction(SILFunction *F,
                 IsSerialized_t Serialized,
                 const ReabstractionInfo &ReInfo,
-                SubstitutionList ParamSubs,
+                SubstitutionMap ParamSubs,
                 StringRef NewName,
                 CloneCollector::CallbackType Callback =nullptr) {
     // Clone and specialize the function.

include/swift/SILOptimizer/Utils/Generics.h

@@ -119,13 +119,13 @@ class ReabstractionInfo {
 
   void createSubstitutedAndSpecializedTypes();
   bool prepareAndCheck(ApplySite Apply, SILFunction *Callee,
-                       SubstitutionList ParamSubs,
+                       SubstitutionMap ParamSubs,
                        OptRemark::Emitter *ORE = nullptr);
   void performFullSpecializationPreparation(SILFunction *Callee,
-                                            SubstitutionList ParamSubs);
+                                            SubstitutionMap ParamSubs);
   void performPartialSpecializationPreparation(SILFunction *Caller,
                                                SILFunction *Callee,
-                                               SubstitutionList ParamSubs);
+                                               SubstitutionMap ParamSubs);
   void finishPartialSpecializationPreparation(
       FunctionSignaturePartialSpecializer &FSPS);
 
@@ -136,7 +136,7 @@ class ReabstractionInfo {
   /// If specialization is not possible getSpecializedType() will return an
   /// invalid type.
   ReabstractionInfo(ApplySite Apply, SILFunction *Callee,
-                    SubstitutionList ParamSubs,
+                    SubstitutionMap ParamSubs,
                     bool ConvertIndirectToDirect = true,
                     OptRemark::Emitter *ORE = nullptr);
 
@@ -256,7 +256,7 @@ class ReabstractionInfo {
 
   /// Returns true if a given apply can be specialized.
   static bool canBeSpecialized(ApplySite Apply, SILFunction *Callee,
-                               SubstitutionList ParamSubs);
+                               SubstitutionMap ParamSubs);
 
   /// Returns the apply site for the current generic specialization.
   ApplySite getApply() const {
@@ -271,7 +271,7 @@ class ReabstractionInfo {
 class GenericFuncSpecializer {
   SILModule &M;
   SILFunction *GenericFunc;
-  SubstitutionList ParamSubs;
+  SubstitutionMap ParamSubs;
   IsSerialized_t Serialized;
   const ReabstractionInfo &ReInfo;
 
@@ -280,7 +280,7 @@ class GenericFuncSpecializer {
 
 public:
   GenericFuncSpecializer(SILFunction *GenericFunc,
-                         SubstitutionList ParamSubs,
+                         SubstitutionMap ParamSubs,
                          IsSerialized_t Serialized,
                          const ReabstractionInfo &ReInfo);
 

include/swift/SILOptimizer/Utils/SILInliner.h

@@ -61,7 +61,7 @@ class SILInliner : public TypeSubstCloner<SILInliner> {
 
 public:
   SILInliner(SILFunction &To, SILFunction &From, InlineKind IKind,
-             SubstitutionList ApplySubs,
+             SubstitutionMap ApplySubs,
              SILOpenedArchetypesTracker &OpenedArchetypesTracker,
              CloneCollector::CallbackType Callback = nullptr)
       : TypeSubstCloner<SILInliner>(To, From, ApplySubs,

include/swift/SILOptimizer/Utils/SpecializationMangler.h

@@ -65,17 +65,17 @@ class SpecializationMangler : public Mangle::ASTMangler {
 // The mangler for specialized generic functions.
 class GenericSpecializationMangler : public SpecializationMangler {
 
-  SubstitutionList Subs;
+  SubstitutionMap SubMap;
   bool isReAbstracted;
 
 public:
 
   GenericSpecializationMangler(SILFunction *F,
-                               SubstitutionList Subs,
+                               SubstitutionMap SubMap,
                                IsSerialized_t Serialized,
                                bool isReAbstracted)
     : SpecializationMangler(SpecializationPass::GenericSpecializer, Serialized, F),
-      Subs(Subs), isReAbstracted(isReAbstracted) {}
+      SubMap(SubMap), isReAbstracted(isReAbstracted) {}
 
   std::string mangle();
 };

lib/SIL/SILPrinter.cpp

@@ -1083,7 +1083,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   template <class Inst>
   void visitApplyInstBase(Inst *AI) {
     *this << Ctx.getID(AI->getCallee());
-    printSubstitutions(AI->getSubstitutions());
+    printSubstitutions(AI->getSubstitutionMap());
     *this << '(';
     interleave(AI->getArguments(),
                [&](const SILValue &arg) { *this << Ctx.getID(arg); },

lib/SIL/SILVerifier.cpp

@@ -1019,12 +1019,12 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   /// Check the substitutions passed to an apply or partial_apply.
-  CanSILFunctionType checkApplySubstitutions(SubstitutionList subs,
+  CanSILFunctionType checkApplySubstitutions(SubstitutionMap subs,
                                              SILType calleeTy) {
     auto fnTy = requireObjectType(SILFunctionType, calleeTy, "callee operand");
 
     // If there are substitutions, verify them and apply them to the callee.
-    if (subs.empty()) {
+    if (!subs.hasAnySubstitutableParams()) {
       require(!fnTy->isPolymorphic(),
               "callee of apply without substitutions must not be polymorphic");
       return fnTy;
@@ -1034,8 +1034,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     // Each archetype occurring in the substitutions list should belong to the
     // current function.
-    for (auto sub : subs) {
-      sub.getReplacement()->getCanonicalType().visit([&](CanType t) {
+    for (auto replacementType : subs.getReplacementTypes()) {
+      replacementType->getCanonicalType().visit([&](CanType t) {
         auto A = dyn_cast<ArchetypeType>(t);
         if (!A)
           return;
@@ -1118,7 +1118,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     // Then make sure that we have a type that can be substituted for the
     // callee.
-    auto substTy = checkApplySubstitutions(site.getSubstitutions(),
+    auto substTy = checkApplySubstitutions(site.getSubstitutionMap(),
                                            site.getCallee()->getType());
     require(site.getOrigCalleeType()->getRepresentation() ==
             site.getSubstCalleeType()->getRepresentation(),
@@ -1274,7 +1274,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     checkApplyTypeDependentArguments(PAI);
 
-    auto substTy = checkApplySubstitutions(PAI->getSubstitutions(),
+    auto substTy = checkApplySubstitutions(PAI->getSubstitutionMap(),
                                         PAI->getCallee()->getType());
 
     require(!PAI->getSubstCalleeType()->isPolymorphic(),
@@ -4043,7 +4043,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             invokeTy->getExtInfo().isPseudogeneric(),
             "invoke function must not take reified generic parameters");
 
-    invokeTy = checkApplySubstitutions(IBSHI->getSubstitutions().toList(),
+    invokeTy = checkApplySubstitutions(IBSHI->getSubstitutions(),
                                     SILType::getPrimitiveObjectType(invokeTy));
 
     auto storageParam = invokeTy->getParameters()[0];

lib/SILOptimizer/IPO/CapturePropagation.cpp

@@ -101,7 +101,7 @@ class CapturePropagationCloner
   bool IsCloningConstant;
 public:
   CapturePropagationCloner(SILFunction *OrigF, SILFunction *NewF,
-                           SubstitutionList Subs)
+                           SubstitutionMap Subs)
       : SuperTy(*NewF, *OrigF, Subs), OrigF(OrigF), IsCloningConstant(false) {}
 
   void cloneBlocks(OperandValueArrayRef Args);
@@ -271,7 +271,7 @@ SILFunction *CapturePropagation::specializeConstClosure(PartialApplyInst *PAI,
     llvm::dbgs() << "CapturePropagation of generic partial_apply:\n";
     PAI->dumpInContext();
   });
-  CapturePropagationCloner cloner(OrigF, NewF, PAI->getSubstitutions());
+  CapturePropagationCloner cloner(OrigF, NewF, PAI->getSubstitutionMap());
   cloner.cloneBlocks(PAI->getArguments());
   assert(OrigF->getDebugScope()->Parent != NewF->getDebugScope()->Parent);
   return NewF;
@@ -410,11 +410,13 @@ static SILFunction *getSpecializedWithDeadParams(
       return nullptr;
 
     // Perform a generic specialization of the Specialized function.
-    ReabstractionInfo ReInfo(ApplySite(), Specialized, PAI->getSubstitutions(),
+    ReabstractionInfo ReInfo(ApplySite(), Specialized,
+                             PAI->getSubstitutionMap(),
                              /* ConvertIndirectToDirect */ false);
-    GenericFuncSpecializer FuncSpecializer(Specialized,
-                                           ReInfo.getClonerParamSubstitutions(),
-                                           Specialized->isSerialized(), ReInfo);
+    GenericFuncSpecializer FuncSpecializer(
+                                         Specialized,
+                                         ReInfo.getClonerParamSubstitutionMap(),
+                                         Specialized->isSerialized(), ReInfo);
 
     SILFunction *GenericSpecializedFunc = FuncSpecializer.trySpecialization();
     if (!GenericSpecializedFunc)

lib/SILOptimizer/IPO/EagerSpecializer.cpp

@@ -623,7 +623,7 @@ emitArgumentConversion(SmallVectorImpl<SILValue> &CallArgs) {
   auto CalleeSubstFnTy = CanSILFuncTy;
   if (CanSILFuncTy->isPolymorphic()) {
     CalleeSubstFnTy = CanSILFuncTy->substGenericArgs(
-        Builder.getModule(), ReInfo.getCallerParamSubstitutions());
+        Builder.getModule(), ReInfo.getCallerParamSubstitutionMap());
     assert(!CalleeSubstFnTy->isPolymorphic() &&
            "Substituted callee type should not be polymorphic");
     assert(!CalleeSubstFnTy->hasTypeParameter() &&
@@ -718,7 +718,7 @@ static SILFunction *eagerSpecialize(SILFunction *GenericFunc,
     Serialized = IsSerializable;
 
   GenericFuncSpecializer
-        FuncSpecializer(GenericFunc, ReInfo.getClonerParamSubstitutions(),
+        FuncSpecializer(GenericFunc, ReInfo.getClonerParamSubstitutionMap(),
                         Serialized, ReInfo);
 
   SILFunction *NewFunc = FuncSpecializer.trySpecialization();

lib/SILOptimizer/IPO/UsePrespecialized.cpp

@@ -77,15 +77,15 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     // If this is the case, check if there is a specialization
     // available for it already and use this specialization
     // instead of the generic version.
-
-    SubstitutionList Subs = AI.getSubstitutions();
-    if (Subs.empty())
+    if (!AI.hasSubstitutions())
       continue;
 
+    SubstitutionMap Subs = AI.getSubstitutionMap();
+
     // Bail if any generic type parameters are unbound.
     // TODO: Remove this limitation once public partial specializations
     // are supported and can be provided by other modules.
-    if (hasArchetypes(Subs))
+    if (Subs.hasArchetypes())
       continue;
 
     ReabstractionInfo ReInfo(AI, ReferencedF, Subs);

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -535,8 +535,8 @@ runOnFunctionRecursively(SILFunction *F, FullApplySite AI,
 
       // Get our list of substitutions.
       auto Subs = (PAI
-                   ? PAI->getSubstitutions()
-                   : InnerAI.getSubstitutions());
+                   ? PAI->getSubstitutionMap()
+                   : InnerAI.getSubstitutionMap());
 
       SILOpenedArchetypesTracker OpenedArchetypesTracker(F);
       F->getModule().registerDeleteNotificationHandler(

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -178,7 +178,7 @@ class SILPerformanceInliner {
 // Returns true if it is possible to perform a generic
 // specialization for a given call.
 static bool canSpecializeGeneric(ApplySite AI, SILFunction *F,
-                                 SubstitutionList Subs) {
+                                 SubstitutionMap Subs) {
   return ReabstractionInfo::canBeSpecialized(AI, F, Subs);
 }
 
@@ -279,7 +279,7 @@ bool SILPerformanceInliner::isProfitableToInline(
   // Bail out if this generic call can be optimized by means of
   // the generic specialization, because we prefer generic specialization
   // to inlining of generics.
-  if (IsGeneric && canSpecializeGeneric(AI, Callee, AI.getSubstitutions())) {
+  if (IsGeneric && canSpecializeGeneric(AI, Callee, AI.getSubstitutionMap())) {
     return false;
   }
 
@@ -350,9 +350,6 @@ bool SILPerformanceInliner::isProfitableToInline(
         auto SubMap = Sig->getSubstitutionMap(Subs);
         SubMap = SubMap.subst(CalleeSubstMap);
 
-        SmallVector<Substitution, 4> NewSubs;
-        Sig->getSubstitutions(SubMap, NewSubs);
-
         // Check if the call can be devirtualized.
         if (isa<ClassMethodInst>(def) || isa<WitnessMethodInst>(def) ||
             isa<SuperMethodInst>(def)) {
@@ -368,7 +365,7 @@ bool SILPerformanceInliner::isProfitableToInline(
         // Check if a generic specialization would be possible.
         if (isa<FunctionRefInst>(def)) {
           auto CalleeF = FAI.getCalleeFunction();
-          if (!canSpecializeGeneric(FAI, CalleeF, NewSubs))
+          if (!canSpecializeGeneric(FAI, CalleeF, SubMap))
             continue;
           DEBUG(llvm::dbgs() << "Generic specialization will be possible after "
                                 "inlining for the call:\n";
@@ -847,7 +844,7 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller) {
 
     SILInliner Inliner(*Caller, *Callee,
                        SILInliner::InlineKind::PerformanceInline,
-                       AI.getSubstitutions(),
+                       AI.getSubstitutionMap(),
                        OpenedArchetypesTracker);
 
     // We've already determined we should be able to inline this, so