[diagnose-unreachable] Adjust test cases for movable guaranteed phis.

The main change is that we do not eliminate end_borrows when propagating
guaranteed phis. This is because phis now forward guaranteed ownership like
owned ownership and since we only eliminate these arguments if all incomign
values to the argument is the same (providing dominance).

Author: gottesmm

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -91,20 +91,14 @@ class UnreachableUserCodeReportingState {
   llvm::DenseMap<const SILBasicBlock*, UnreachableInfo> MetaMap;
 };
 
-static void deleteEndBorrows(SILValue v) {
-  SmallVector<SILInstruction *, 4> endBorrowList;
-  for (auto *use : v->getUses()) {
-    if (auto *ebi = dyn_cast<EndBorrowInst>(use->getUser())) {
-      endBorrowList.push_back(ebi);
-    }
-  }
-  while (!endBorrowList.empty()) {
-    endBorrowList.pop_back_val()->eraseFromParent();
-  }
-}
-
 /// Propagate/remove basic block input values when all predecessors
 /// supply the same arguments.
+///
+/// NOTE: Since BranchInst always forwards guaranteed and owned parameters the
+/// same way (like owned parameters), we do not need to add any special handling
+/// for guaranteed parameters here. This is because if all of the incoming
+/// values into my guaranteed phi is the same, then we know that said incoming
+/// value must dominate the phi by definition.
 static void propagateBasicBlockArgs(SILBasicBlock &BB) {
   // This functions would simplify the code as following:
   //
@@ -185,10 +179,6 @@ static void propagateBasicBlockArgs(SILBasicBlock &BB) {
     // this to CCP and trigger another round of copy propagation.
     SILArgument *Arg = *AI;
 
-    // If this argument is guaranteed and Args[Idx], delete the end_borrow.
-    if (Arg->getOwnershipKind() == ValueOwnershipKind::Guaranteed)
-      deleteEndBorrows(Arg);
-
     // We were able to fold, so all users should use the new folded value.
     Arg->replaceAllUsesWith(Args[Idx]);
     NumBasicBlockArgsPropagated++;

test/SILOptimizer/diagnose_unreachable.sil

@@ -516,15 +516,20 @@ bb3:
   return %9999 : $()
 }
 
+// Rather than eliminate the end_borrow, we just propagate through since
+// branches now act like phis. We could eliminate the begin_borrow scope though,
+// but this pass does not perform that simplification.
+//
 // CHECK-LABEL: sil [ossa] @eliminate_end_borrow_when_propagating_bb_args : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
-// CHECK-NOT: end_borrow
+// CHECK: %1 = begin_borrow %0
 // CHECK: [[FUNC_REF:%.*]] = function_ref @guaranteed_nativeobject_user
-// CHECK-NEXT: apply [[FUNC_REF]](%0) :
-// CHECK-NOT: end_borrow
+// CHECK-NEXT: apply [[FUNC_REF]](%1) :
+// CHECK: end_borrow %1
 // CHECK: } // end sil function 'eliminate_end_borrow_when_propagating_bb_args'
 sil [ossa] @eliminate_end_borrow_when_propagating_bb_args : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
 bb0(%0 : @guaranteed $Builtin.NativeObject):
-  br bb1(%0 : $Builtin.NativeObject)
+  %0a = begin_borrow %0 : $Builtin.NativeObject
+  br bb1(%0a : $Builtin.NativeObject)
 
 bb1(%1 : @guaranteed $Builtin.NativeObject):
   %2 = function_ref @guaranteed_nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
@@ -788,20 +793,20 @@ enum EnumWithB {
   func testit() -> Int
 }
 
-// Test propagation of guaranteed phi arguments. The nested end_borrow
-// must be removed, even with the outer borrow is *not* a function
-// argument.
+// Test propagation of guaranteed phi arguments. The nested end_borrow should
+// not be removed since guaranteed phis propagate now.
 //
 // CHECK-LABEL: sil hidden [ossa] @testEliminatePropagateGuaranteedPhiAfterSwitch : $@convention(method) (@guaranteed EnumWithB) -> () {
 // CHECK: bb1([[PHI:%.*]] : @guaranteed $B):
-// CHECK-NOT: end_borrow
+// CHECK: end_borrow
 // CHECK-LABEL: } // end sil function 'testEliminatePropagateGuaranteedPhiAfterSwitch'
 sil hidden [ossa] @testEliminatePropagateGuaranteedPhiAfterSwitch : $@convention(method) (@guaranteed EnumWithB) -> () {
 bb0(%0 : @guaranteed $EnumWithB):
   switch_enum %0 : $EnumWithB, case #EnumWithB.A!enumelt.1: bb1
 
 bb1(%2 : @guaranteed $B):
-  br bb3(%2 : $B)
+  %2a = begin_borrow %2 : $B
+  br bb3(%2a : $B)
 
 bb3(%4 : @guaranteed $B):
   %99 = tuple ()
@@ -811,8 +816,9 @@ bb3(%4 : @guaranteed $B):
 
 // CHECK-LABEL: sil hidden [ossa] @testEliminatePropagateBeginBorrowGuaranteedPhiAfterSwitch : $@convention(method) (@owned B) -> () {
 // CHECK: [[BORROW:%.*]] = begin_borrow
+// CHECK:  bb1:
+// CHECK:  bb2:
 // CHECK: end_borrow [[BORROW]]
-// CHECK-NOT: end_borrow
 // CHECK-LABEL: } // end sil function 'testEliminatePropagateBeginBorrowGuaranteedPhiAfterSwitch'
 sil hidden [ossa] @testEliminatePropagateBeginBorrowGuaranteedPhiAfterSwitch : $@convention(method) (@owned B) -> () {
 bb0(%0 : @owned $B):
@@ -825,8 +831,6 @@ bb1(%2 : @guaranteed $B):
 bb3(%3 : @guaranteed $B):
   %99 = tuple ()
   end_borrow %3 : $B
-  end_borrow %2 : $B
-  end_borrow %1 : $B
   destroy_value %0 : $B
   return %99 : $()
 }
@@ -853,18 +857,18 @@ bb3(%4 : @guaranteed $B):
 // Make sure that we can handle iterated end_borrow.
 //
 // CHECK-LABEL: sil hidden [ossa] @testPropagateGuaranteedPhi : $@convention(method) (@guaranteed B) -> () {
-// CHECK-NOT: end_borrow
+// CHECK: end_borrow
 // CHECK-LABEL: } // end sil function 'testPropagateGuaranteedPhi'
 sil hidden [ossa] @testPropagateGuaranteedPhi : $@convention(method) (@guaranteed B) -> () {
 bb0(%0 : @guaranteed $B):
-  br bb1(%0 : $B)
+  %0a = begin_borrow %0 : $B
+  br bb1(%0a : $B)
 
 bb1(%1 : @guaranteed $B):
   br bb2(%1 : $B)
 
 bb2(%2 : @guaranteed $B):
   %99 = tuple ()
   end_borrow %2 : $B
-  end_borrow %1 : $B
   return %99 : $()
 }