[DCE] Keep insts which consume escaping values.

When DCE deletes instructions as dead, if the instruction ends one of
its operands lifetimes, it must insert a compensating lifetime end.
When the def block of the value and the parent block of the instruction
are different, it uses lifetime completion.  Lifetime completion relies
on complete liveness, which doesn't and can't exist for values with
pointer escapes.  The result is ending lifetimes too early.

Avoid this scenario by marking such instructions live.

In the fullness of time, it may be possible to track the deleted
instruction's "location" even in the face of deletions of adjacent
instructions and parent blocks and to insert the lifetime end at that
location.

rdar://149007151

Author: nate-chandler

lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -77,6 +77,28 @@ static bool seemsUseful(SILInstruction *I) {
     return true;
   }
 
+  // Instructions which end the lifetimes of values which escape can only be
+  // deleted if compensating lifetime ends are added.  Compensating lifetime
+  // ends are added by OSSACompleteLifetime when the def block of the value
+  // is different from the parent block of the instruction.  But
+  // OSSACompleteLifetime requires that liveness be complete--that there are no
+  // pointer escapes.  So we can't delete instructions which end the lifetime
+  // of values which escape to a pointer and whose parent blocks are different.
+  if (llvm::any_of(I->getAllOperands(), [I](Operand &operand) {
+        if (!operand.isLifetimeEnding())
+          return false;
+        auto value = operand.get();
+        if (isa<SILUndef>(value))
+          return false;
+        auto *insertionPoint = value->getDefiningInsertionPoint();
+        ASSERT(insertionPoint);
+        if (insertionPoint->getParent() == I->getParent())
+          return false;
+        return findPointerEscape(value);
+      })) {
+    return true;
+  }
+
   if (auto *BI = dyn_cast<BuiltinInst>(I)) {
     // Although the onFastPath builtin has no side-effects we don't want to
     // remove it.

test/SILOptimizer/dead_code_elimination_ossa.sil

@@ -15,12 +15,18 @@ class C {}
 
 sil @getC : $@convention(thin) () -> @owned C
 sil @barrier : $@convention(thin) () -> ()
+sil @initC : $@convention(thin) (Builtin.Word) -> (@owned C, Builtin.RawPointer)
+sil [readnone] @finalC : $@convention(thin) (@owned C) -> @owned C
 
 struct CAndBit {
     var c: C
     var bit: Int1
 }
 
+struct Bool {
+  var _value: Builtin.Int1
+}
+
 struct MO: ~Copyable {
   var x: Int
   deinit
@@ -507,3 +513,28 @@ bb0(%0 : @owned $Outer):
   return %6 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @dont_remove_lifetime_end_of_escaping_value
+// CHECK:         [[FINALIZE:%[^,]+]] = function_ref @finalC
+// CHECK:         apply [[FINALIZE]]
+// CHECK-LABEL: } // end sil function 'dont_remove_lifetime_end_of_escaping_value'
+sil [ossa] @dont_remove_lifetime_end_of_escaping_value : $@convention(thin) (Bool) -> () {
+bb0(%0 : $Bool):
+  %1 = integer_literal $Builtin.Word, 1
+  %2 = function_ref @initC : $@convention(thin) (Builtin.Word) -> (@owned C, Builtin.RawPointer)
+  %3 = apply %2(%1) : $@convention(thin) (Builtin.Word) -> (@owned C, Builtin.RawPointer)
+  (%4, %5) = destructure_tuple %3
+  %6 = mark_dependence %5 on %4
+  %7 = pointer_to_address %6 to [strict] $*Bool
+  store %0 to [trivial] %7
+  br bb1
+
+bb1:
+  %13 = function_ref @finalC : $@convention(thin) (@owned C) -> @owned C
+  %14 = apply %13(%4) : $@convention(thin) (@owned C) -> @owned C
+  destroy_value %14
+  br bb2
+
+bb2:
+  %17 = tuple ()
+  return %17
+}