Merge pull request swiftlang#28725 from gottesmm/pr-1b10b0856adef409da4bed3d4af33137abf625cf

[ownership] Change BorrowScopeIntroducerValue::areInstructionsWithinScope to take SILInstructions instead of BranchPropagatedUser.

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -187,6 +187,14 @@ class LinearLifetimeChecker {
   bool validateLifetime(SILValue value,
                         ArrayRef<SILInstruction *> consumingUses,
                         ArrayRef<SILInstruction *> nonConsumingUses) {
+    assert(llvm::all_of(
+               consumingUses,
+               [](SILInstruction *i) { return !isa<CondBranchInst>(i); }) &&
+           "Passed cond branch to a non-BranchPropagatedUser API");
+    assert(llvm::all_of(
+               nonConsumingUses,
+               [](SILInstruction *i) { return !isa<CondBranchInst>(i); }) &&
+           "Passed cond branch to a non-BranchPropagatedUser API");
     auto *consumingUsesCast =
         reinterpret_cast<const BranchPropagatedUser *>(consumingUses.data());
     auto *nonConsumingUsesCast =
@@ -420,11 +428,11 @@ struct BorrowScopeIntroducingValue {
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool areInstructionsWithinScope(
-      ArrayRef<BranchPropagatedUser> instructions,
-      SmallVectorImpl<BranchPropagatedUser> &scratchSpace,
-      SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-      DeadEndBlocks &deadEndBlocks) const;
+  bool
+  areInstructionsWithinScope(ArrayRef<SILInstruction *> instructions,
+                             SmallVectorImpl<SILInstruction *> &scratchSpace,
+                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                             DeadEndBlocks &deadEndBlocks) const;
 
 private:
   /// Internal constructor for failable static constructor. Please do not expand

lib/SIL/OwnershipUtils.cpp

@@ -195,8 +195,8 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
 }
 
 bool BorrowScopeIntroducingValue::areInstructionsWithinScope(
-    ArrayRef<BranchPropagatedUser> instructions,
-    SmallVectorImpl<BranchPropagatedUser> &scratchSpace,
+    ArrayRef<SILInstruction *> instructions,
+    SmallVectorImpl<SILInstruction *> &scratchSpace,
     SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
     DeadEndBlocks &deadEndBlocks) const {
   // Make sure that we clear our scratch space/utilities before we exit.
@@ -214,8 +214,9 @@ bool BorrowScopeIntroducingValue::areInstructionsWithinScope(
     return true;
 
   // Otherwise, gather up our local scope ending instructions.
-  visitLocalScopeEndingUses(
-      [&scratchSpace](Operand *op) { scratchSpace.emplace_back(op); });
+  visitLocalScopeEndingUses([&scratchSpace](Operand *op) {
+    scratchSpace.emplace_back(op->getUser());
+  });
 
   LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
   return checker.validateLifetime(value, scratchSpace, instructions);

lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -14,7 +14,6 @@
 #include "swift/Basic/BlotSetVector.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/SIL/BasicBlockUtils.h"
-#include "swift/SIL/BranchPropagatedUser.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
@@ -577,21 +576,19 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   //    need to insert an end_borrow since all of our borrow introducers are
   //    non-local scopes.
   {
-    SmallVector<BranchPropagatedUser, 8> destroysForLinearLifetimeCheck;
     bool foundNonDeadEnd = false;
     for (auto *dvi : destroys) {
       foundNonDeadEnd |= !getDeadEndBlocks().isDeadEnd(dvi->getParent());
-      destroysForLinearLifetimeCheck.push_back(&dvi->getAllOperands()[0]);
     }
     if (!foundNonDeadEnd && haveAnyLocalScopes)
       return false;
-    SmallVector<BranchPropagatedUser, 8> scratchSpace;
+    SmallVector<SILInstruction *, 8> scratchSpace;
     SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
     if (llvm::any_of(borrowScopeIntroducers,
                      [&](BorrowScopeIntroducingValue borrowScope) {
                        return !borrowScope.areInstructionsWithinScope(
-                           destroysForLinearLifetimeCheck, scratchSpace,
-                           visitedBlocks, getDeadEndBlocks());
+                           destroys, scratchSpace, visitedBlocks,
+                           getDeadEndBlocks());
                      })) {
       return false;
     }
@@ -786,22 +783,15 @@ class StorageGuaranteesLoadVisitor
 
     // Use the linear lifetime checker to check whether the copied
     // value is dominated by the lifetime of the borrow it's based on.
-    SmallVector<BranchPropagatedUser, 4> baseEndBorrows;
-    for (auto *use : borrowInst->getUses()) {
-      if (isa<EndBorrowInst>(use->getUser())) {
-        baseEndBorrows.emplace_back(use);
-      }
-    }
-    
-    SmallVector<BranchPropagatedUser, 4> valueDestroys;
-    for (auto *use : Load->getUses()) {
-      if (isa<DestroyValueInst>(use->getUser())) {
-        valueDestroys.emplace_back(use);
-      }
-    }
-    
-    SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
+    SmallVector<SILInstruction *, 4> baseEndBorrows;
+    llvm::copy(borrowInst->getUsersOfType<EndBorrowInst>(),
+               std::back_inserter(baseEndBorrows));
 
+    SmallVector<SILInstruction *, 4> valueDestroys;
+    llvm::copy(Load->getUsersOfType<DestroyValueInst>(),
+               std::back_inserter(valueDestroys));
+
+    SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
     LinearLifetimeChecker checker(visitedBlocks, ARCOpt.getDeadEndBlocks());
     // Returns true on success. So we invert.
     bool foundError =