Update DCE for @guaranteed forwarding phi support

Author: meg-gupta

lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -50,7 +50,8 @@ static bool seemsUseful(SILInstruction *I) {
   // side-effects, they can be DCE'ed if they do not have useful
   // dependencies/reverse dependencies
   if (isa<BeginAccessInst>(I) || isa<CopyValueInst>(I) ||
-      isa<DestroyValueInst>(I) || isa<EndLifetimeInst>(I))
+      isa<DestroyValueInst>(I) || isa<EndLifetimeInst>(I) ||
+      isa<EndBorrowInst>(I))
     return false;
 
   // A load [copy] is okay to be DCE'ed if there are no useful dependencies
@@ -125,13 +126,12 @@ class DCE {
   llvm::DenseMap<SILValue, SmallPtrSet<SILInstruction *, 4>>
       ReverseDependencies;
 
-  // reborrowDependencies tracks the dependency of a reborrowed phiArg with its
-  // renamed base value.
-  // A reborrowed phiArg may have a new base value, if it's original base value
-  // was also passed as a branch operand. The renamed base value should then be
-  // live if the reborrow phiArg was also live.
+  // guaranteedPhiDependencies tracks the dependency of a reborrowed phiArg with
+  // its renamed base value. A reborrowed phiArg may have a new base value, if
+  // it's original base value was also passed as a branch operand. The renamed
+  // base value should then be live if the reborrow phiArg was also live.
   using BaseValueSet = SmallPtrSet<SILValue, 8>;
-  llvm::DenseMap<SILPhiArgument *, BaseValueSet> reborrowDependencies;
+  llvm::DenseMap<SILPhiArgument *, BaseValueSet> guaranteedPhiDependencies;
 
   /// Tracks if the pass changed branches.
   bool BranchesChanged = false;
@@ -145,7 +145,7 @@ class DCE {
   void addReverseDependency(SILValue from, SILInstruction *to);
   /// Starting from \p borrowInst find all reborrow dependency of its reborrows
   /// with their renamed base values.
-  void findReborrowDependencies(BeginBorrowInst *borrowInst);
+  void findGuaranteedPhiDependencies(BeginBorrowInst *borrowInst);
   bool removeDead();
 
   void computeLevelNumbers(PostDomTreeNode *root);
@@ -288,7 +288,6 @@ void DCE::markLive() {
         auto *borrowInst = cast<BeginBorrowInst>(&I);
         if (borrowInst->getOperand()->getOwnershipKind() ==
             OwnershipKind::Guaranteed) {
-          markInstructionLive(borrowInst);
           // Visit the end_borrows of all the borrow scopes that this
           // begin_borrow could be borrowing.
           SmallVector<SILValue, 4> roots;
@@ -301,8 +300,8 @@ void DCE::markLive() {
           }
           continue;
         }
-        // Populate reborrowDependencies for this borrow
-        findReborrowDependencies(borrowInst);
+        // Populate guaranteedPhiDependencies for this borrow
+        findGuaranteedPhiDependencies(borrowInst);
         // Don't optimize a borrow scope if it is lexical or has a pointer
         // escape.
         if (borrowInst->isLexical() ||
@@ -337,19 +336,20 @@ void DCE::addReverseDependency(SILValue from, SILInstruction *to) {
   ReverseDependencies[from].insert(to);
 }
 
-void DCE::findReborrowDependencies(BeginBorrowInst *borrowInst) {
-  LLVM_DEBUG(llvm::dbgs() << "Finding reborrow dependencies of " << borrowInst
-                          << "\n");
+void DCE::findGuaranteedPhiDependencies(BeginBorrowInst *borrowInst) {
+  LLVM_DEBUG(llvm::dbgs() << "Finding @guaranteed phi dependencies of "
+                          << borrowInst << "\n");
   BorrowingOperand initialScopedOperand(&borrowInst->getOperandRef());
-  auto visitReborrowBaseValuePair = [&](SILPhiArgument *phiArg,
-                                        SILValue baseValue) {
-    reborrowDependencies[phiArg].insert(baseValue);
+  auto visitDependentPhiBaseValuePair = [&](SILPhiArgument *phiArg,
+                                            SILValue baseValue) {
+    guaranteedPhiDependencies[phiArg].insert(baseValue);
   };
-  // Find all reborrow dependencies starting from \p borrowInst and populate
-  // them in reborrowDependencies
-  findTransitiveReborrowBaseValuePairs(initialScopedOperand,
-                                       borrowInst->getOperand(),
-                                       visitReborrowBaseValuePair);
+  // Find all dependencies starting from \p borrowInst and populate
+  // them in guaranteedPhiDependencies
+  visitExtendedReborrowPhiBaseValuePairs(borrowInst,
+                                         visitDependentPhiBaseValuePair);
+  visitExtendedGuaranteedForwardingPhiBaseValuePairs(
+      BorrowedValue(borrowInst), visitDependentPhiBaseValuePair);
 }
 
 // Mark as live the terminator argument at index ArgIndex in Pred that
@@ -429,7 +429,7 @@ void DCE::propagateLiveBlockArgument(SILArgument *Arg) {
   }
 
   if (auto *phi = dyn_cast<SILPhiArgument>(Arg)) {
-    for (auto depVal : reborrowDependencies.lookup(phi)) {
+    for (auto depVal : guaranteedPhiDependencies.lookup(phi)) {
       markValueLive(depVal);
     }
   }

test/SILOptimizer/dead_code_elimination_nontrivial_ossa.sil

@@ -23,6 +23,14 @@ case none
 case some(T)
 }
 
+struct Wrapper1 {
+  var val1: Wrapper2
+}
+
+struct Wrapper2 {
+  var val2: Klass
+}
+
 sil [ossa] @$testtryapplyklassgen : $@convention(thin) () -> (@owned Klass, @error any Error)
 sil [ossa] @$use_klass1 : $@convention(thin) (@owned Klass) -> ()
 sil [ossa] @$use_klass2 : $@convention(thin) (@guaranteed Klass) -> ()
@@ -728,17 +736,10 @@ bb3(%original : @owned $Klass, %lifetime : @guaranteed $Klass):
 
 // CHECK-LABEL: sil [ossa] @borrow_none : {{.*}} {
 // CHECK:       {{bb[0-9]+}}:
-// CHECK:         [[INSTANCE:%[^,]+]] = enum $FakeOptional<Klass>, #FakeOptional.none!enumelt
-// CHECK:         switch_enum [[INSTANCE]] : $FakeOptional<Klass>, case #FakeOptional.some!enumelt: [[WORK:bb[0-9]+]], case #FakeOptional.none!enumelt: [[TO_EXIT:bb[0-9]+]], forwarding: @guaranteed
-// CHECK:       [[TO_EXIT]]:
-// CHECK:         br [[EXIT:bb[0-9]+]]
-// CHECK:       [[WORK]]([[PAYLOAD:%[^,]+]] : @guaranteed $Klass):
-// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[PAYLOAD]]
-// CHECK:         end_borrow [[LIFETIME]]
-// CHECK:         br [[EXIT]]
+// CHECK-NEXT:    br [[EXIT:bb[0-9]+]]
 // CHECK:       [[EXIT]]:
-// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
-// CHECK:         return [[RETVAL]] : $()
+// CHECK-NEXT:    [[RETVAL:%[^,]+]] = tuple ()
+// CHECK-NEXT:    return [[RETVAL]] : $()
 // CHECK-LABEL: } // end sil function 'borrow_none'
 sil [ossa] @borrow_none : $@convention(thin) () -> () {
 entry:
@@ -810,8 +811,6 @@ exit(%outer_lifetime_3 : @guaranteed $Klass, %inner_lifetime_2 : @guaranteed $Kl
 // CHECK:         [[BORROW_EITHER:%[^,]+]] = begin_borrow [[EITHER]]
 // CHECK:         switch_enum [[BORROW_EITHER]] : $EitherNoneOrAnyObject, case #EitherNoneOrAnyObject.none!enumelt: [[NONE_BLOCK:bb[0-9]+]], case #EitherNoneOrAnyObject.any!enumelt: [[SOME_BLOCK:bb[0-9]+]]
 // CHECK:       [[SOME_BLOCK]]([[PAYLOAD:%[^,]+]] : @guaranteed $AnyObject):
-// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[PAYLOAD]]
-// CHECK:         end_borrow [[LIFETIME]]
 // CHECK:         end_borrow [[BORROW_EITHER]]
 // CHECK:         destroy_value [[EITHER]]
 // CHECK:         br [[EXIT:bb[0-9]+]]
@@ -845,6 +844,18 @@ exit:
   return %retval : $()
 }
 
+sil [ossa] @reborrowed_guaranteed_phi3 : $@convention(thin) (@owned Klass) -> () {
+entry(%instance : @owned $Klass):
+  %outer_lifetime_1 = begin_borrow %instance : $Klass
+  %inner_lifetime_1 = begin_borrow %outer_lifetime_1 : $Klass
+  br exit(%inner_lifetime_1 : $Klass)
+exit(%inner_lifetime_2 : @guaranteed $Klass):
+  end_borrow %inner_lifetime_2 : $Klass
+  end_borrow %outer_lifetime_1 : $Klass
+  destroy_value %instance : $Klass
+  %retval = tuple ()
+  return %retval : $()
+}
 // CHECK-LABEL: sil [ossa] @reborrow_load_borrow : {{.*}} {
 // CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] : $*Klass):
 // CHECK:         [[LIFETIME:%[^,]+]] = load_borrow [[INSTANCE]]
@@ -998,3 +1009,50 @@ bb1(%21 : $@noescape @callee_guaranteed () -> (), %22 : @guaranteed $@callee_gua
   %28 = tuple ()
   return %28: $()
 }
+
+sil @use_klass : $@convention(thin) (@guaranteed Klass) -> ()
+
+sil [ossa] @test_forwarded_phi4 : $@convention(thin) (@owned Wrapper1) -> () {
+bb0(%0 : @owned $Wrapper1):
+  %outer = begin_borrow %0 : $Wrapper1
+  br bb1 
+
+bb1:
+  %ex1 = struct_extract %outer : $Wrapper1, #Wrapper1.val1
+  br bb2(%ex1 : $Wrapper2, %outer : $Wrapper1)
+
+bb2(%phi1 : @guaranteed $Wrapper2, %phi2 : @guaranteed $Wrapper1):
+  %ex2 = struct_extract %phi1 : $Wrapper2, #Wrapper2.val2
+  br bb3(%ex2 : $Klass, %phi2 : $Wrapper1)
+
+bb3(%phi3 : @guaranteed $Klass, %phi4 : @guaranteed $Wrapper1):
+  %f = function_ref @use_klass : $@convention(thin) (@guaranteed Klass) -> ()
+  apply %f(%phi3) : $@convention(thin) (@guaranteed Klass) -> ()
+  end_borrow %phi4 : $Wrapper1
+  destroy_value %0 : $Wrapper1
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+sil [ossa] @test_loadborrow_dep : $@convention(thin) (@in Wrapper1) -> () {
+bb0(%0 : $*Wrapper1):
+  %outer = load_borrow %0 : $*Wrapper1
+  br bb1 
+
+bb1:
+  %ex1 = struct_extract %outer : $Wrapper1, #Wrapper1.val1
+  br bb2(%ex1 : $Wrapper2, %outer : $Wrapper1)
+
+bb2(%phi1 : @guaranteed $Wrapper2, %phi2 : @guaranteed $Wrapper1):
+  %ex2 = struct_extract %phi1 : $Wrapper2, #Wrapper2.val2
+  br bb3(%ex2 : $Klass, %phi2 : $Wrapper1)
+
+bb3(%phi3 : @guaranteed $Klass, %phi4 : @guaranteed $Wrapper1):
+  %f = function_ref @use_klass : $@convention(thin) (@guaranteed Klass) -> ()
+  apply %f(%phi3) : $@convention(thin) (@guaranteed Klass) -> ()
+  end_borrow %phi4 : $Wrapper1
+  destroy_addr %0 : $*Wrapper1
+  %9999 = tuple()
+  return %9999 : $()
+}
+