Fix begin_apply inlining when there are no yields

In this PR, preFixUp function in SILCloner is added which can be
overidden by implementations so that the SIL is cleaned for `commonFixup` processing.
For begin_apply inlining, blocks split due to end_apply and abort_apply
are fixed when no yields are found.

Author: meg-gupta

include/swift/SIL/SILCloner.h

@@ -374,12 +374,16 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
   /// This is called by either of the top-level visitors, cloneReachableBlocks
   /// or cloneSILFunction, after all other visitors are have been called.
+
+  /// `preFixUp` is called first.
+  void preFixUp(SILFunction *F) {}
+  /// After postFixUp, the SIL must be valid and semantically equivalent to the
+  /// SIL before cloning.
   ///
-  /// After fixUp, the SIL must be valid and semantically equivalent to the SIL
-  /// before cloning.
-  ///
-  /// Common fix-ups are handled first in `doFixUp` and may not be overridden.
-  void fixUp(SILFunction *F) {}
+  /// Common fix-ups are handled first in `commonFixUp` and may not be
+  /// overridden.
+  void postFixUp(SILFunction *F) {}
+
 private:
   /// MARK: SILCloner implementation details hidden from CRTP extensions.
 
@@ -388,8 +392,8 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   void visitBlocksDepthFirst(SILBasicBlock *StartBB);
 
   /// Also perform fundamental cleanup first, then call the CRTP extension,
-  /// `fixUp`.
-  void doFixUp(SILFunction *F);
+  /// `postFixUp`.
+  void commonFixUp(SILFunction *F);
 };
 
 /// A SILBuilder that automatically invokes postprocess on each
@@ -581,7 +585,7 @@ void SILCloner<ImplClass>::cloneReachableBlocks(
   // Discover and map the region to be cloned.
   visitBlocksDepthFirst(startBB);
 
-  doFixUp(F);
+  commonFixUp(F);
 }
 
 template <typename ImplClass>
@@ -606,7 +610,7 @@ void SILCloner<ImplClass>::cloneFunctionBody(SILFunction *F,
   // This will layout all newly cloned blocks immediate after clonedEntryBB.
   visitBlocksDepthFirst(&*F->begin());
 
-  doFixUp(F);
+  commonFixUp(F);
 }
 
 template<typename ImplClass>
