[SIL Inlining] Extract out a reusable code snippet in PerformanceInliner

into a utility function in SILInliner.

Author: ravikandhadai

include/swift/SILOptimizer/Utils/SILInliner.h

@@ -120,6 +120,29 @@ class SILInliner {
   std::pair<SILBasicBlock::iterator, SILBasicBlock *>
   inlineFunction(SILFunction *calleeFunction, FullApplySite apply,
                  ArrayRef<SILValue> appliedArgs);
+
+  /// Inline the function called by the given full apply site. This creates
+  /// an instance of SILInliner by constructing a substitution map and
+  /// OpenedArchetypesTracker from the given apply site, and invokes
+  /// `inlineFunction` method on the SILInliner instance to inline the callee.
+  /// This requires the full apply site to be a direct call i.e., the apply
+  /// instruction must have a function ref.
+  ///
+  /// *NOTE*:This attempts to perform inlining unconditionally and thus asserts
+  /// if inlining will fail. All users /must/ check that a function is allowed
+  /// to be inlined using SILInliner::canInlineApplySite before calling this
+  /// function.
+  ///
+  /// *NOTE*: Inlining can result in improperly nested stack allocations, which
+  /// must be corrected after inlining. See needsUpdateStackNesting().
+  ///
+  /// Returns an iterator to the first inlined instruction (or the end of the
+  /// caller block for empty functions) and the last block in function order
+  /// containing inlined instructions (the original caller block for
+  /// single-block functions).
+  static std::pair<SILBasicBlock::iterator, SILBasicBlock *>
+  inlineFullApply(FullApplySite apply, SILInliner::InlineKind inlineKind,
+                  SILOptFunctionBuilder &funcBuilder);
 };
 
 } // end namespace swift

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -901,33 +901,22 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller) {
       continue;
     }
 
-    SmallVector<SILValue, 8> Args;
-    for (const auto &Arg : AI.getArguments())
-      Args.push_back(Arg);
+    LLVM_DEBUG(dumpCaller(Caller); llvm::dbgs()
+                                   << "    inline [" << Callee->size() << "->"
+                                   << Caller->size() << "] "
+                                   << Callee->getName() << "\n");
 
-    LLVM_DEBUG(dumpCaller(Caller);
-               llvm::dbgs() << "    inline [" << Callee->size() << "->"
-                            << Caller->size()
-                            << "] " << Callee->getName() << "\n");
-
-    SILOpenedArchetypesTracker OpenedArchetypesTracker(Caller);
-    Caller->getModule().registerDeleteNotificationHandler(
-        &OpenedArchetypesTracker);
-    // The callee only needs to know about opened archetypes used in
-    // the substitution list.
-    OpenedArchetypesTracker.registerUsedOpenedArchetypes(AI.getInstruction());
-
-    SILInliner Inliner(FuncBuilder, SILInliner::InlineKind::PerformanceInline,
-                       AI.getSubstitutionMap(), OpenedArchetypesTracker);
-
-    needUpdateStackNesting |= Inliner.needsUpdateStackNesting(AI);
+    // Note that this must happen before inlining as the apply instruction
+    // will be deleted after inlining.
+    needUpdateStackNesting |= SILInliner::needsUpdateStackNesting(AI);
 
     // We've already determined we should be able to inline this, so
     // unconditionally inline the function.
     //
-    // If for whatever reason we can not inline this function, inlineFunction
+    // If for whatever reason we can not inline this function, inlineFullApply
     // will assert, so we are safe making this assumption.
-    Inliner.inlineFunction(Callee, AI, Args);
+    SILInliner::inlineFullApply(AI, SILInliner::InlineKind::PerformanceInline,
+                                FuncBuilder);
     NumFunctionsInlined++;
   }
   // The inliner splits blocks at call sites. Re-merge trivial branches to

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -334,6 +334,28 @@ SILInliner::inlineFunction(SILFunction *calleeFunction, FullApplySite apply,
   return std::make_pair(nextI, cloner.getLastClonedBB());
 }
 
+std::pair<SILBasicBlock::iterator, SILBasicBlock *>
+SILInliner::inlineFullApply(FullApplySite apply,
+                            SILInliner::InlineKind inlineKind,
+                            SILOptFunctionBuilder &funcBuilder) {
+  SmallVector<SILValue, 8> appliedArgs;
+  for (const auto &arg : apply.getArguments())
+    appliedArgs.push_back(arg);
+
+  SILFunction *caller = apply.getFunction();
+  SILOpenedArchetypesTracker OpenedArchetypesTracker(caller);
+  caller->getModule().registerDeleteNotificationHandler(
+      &OpenedArchetypesTracker);
+  // The callee only needs to know about opened archetypes used in
+  // the substitution list.
+  OpenedArchetypesTracker.registerUsedOpenedArchetypes(apply.getInstruction());
+
+  SILInliner Inliner(funcBuilder, inlineKind, apply.getSubstitutionMap(),
+                     OpenedArchetypesTracker);
+  return Inliner.inlineFunction(apply.getReferencedFunction(), apply,
+                                appliedArgs);
+}
+
 SILInlineCloner::SILInlineCloner(
     SILFunction *calleeFunction, FullApplySite apply,
     SILOptFunctionBuilder &funcBuilder, InlineKind inlineKind,