[PrunedLiveness] Branch summary merges to ending.

A branch instruction that is both a lifetime-ending user and also a
non-lifetime-ending of a value should be regarded as a lifetime-ending
user.

Without this, utilities that rely on PrunedLiveness such as
`LinearLiveness` and `InteriorLiveness` both incorrectly report that a
branch featuring a value and also a reborrow or guaranteed phi are
non-ending.

rdar://130427564

Author: nate-chandler

lib/SIL/Utils/PrunedLiveness.cpp

@@ -192,6 +192,43 @@ static FunctionTest
 //                              PrunedLiveRange
 //===----------------------------------------------------------------------===//
 
+static PrunedLiveness::LifetimeEnding
+branchMeet(PrunedLiveness::LifetimeEnding const lhs,
+           PrunedLiveness::LifetimeEnding const rhs) {
+  enum BranchLifetimeEnding {
+    Ending,
+    NonEnding,
+    NonUse,
+  };
+  auto toBranch =
+      [](PrunedLiveness::LifetimeEnding const ending) -> BranchLifetimeEnding {
+    switch (ending) {
+    case PrunedLiveness::LifetimeEnding::Value::NonEnding:
+      return NonEnding;
+    case PrunedLiveness::LifetimeEnding::Value::Ending:
+      return Ending;
+    case PrunedLiveness::LifetimeEnding::Value::NonUse:
+      return NonUse;
+    }
+  };
+  auto toRegular =
+      [](BranchLifetimeEnding const ending) -> PrunedLiveness::LifetimeEnding {
+    switch (ending) {
+    case NonEnding:
+      return PrunedLiveness::LifetimeEnding::Value::NonEnding;
+    case Ending:
+      return PrunedLiveness::LifetimeEnding::Value::Ending;
+    case NonUse:
+      return PrunedLiveness::LifetimeEnding::Value::NonUse;
+    }
+  };
+  return toRegular(std::min(toBranch(lhs), toBranch(rhs)));
+}
+static void branchMeetInPlace(PrunedLiveness::LifetimeEnding &that,
+                              PrunedLiveness::LifetimeEnding const other) {
+  that = branchMeet(that, other);
+}
+
 template <typename LivenessWithDefs>
 void PrunedLiveRange<LivenessWithDefs>::updateForUse(
     SILInstruction *user,
@@ -210,8 +247,13 @@ void PrunedLiveRange<LivenessWithDefs>::updateForUse(
   // This call is not considered the end of %val's lifetime. The @owned
   // argument must be copied.
   auto iterAndSuccess = users.insert({user, lifetimeEnding});
-  if (!iterAndSuccess.second)
-    iterAndSuccess.first->second.meetInPlace(lifetimeEnding);
+  if (!iterAndSuccess.second) {
+    if (isa<BranchInst>(user)) {
+      branchMeetInPlace(iterAndSuccess.first->second, lifetimeEnding);
+    } else {
+      iterAndSuccess.first->second.meetInPlace(lifetimeEnding);
+    }
+  }
 }
 template <typename LivenessWithDefs>
 void PrunedLiveRange<LivenessWithDefs>::updateForUse(SILInstruction *user,

test/SILOptimizer/liveness_unit.sil

@@ -378,7 +378,7 @@ bb1(%reborrow : @guaranteed $C, %phi : @guaranteed $PairC):
 // CHECK-LABEL: testSSAReborrowedPhi: ssa_liveness
 // CHECK: SSA lifetime analysis: %{{.*}} = begin_borrow
 // CHECK-NEXT: bb0: LiveWithin
-// CHECK-NEXT: regular user: br bb1
+// CHECK-NEXT: lifetime-ending user: br bb1
 // CHECK-NEXT: regular user: %{{.*}} = struct
 // CHECK-NEXT: last user: br bb1
 // CHECK-NEXT: end running

test/SILOptimizer/ossa_lifetime_completion.sil

@@ -11,6 +11,8 @@ public enum FakeOptional<T> {
   case some(T)
 }
 
+sil @getC : $@convention(thin) () -> (@owned C)
+
 // CHECK-LABEL: begin running test 1 of 1 on eagerConsumneOwnedArg: ossa-lifetime-completion with: @argument
 // CHECK-LABEL: OSSA lifetime completion: %0 = argument of bb0 : $C
 // CHECK: sil [ossa] @eagerConsumneOwnedArg : $@convention(thin) (@owned C) -> () {
@@ -395,3 +397,38 @@ exit:
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: begin running test {{.*}} on root_of_reborrow: ossa-lifetime-completion
+// Verify that no instructions were inserted after backedge2's terminator.  (In
+// fact, if they were, the test would crash.)
+// CHECK-LABEL: sil [ossa] @root_of_reborrow : {{.*}} {
+// CHECK:       bb1([[C0:%[^,]+]] : @owned $C, [[B0:%[^,]+]] : @reborrow @guaranteed $C):
+// CHECK-NEXT:    end_borrow [[B0]]
+// CHECK-NEXT:    destroy_value [[C0]]
+// CHECK-NEXT:    br
+// CHECK-LABEL: } // end sil function 'root_of_reborrow'
+// CHECK-LABEL: end running test {{.*}} on root_of_reborrow: ossa-lifetime-completion
+sil [ossa] @root_of_reborrow : $@convention(thin) () -> () {
+entry:
+  %getC = function_ref @getC : $@convention(thin) () -> (@owned C)
+  %c = apply %getC() : $@convention(thin) () -> (@owned C)
+  %b = begin_borrow %c : $C
+  br header(%c : $C, %b : $C)
+header(%c0 : @owned $C, %b0 : @reborrow @guaranteed $C):
+  end_borrow %b0 : $C
+  destroy_value %c0 : $C
+  br body
+body:
+  br latch
+latch:
+  cond_br undef, backedge, exit
+backedge:
+  %c1 = apply %getC() : $@convention(thin) () -> (@owned C)
+  %b1 = begin_borrow %c1 : $C
+  br backedge2(%c1 : $C, %b1 : $C)
+backedge2(%c2 : @owned $C, %b2 : @reborrow @guaranteed $C):
+  specify_test "ossa-lifetime-completion %c2"
+  br header(%c2 : $C, %b2 : $C)
+exit:
+  unreachable
+}

test/SILOptimizer/ownership_liveness_unit.sil

@@ -386,7 +386,7 @@ bb1(%reborrow : @guaranteed $C):
 // CHECK: Interior liveness:   %{{.*}} = begin_borrow %0 : $C
 // CHECK-NEXT: Inner scope:   %{{.*}} = begin_borrow %{{.*}} : $D
 // CHECK-NEXT: bb0: LiveWithin
-// CHECK-NEXT: regular user:   br bb1(%{{.*}} : $C, %{{.*}} : $D)
+// CHECK-NEXT: lifetime-ending user:   br bb1(%{{.*}} : $C, %{{.*}} : $D)
 // CHECK-NEXT: regular user:   %{{.*}} = unchecked_ref_cast %{{.*}} : $C to $D
 // CHECK-NEXT: Complete liveness
 // CHECK-NEXT: Unenclosed phis {