[OSSACanOwned] Fix liveness passed to completion.

To determine where a lifetime ends within dead-end blocks,
OSSACanonicalizeOwned uses OSSACompleteLifetime's
visitAvailabilityBoundary.  This API takes a liveness which it uses to
walk forward to the availability boundary.  Specifically, the liveness
passed from OSSACanonicalizeOwned to OSSACompleteLifetime is a variation
of OSSACanonicalizeOwned's own liveness (it has destroys added).

There is a mismatch in the characteristics of livenesses created by
OSSACanonicalizeOwned and OSSACompleteLifetime:  The former deals with
not only direct uses of a value but also uses of its copies; that
introduces the possibility for consuming uses in the middle of liveness.
The latter on the other hand deals only with uses of a single value
(nestedly, but at each level of nesting only a single value).  Passing a
liveness from the former to the latter without handling this mismatch
is incorrect: OSSACompleteLifetime understands consuming uses to always
end a lifetime, even when they are in the middle of a copy-extended
liveness.  The result is that OSSACompleteLifetime produces non-sensical
results when provided with such a liveness.

To address this, fixup the liveness passed from OSSACanonicalizeOwned to
OSSACompleteLifetime by demoting consuming uses that appear within
(that's to say _not_ on the boundary) of liveness to non-consuming uses.

rdar://142846936

Author: nate-chandler

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -285,6 +285,43 @@ void CanonicalizeOSSALifetime::extendLivenessToDeadEnds() {
     completeLiveness.updateForUse(destroy, /*lifetimeEnding*/ true);
   }
 
+  // Demote consuming uses within complete liveness to non-consuming uses.
+  //
+  // OSSALifetimeCompletion considers the lifetime of a single value.  Such
+  // lifetimes never continue beyond consumes.
+  std::optional<llvm::SmallPtrSet<SILInstruction *, 8>> lastUsers;
+  auto isConsumeOnBoundary = [&](SILInstruction *instruction) -> bool {
+    if (!lastUsers) {
+      // Avoid computing lastUsers if possible.
+      auto *function = getCurrentDef()->getFunction();
+      auto *deadEnds = deadEndBlocksAnalysis->get(function);
+      llvm::SmallVector<SILBasicBlock *, 8> completeConsumingBlocks(
+          consumingBlocks.getArrayRef());
+      for (auto &block : *function) {
+        if (!deadEnds->isDeadEnd(&block))
+          continue;
+        completeConsumingBlocks.push_back(&block);
+      }
+      PrunedLivenessBoundary boundary;
+      liveness->computeBoundary(boundary, completeConsumingBlocks);
+
+      lastUsers.emplace();
+      for (auto *lastUser : boundary.lastUsers) {
+        lastUsers->insert(lastUser);
+      }
+    }
+    return lastUsers->contains(instruction);
+  };
+  for (auto pair : liveness->getAllUsers()) {
+    if (!pair.second.isEnding())
+      continue;
+    auto *instruction = pair.first;
+    if (isConsumeOnBoundary(instruction))
+      continue;
+    // Demote instruction's lifetime-ending-ness to non-lifetime-ending.
+    completeLiveness.updateForUse(pair.first, /*lifetimeEnding=*/false);
+  }
+
   OSSALifetimeCompletion::visitAvailabilityBoundary(
       getCurrentDef(), completeLiveness, [&](auto *unreachable, auto end) {
         if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {

test/SILOptimizer/canonicalize_ossa_lifetime_unit.sil

@@ -857,3 +857,30 @@ exit:
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: begin running test {{.*}} on consume_copy_before_use_in_dead_end
+// CHECK-LABEL: sil [ossa] @consume_copy_before_use_in_dead_end : {{.*}} {
+// CHECK-NOT:     destroy_value [dead_end]
+// CHECK-LABEL: } // end sil function 'consume_copy_before_use_in_dead_end'
+// CHECK-LABEL: end running test {{.*}} on consume_copy_before_use_in_dead_end
+sil [ossa] @consume_copy_before_use_in_dead_end : $@convention(thin) (@owned C) -> () {
+entry(%c : @owned $C):
+  cond_br undef, exit, die
+
+exit:
+  destroy_value %c
+  %retval = tuple ()
+  return %retval
+
+die:
+  %move = move_value [lexical] %c
+  %copy = copy_value %move
+  specify_test "canonicalize_ossa_lifetime true false true %move"
+  apply undef(%move) : $@convention(thin) (@owned C) -> ()
+  %addr = alloc_stack $C
+  %token = store_borrow %copy to %addr
+  apply undef() : $@convention(thin) () -> ()
+  %reload = load_borrow %token
+  apply undef(%reload) : $@convention(thin) (@guaranteed C) -> ()
+  unreachable
+}