@@ -709,9 +713,11 @@ void SILCloner<ImplClass>::visitBlocksDepthFirst(SILBasicBlock *startBB) {
 }
 
 /// Clean-up after cloning.
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::doFixUp(SILFunction *F) {
+template <typename ImplClass>
+void SILCloner<ImplClass>::commonFixUp(SILFunction *F) {
+  // Call any cleanup specific to the CRTP extensions.
+  asImpl().preFixUp(F);
+
   // If our source function is in ossa form, but the function into which we are
   // cloning is not in ossa, after we clone, eliminate default arguments.
   if (!getBuilder().hasOwnership() && F->hasOwnership()) {
@@ -745,7 +751,7 @@ SILCloner<ImplClass>::doFixUp(SILFunction *F) {
   }
 
   // Call any cleanup specific to the CRTP extensions.
-  asImpl().fixUp(F);
+  asImpl().postFixUp(F);
 }
 
 template<typename ImplClass>

include/swift/SILOptimizer/Utils/GenericCloner.h

@@ -71,7 +71,7 @@ class GenericCloner
     return SC.getCloned();
   }
 
-  void fixUp(SILFunction *calleeFunction);
+  void postFixUp(SILFunction *calleeFunction);
 
   static SILFunction *createDeclaration(SILOptFunctionBuilder &FuncBuilder,
                                         SILFunction *Orig,

lib/SILOptimizer/Utils/GenericCloner.cpp

@@ -209,7 +209,7 @@ const SILDebugScope *GenericCloner::remapScope(const SILDebugScope *DS) {
   return RemappedScope;
 }
 
-void GenericCloner::fixUp(SILFunction *f) {
+void GenericCloner::postFixUp(SILFunction *f) {
   for (auto *apply : noReturnApplies) {
     auto applyBlock = apply->getParent();
     applyBlock->split(std::next(SILBasicBlock::iterator(apply)));

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -293,9 +293,12 @@ class SILInlineCloner
   /// This hook is called after either of the top-level visitors:
   /// cloneReachableBlocks or cloneSILFunction.
   ///
-  /// After fixUp, the SIL must be valid and semantically equivalent to the SIL
-  /// before cloning.
-  void fixUp(SILFunction *calleeFunction);
+  /// After `preFixUp` is called `commonFixUp` will be called.
+  void preFixUp(SILFunction *calleeFunction);
+
+  /// After postFixUp, the SIL must be valid and semantically equivalent to the
+  /// SIL before cloning.
+  void postFixUp(SILFunction *calleeFunction);
 
   const SILDebugScope *getOrCreateInlineScope(const SILDebugScope *DS);
 
@@ -602,12 +605,14 @@ void SILInlineCloner::visitTerminator(SILBasicBlock *BB) {
   visit(BB->getTerminator());
 }
 
-void SILInlineCloner::fixUp(SILFunction *calleeFunction) {
+void SILInlineCloner::preFixUp(SILFunction *calleeFunction) {
   // "Completing" the BeginApply only fixes the end of the apply scope. The
   // begin_apply itself lingers.
   if (BeginApply)
     BeginApply->complete();
+}
 
+void SILInlineCloner::postFixUp(SILFunction *calleeFunction) {
   NextIter = std::next(Apply.getInstruction()->getIterator());
 
   assert(!Apply.getInstruction()->hasUsesOfAnyResult());

test/SILOptimizer/inline_begin_apply.sil

@@ -44,6 +44,11 @@ unwind:
   unwind
 }
 
+sil [transparent] [ossa] @test_unreachable : $@yield_once <C: SomeClass> () -> (@yields @in Indirect<C>) {
+entry:
+  unreachable 
+}
+
 // CHECK-LABEL: sil @test_simple_call
 // CHECK: bb0(%0 : $Builtin.Int1):
 // CHECK:  [[MARKER:%.*]] = function_ref @marker
@@ -109,6 +114,40 @@ cont:
   return %ret : $()
 }
 
+// CHECK-LABEL: sil @test_unreachable_call :
+// CHECK: bb0(%0 : $Builtin.Int1):
+// CHECK:  [[MARKER:%.*]] = function_ref @marker
+// CHECK:  unreachable
+// CHECK: } // end sil function 'test_unreachable_call'
+sil @test_unreachable_call : $(Builtin.Int1) -> () {
+entry(%flag : $Builtin.Int1):
+  %marker = function_ref @marker : $@convention(thin) (Builtin.Int32) -> ()
+  %0 = function_ref @test_unreachable : $@convention(thin) @yield_once <T: SomeClass> () -> (@yields @in Indirect<T>)
+  (%value, %token) = begin_apply %0<SomeSubclass>() : $@convention(thin) @yield_once <T: SomeClass> () -> (@yields @in Indirect<T>)
+  destroy_addr %value : $*Indirect<SomeSubclass>
+  cond_br %flag, yes, no
+
+yes:
+  %10 = integer_literal $Builtin.Int32, 10
+  apply %marker(%10) : $@convention(thin) (Builtin.Int32) -> ()
+  end_apply %token
+  %20 = integer_literal $Builtin.Int32, 20
+  apply %marker(%20) : $@convention(thin) (Builtin.Int32) -> ()
+  br cont
+
+no:
+  %11 = integer_literal $Builtin.Int32, 11
+  apply %marker(%11) : $@convention(thin) (Builtin.Int32) -> ()
+  abort_apply %token
+  %21 = integer_literal $Builtin.Int32, 21
+  apply %marker(%21) : $@convention(thin) (Builtin.Int32) -> ()
+  br cont
+
+cont:
+  %ret = tuple ()
+  return %ret : $()
+}
+
 sil [transparent] [ossa] @test_two_yield : $@yield_once <C: SomeClass> (Builtin.Int1) -> (@yields @in Indirect<C>, @yields Builtin.Int64) {
 entry(%0 : $Builtin.Int1):
   %marker = function_ref @marker : $@convention(thin) (Builtin.Int32) -> ()