[OME] Erase dead_end lifetime ends.

Such instructions are inserted to ensure complete OSSA lifetimes and
should be removed when lowering out of OSSA.

Author: nate-chandler

lib/SIL/Utils/OSSALifetimeCompletion.cpp

@@ -76,7 +76,7 @@ static SILInstruction *endOSSALifetime(SILValue value,
     }
     return builder.createDestroyValue(loc, value, DontPoisonRefs, isDeadEnd);
   }
-  return builder.createEndBorrow(loc, value, isDeadEnd);
+  return builder.createEndBorrow(loc, value);
 }
 
 static bool endLifetimeAtLivenessBoundary(SILValue value,

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -141,6 +141,15 @@ struct OwnershipModelEliminatorVisitor
 
   void splitDestroy(DestroyValueInst *destroy);
   bool visitDestroyValueInst(DestroyValueInst *dvi);
+  bool visitDeallocBoxInst(DeallocBoxInst *dbi) {
+    if (!dbi->isDeadEnd())
+      return false;
+
+    // dead_end instructions are required for complete OSSA lifetimes but should
+    // not exist post-OSSA.
+    eraseInstruction(dbi);
+    return true;
+  }
   bool visitLoadBorrowInst(LoadBorrowInst *lbi);
   bool visitMoveValueInst(MoveValueInst *mvi) {
     eraseInstructionAndRAUW(mvi, mvi->getOperand());
@@ -571,6 +580,13 @@ void OwnershipModelEliminatorVisitor::splitDestroy(DestroyValueInst *destroy) {
 
 bool OwnershipModelEliminatorVisitor::visitDestroyValueInst(
     DestroyValueInst *dvi) {
+  if (dvi->isDeadEnd()) {
+    // dead_end instructions are required for complete OSSA lifetimes but should
+    // not exist post-OSSA.
+    eraseInstruction(dvi);
+    return true;
+  }
+
   // Nonescaping closures are represented ultimately as trivial pointers to
   // their context, but we use ownership to do borrow checking of their captures
   // in OSSA. Now that we're eliminating ownership, fold away destroys.

test/SILOptimizer/ownership_model_eliminator.sil

@@ -411,3 +411,48 @@ bb0(%0 : @guaranteed $C, %1 : $*C):
   return %t : $()
 }
 
+// CHECK-LABEL: sil @test_dead_end_destroy_value : {{.*}} {
+// CHECK:       bb0([[C:%[^,]+]] :
+// CHECK:         cond_br undef, [[DIE:bb[0-9]+]], [[EXIT:bb[0-9]+]]
+// CHECK:       [[DIE]]:
+// Verify that there's no release_value before this trap.
+// CHECK-NEXT:    unreachable
+// CHECK:       [[EXIT]]:
+// CHECK:         strong_release [[C]]
+// CHECK-LABEL: } // end sil function 'test_dead_end_destroy_value'
+sil [ossa] @test_dead_end_destroy_value : $@convention(thin) (@owned C) -> () {
+entry(%c : @owned $C):
+  cond_br undef, die, exit
+
+die:
+  destroy_value [dead_end] %c : $C
+  unreachable
+
+exit:
+  destroy_value %c : $C
+  %retval = tuple ()
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil @test_dead_end_dealloc_box : {{.*}} {
+// CHECK:         [[B:%[^,]+]] = alloc_box
+// CHECK:         cond_br undef, [[DIE:bb[0-9]+]], [[EXIT:bb[0-9]+]]                         
+// CHECK:       [[DIE]]:                                              
+// CHECK-NEXT:    unreachable                                     
+// CHECK:       [[EXIT]]:                                              
+// CHECK:         dealloc_box [[B]]
+// CHECK-LABEL: } // end sil function 'test_dead_end_dealloc_box'
+sil [ossa] @test_dead_end_dealloc_box : $@convention(thin) () -> () {
+entry:
+  %b = alloc_box ${ var C }
+  cond_br undef, die, exit
+
+die:
+  dealloc_box [dead_end] %b : ${ var C }
+  unreachable
+
+exit:
+  dealloc_box %b : ${ var C }
+  %retval = tuple ()
+  return %retval : $()
+}