Remove an llvm_unreachable in ownership rauw

This PR just removes an unnecessary error raised in
OwnershipLifetimeExtender::createPlusOneCopy.
We can ownership rauw a value inside the loop with a value outside the
loop. findJointPostDominatingSet correctly helps create control
equivalent copies inside the loop for replacement.

Author: meg-gupta

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -264,24 +264,16 @@ struct OwnershipLifetimeExtender {
 CopyValueInst *
 OwnershipLifetimeExtender::createPlusOneCopy(SILValue value,
                                              SILInstruction *consumingPoint) {
-  auto *newValInsertPt = value->getDefiningInsertionPoint();
-  assert(newValInsertPt);
-  CopyValueInst *copy;
-  if (!isa<SILArgument>(value)) {
-    SILBuilderWithScope::insertAfter(newValInsertPt, [&](SILBuilder &builder) {
-      copy = builder.createCopyValue(builder.getInsertionPointLoc(), value);
-    });
-  } else {
-    SILBuilderWithScope builder(newValInsertPt);
-    copy = builder.createCopyValue(newValInsertPt->getLoc(), value);
-  }
+  auto *copyPoint = value->getNextInstruction();
+  auto loc = copyPoint->getLoc();
+  auto *copy = SILBuilderWithScope(copyPoint).createCopyValue(loc, value);
 
   auto &callbacks = ctx.callbacks;
   callbacks.createdNewInst(copy);
 
   auto *result = copy;
   findJointPostDominatingSet(
-      newValInsertPt->getParent(), consumingPoint->getParent(),
+      copyPoint->getParent(), consumingPoint->getParent(),
       // inputBlocksFoundDuringWalk.
       [&](SILBasicBlock *loopBlock) {
         // This must be consumingPoint->getParent() since we only have one
@@ -291,10 +283,16 @@ OwnershipLifetimeExtender::createPlusOneCopy(SILValue value,
         assert(loopBlock == consumingPoint->getParent());
         auto front = loopBlock->begin();
         SILBuilderWithScope newBuilder(front);
+
+        // Create an extra copy when the consuming point is inside a
+        // loop and both copyPoint and the destroy points are outside the
+        // loop. This copy will be consumed in the same block. The original
+        // value will be destroyed on all paths exiting the loop.
+        //
+        // Since copyPoint dominates consumingPoint, it must be outside the
+        // loop. Otherwise backward traversal would have stopped at copyPoint.
         result = newBuilder.createCopyValue(front->getLoc(), copy);
         callbacks.createdNewInst(result);
-
-        llvm_unreachable("Should never visit this!");
       },
       // Input blocks in joint post dom set. We don't care about thse.
       [&](SILBasicBlock *postDomBlock) {

test/SILOptimizer/cse_ossa_nontrivial.sil

@@ -7,8 +7,9 @@ import Swift
 ///////////////
 // CSE Tests //
 ///////////////
-class Klass {
-}
+class SuperKlass {}
+
+class Klass : SuperKlass {}
 
 struct NonTrivialStruct {
   var val:Klass
@@ -34,6 +35,7 @@ struct StructWithEnum2 {
 
 sil @use_nontrivialstruct1 : $@convention(thin) (@guaranteed NonTrivialStruct) -> ()
 sil @use_nontrivialstruct2 : $@convention(thin) (@owned NonTrivialStruct) -> ()
+sil @use_superklass1 : $@convention(thin) (@owned SuperKlass) -> ()
 
 // CHECK-LABEL: sil [ossa] @structliteral1 :
 // CHECK: struct $NonTrivialStruct
@@ -767,3 +769,30 @@ bb0(%0 : @guaranteed $WrapperKlass):
   return %res : $()
 }
 
+// CHECK-LABEL: sil [ossa] @cse_upcast_loop :
+// CHECK: upcast
+// CHECK-NOT: upcast
+// CHECK-LABEL: } // end sil function 'cse_upcast_loop'
+sil [ossa] @cse_upcast_loop : $@convention(thin) (@owned Klass) -> () {
+bb0(%0 : @owned $Klass):
+  %func  = function_ref @use_superklass1 : $@convention(thin) (@owned SuperKlass) -> ()
+  %copy0 = copy_value %0 : $Klass
+  %1 = upcast %copy0 : $Klass to $SuperKlass
+  apply %func(%1) : $@convention(thin) (@owned SuperKlass) -> ()
+  br bb1
+
+bb1:
+  cond_br undef, bb2, bb3
+
+bb2:
+  %copy1 = copy_value %0 : $Klass
+  %2 = upcast %copy1 : $Klass to $SuperKlass
+  apply %func(%2) : $@convention(thin) (@owned SuperKlass) -> ()
+  br bb1
+
+bb3:
+  destroy_value %0 : $Klass
+  %res = tuple ()
+  return %res : $()
+}
+