[OSSACanOwned] Dead-end extend base lifetime.

Regardless of consumes of copies, if the original lexical value is not
consumed on a dead-end path, it must remain live to that dead-end.

rdar://145226757

Author: nate-chandler

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -237,6 +237,8 @@ class CanonicalizeOSSALifetime final {
   /// copies.
   const MaximizeLifetime_t maximizeLifetime;
 
+  SILFunction *function;
+
   // If present, will be used to ensure that the lifetime is not shortened to
   // end inside an access scope which it previously enclosed.  (Note that ending
   // before such an access scope is fine regardless.)
@@ -354,7 +356,7 @@ class CanonicalizeOSSALifetime final {
       DeadEndBlocksAnalysis *deadEndBlocksAnalysis, DominanceInfo *domTree,
       BasicCalleeAnalysis *calleeAnalysis, InstructionDeleter &deleter)
       : pruneDebugMode(pruneDebugMode), maximizeLifetime(maximizeLifetime),
-        accessBlockAnalysis(accessBlockAnalysis),
+        function(function), accessBlockAnalysis(accessBlockAnalysis),
         deadEndBlocksAnalysis(deadEndBlocksAnalysis), domTree(domTree),
         calleeAnalysis(calleeAnalysis), deleter(deleter) {}
 
@@ -497,6 +499,7 @@ class CanonicalizeOSSALifetime final {
                             PrunedLivenessBoundary &boundary);
 
   void extendLivenessToDeadEnds();
+  void extendLexicalLivenessToDeadEnds();
   void extendLivenessToDeinitBarriers();
 
   void extendUnconsumedLiveness(PrunedLivenessBoundary const &boundary);

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -274,6 +274,32 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
   return true;
 }
 
+/// Extend liveness to the availability boundary of currentDef.  Even if a copy
+/// is consumed on a path to the dead-end, if the def stays live through to the
+/// dead-end, its lifetime must not be shrunk back from it (eventually we'll
+/// support shrinking it back to deinit barriers).
+void CanonicalizeOSSALifetime::extendLexicalLivenessToDeadEnds() {
+  // TODO: OSSALifetimeCompletion: Once lifetimes are always complete, delete
+  //                               this method.
+  SmallVector<SILBasicBlock *, 32> lexicalDiscoverdBlocks;
+  SSAPrunedLiveness lexicalLiveness(function, &lexicalDiscoverdBlocks);
+  lexicalLiveness.initializeDef(getCurrentDef());
+  lexicalLiveness.computeSimple();
+  OSSALifetimeCompletion::visitAvailabilityBoundary(
+      getCurrentDef(), lexicalLiveness, [&](auto *unreachable, auto end) {
+        if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {
+          recordUnreachableLifetimeEnd(unreachable);
+        }
+        unreachable->visitPriorInstructions([&](auto *inst) {
+          liveness->extendToNonUse(inst);
+          return true;
+        });
+      });
+}
+
+/// Extend liveness to the availability boundary of the copy-extended
+/// availability boundary of currentDef.  Prevents destroys from being inserted
+/// between borrows of (copies of) the def and dead-ends.
 void CanonicalizeOSSALifetime::extendLivenessToDeadEnds() {
   // TODO: OSSALifetimeCompletion: Once lifetimes are always complete, delete
   //                               this method.
@@ -1356,6 +1382,9 @@ bool CanonicalizeOSSALifetime::computeLiveness() {
     clear();
     return false;
   }
+  if (respectsDeinitBarriers()) {
+    extendLexicalLivenessToDeadEnds();
+  }
   extendLivenessToDeadEnds();
   if (respectsDeinitBarriers()) {
     extendLivenessToDeinitBarriers();

test/SILOptimizer/canonicalize_ossa_lifetime_unit.sil

@@ -3,6 +3,9 @@
 import Swift
 
 class C {}
+
+enum Never {}
+sil @run : $@convention(thin) () -> Never
 sil @getOwned : $@convention(thin) () -> @owned C
 sil @barrier : $@convention(thin) () -> ()
 sil [ossa] @getC : $@convention(thin) () -> @owned C
@@ -945,3 +948,18 @@ entry(%a: @owned $C):
   %retval = tuple ()
   return %retval
 }
+
+// CHECK-LABEL: begin running test {{.*}} on extend_lifetime_to_deadend_despite_copy_consume
+// CHECK-LABEL: sil [ossa] @extend_lifetime_to_deadend_despite_copy_consume : {{.*}} {
+// CHECK:         copy_value
+// CHECK-LABEL: } // end sil function 'extend_lifetime_to_deadend_despite_copy_consume'
+// CHECK-LABEL: end running test {{.*}} on extend_lifetime_to_deadend_despite_copy_consume
+sil [ossa] @extend_lifetime_to_deadend_despite_copy_consume : $@convention(thin) (@owned C) -> () {
+entry(%c : @owned $C):
+  specify_test "canonicalize_ossa_lifetime true false true @argument"
+  %cc = copy_value %c
+  %takeC = function_ref @takeC : $@convention(thin) (@owned C) -> ()
+  apply %takeC(%cc) : $@convention(thin) (@owned C) -> ()
+  %run = function_ref @run : $@convention(thin) () -> Never
+  unreachable
+}