[CanonicalizeOSSALifetime] Handle later reborrows.

Properly handle the different sorts of reborrows when they are visited:
- non-branch reborrows (tuples, etc) are non-lifetime-ending uses; such
  reborrows are relevant defs for liveness
- branch reborrows which also consume the owned phi are lifetime-ending
  uses
- branch reborrows which DO NOT consume the owned phi are
  non-lifetime-ending uses, and the corresponding phis are relevant defs
  for liveness

rdar://97399065

Author: nate-chandler

lib/SILOptimizer/Utils/CanonicalOSSALifetime.cpp

@@ -175,10 +175,32 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
       case OperandOwnership::InteriorPointer:
       case OperandOwnership::ForwardingBorrow:
       case OperandOwnership::EndBorrow:
-      case OperandOwnership::Reborrow:
         // Guaranteed values are considered uses of the value when the value is
-        // an owned phi and the guaranteed values are adjacent reborrow phis.
+        // an owned phi and the guaranteed values are adjacent reborrow phis or
+        // reborrow of such.
+        liveness.updateForUse(user, /*lifetimeEnding*/ false);
+        break;
+      case OperandOwnership::Reborrow:
+        BranchInst *branch;
+        if (!(branch = dyn_cast<BranchInst>(user))) {
+          // Non-phi reborrows (tuples, etc) never end the lifetime of the owned
+          // value.
+          liveness.updateForUse(user, /*lifetimeEnding*/ false);
+          defUseWorklist.insert(cast<SingleValueInstruction>(user));
+          break;
+        }
+        if (is_contained(user->getOperandValues(), currentDef)) {
+          // An adjacent phi consumes the value being reborrowed.  Although this
+          // use doesn't end the lifetime, this user does.
+          liveness.updateForUse(user, /*lifetimeEnding*/ true);
+          break;
+        }
+        // No adjacent phi consumes the value.  This use is not lifetime ending.
         liveness.updateForUse(user, /*lifetimeEnding*/ false);
+        // This branch reborrows a guaranteed phi whose lifetime is dependent on
+        // currentDef.  Uses of the reborrowing phi extend liveness.
+        auto *reborrow = branch->getArgForOperand(use);
+        defUseWorklist.insert(reborrow);
         break;
       }
     }

test/SILOptimizer/copy_propagation_canonicalize_with_reborrows.sil

@@ -196,3 +196,111 @@ exit:
   destroy_value %value : $FakeOptional<X>
   return %retval : $()
 }
+
+// Ensure that an adjacent reborrow phi being reborrowed doesn't get counted as
+// a non-lifetime ending use and extend liveness beyond the instruction where
+// the reborrow occurs.
+// CHECK-LABEL: sil [ossa] @reborrow_adjacent_to_consume_doesnt_extend_lifetime : {{.*}} {
+// CHECK:       bb1([[REBORROW:%[^,]+]] : @guaranteed $X, [[VALUE:%[^,]+]] :
+// CHECK:       {{bb[0-9]+}}:
+// CHECK:         end_borrow [[REBORROW]]
+// CHECK:         destroy_value [[VALUE]]
+// CHECK-LABEL: } // end sil function 'reborrow_adjacent_to_consume_doesnt_extend_lifetime'
+sil [ossa] @reborrow_adjacent_to_consume_doesnt_extend_lifetime : $@convention(thin) (@owned X) -> () {
+bb0(%0 : @owned $X):
+  %1 = begin_borrow %0 : $X
+  br bb1(%1 : $X, %0 : $X)
+
+bb1(%3 : @guaranteed $X, %4 : @owned $X):
+  cond_br undef, bb2, bb10
+
+bb2:
+  br bb3
+
+bb3:
+  br bb4(%3 : $X, %4 : $X)
+
+bb4(%8 : @guaranteed $X, %9 : @owned $X):
+  cond_br undef, bb5, bb8
+
+bb5:
+  br bb6
+
+bb6:
+  br bb7
+
+bb7:
+  %13 = function_ref @getX : $@convention(thin) () -> @owned X
+  %14 = apply %13() : $@convention(thin) () -> @owned X
+  end_borrow %8 : $X
+  destroy_value %9 : $X
+  %17 = begin_borrow %14 : $X
+  br bb4(%17 : $X, %14 : $X)
+
+bb8:
+  br bb9
+
+bb9:
+  br bb1(%8 : $X, %9 : $X)
+
+bb10:
+  // TODO: Remove the copy once it isn't necessary to trigger canonicalization.
+  %bogus = copy_value %4 : $X
+  destroy_value %bogus : $X
+  %23 = tuple ()
+  end_borrow %3 : $X
+  destroy_value %4 : $X
+  return %23 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @nohoist_destroy_over_endborrow_nonadjacent_reborrow : {{.*}} {
+// CHECK:         end_borrow {{%[^,]+}}
+// CHECK:         destroy_value {{%[^,]+}}
+// CHECK-LABEL: } // end sil function 'nohoist_destroy_over_endborrow_nonadjacent_reborrow'
+sil [ossa] @nohoist_destroy_over_endborrow_nonadjacent_reborrow : $@convention(thin) (@owned X) -> () {
+entry(%value_1 : @owned $X):
+  %lifetime_1 = begin_borrow %value_1 : $X
+  br consume_and_reborrow(%lifetime_1 : $X, %value_1 : $X)
+
+consume_and_reborrow(%lifetime_2 : @guaranteed $X, %value_2 : @owned $X):
+  br reborrow_only(%lifetime_2 : $X)
+
+reborrow_only(%lifetime_3 : @guaranteed $X):
+  br exit
+
+exit:
+  %bogus = copy_value %value_2 : $X
+  destroy_value %bogus : $X
+  %retval = tuple ()
+  end_borrow %lifetime_3 : $X
+  destroy_value %value_2 : $X
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @nohoist_destroy_over_endborrow_nonadjacent_reborrow_2 : {{.*}} {
+// CHECK:         end_borrow {{%[^,]+}}
+// CHECK:         destroy_value {{%[^,]+}}
+// CHECK-LABEL: } // end sil function 'nohoist_destroy_over_endborrow_nonadjacent_reborrow_2'
+sil [ossa] @nohoist_destroy_over_endborrow_nonadjacent_reborrow_2 : $@convention(thin) (@owned X) -> () {
+entry(%value_1 : @owned $X):
+  %lifetime_1 = begin_borrow %value_1 : $X
+  br consume_and_reborrow(%lifetime_1 : $X, %value_1 : $X)
+
+consume_and_reborrow(%lifetime_2 : @guaranteed $X, %value_2 : @owned $X):
+  br reborrow_only_1(%lifetime_2 : $X)
+
+reborrow_only_1(%lifetime_3 : @guaranteed $X):
+  br reborrow_only_2(%lifetime_3 : $X)
+
+reborrow_only_2(%lifetime_4 : @guaranteed $X):
+  br exit
+
+exit:
+  %bogus = copy_value %value_2 : $X
+  destroy_value %bogus : $X
+  %retval = tuple ()
+  end_borrow %lifetime_4 : $X
+  destroy_value %value_2 : $X
+  return %retval : $()
+}
+