[OSSACanOwned] Extend all lifetimes to dead-ends.

Uses of borrows may occur between the borrow and a dead-end regardless
of lexicality, so always extend lifetimes to dead-ends.

Author: nate-chandler

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -370,9 +370,7 @@ class CanonicalizeOSSALifetime final {
     currentDef = def;
     currentLexicalLifetimeEnds = lexicalLifetimeEnds;
 
-    if (maximizeLifetime || respectsDeinitBarriers()) {
-      liveness->initializeDiscoveredBlocks(&discoveredBlocks);
-    }
+    liveness->initializeDiscoveredBlocks(&discoveredBlocks);
     liveness->initializeDef(getCurrentDef());
   }
 

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -274,6 +274,18 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
   return true;
 }
 
+/// Extend liveness to the copy-extended availability boundary of currentDef.
+/// Prevents destroys from being inserted between borrows of (copies of) the
+/// def and dead-ends.
+///
+/// Example:
+///     %def need not be lexical
+///     %c = copy_value %def
+///     %sb = store_borrow %c to %addr
+///     // Must extend lifetime of %def up to this point.  Otherwise, a
+///     // destroy_value could be inserted within a borrow scope or interior
+///     // pointer use.
+///     unreachable
 void CanonicalizeOSSALifetime::extendLivenessToDeadEnds() {
   // TODO: OSSALifetimeCompletion: Once lifetimes are always complete, delete
   //                               this method.
@@ -1356,8 +1368,8 @@ bool CanonicalizeOSSALifetime::computeLiveness() {
     clear();
     return false;
   }
+  extendLivenessToDeadEnds();
   if (respectsDeinitBarriers()) {
-    extendLivenessToDeadEnds();
     extendLivenessToDeinitBarriers();
   }
   if (accessBlockAnalysis) {

test/SILOptimizer/assemblyvision_remark/chacha.swift

@@ -28,8 +28,8 @@ func checkResult(_ plaintext: [UInt8]) {
 
 @_semantics("optremark.sil-assembly-vision-remark-gen")
 public func run_ChaCha(_ N: Int) {
-  let key = Array(repeating: UInt8(1), count: 32) // expected-remark {{release of type '}}
-  let nonce = Array(repeating: UInt8(2), count: 12) // expected-remark {{release of type '}}
+  let key = Array(repeating: UInt8(1), count: 32) // expected-note {{of 'key}}
+  let nonce = Array(repeating: UInt8(2), count: 12) // expected-note {{of 'nonce}}
 
   var checkedtext = Array(repeating: UInt8(0), count: 1024) // expected-note {{of 'checkedtext}}
   ChaCha20.encrypt(bytes: &checkedtext, key: key, nonce: nonce)
@@ -44,3 +44,5 @@ public func run_ChaCha(_ N: Int) {
   }
 } // expected-remark {{release of type '}}
   // expected-remark @-1 {{release of type '}}
+  // expected-remark @-2 {{release of type '}}
+  // expected-remark @-3 {{release of type '}}

test/SILOptimizer/canonicalize_ossa_lifetime_unit.sil

@@ -885,6 +885,33 @@ die:
   unreachable
 }
 
+// CHECK-LABEL: begin running test {{.*}} on consume_copy_before_use_in_dead_end_2
+// CHECK-LABEL: sil [ossa] @consume_copy_before_use_in_dead_end_2 : {{.*}} {
+// CHECK-NOT:     destroy_value [dead_end]
+// CHECK-LABEL: } // end sil function 'consume_copy_before_use_in_dead_end_2'
+// CHECK-LABEL: end running test {{.*}} on consume_copy_before_use_in_dead_end_2
+sil [ossa] @consume_copy_before_use_in_dead_end_2 : $@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 %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
+}
+
 // The destroy of a value must not be hoisted over a destroy of a copy of a
 // partial_apply [on_stack] which captures the value.
 // CHECK-LABEL: begin running test {{.*}} on destroy_after_pa_copy_destroy