Add functionality to the OSSA BorrowedValue utility.

This abstraction is heavily used to ask about the current borrow scope
enclosing some uses. Give it the functionality it needs.

Add BorrowedValue::computeLiveness(PrunedLiveness). Get the borrow
scope's live range. A trivial 4-line implementation.

Cleanup BorrowedValue::areUsesWithinScope(). Quick check to see if a set
of uses known to be dominated by the borrow are within the borrow scope.

Add BorrowedValue::hasReborrow(). Is this local borrow scope
reborrowed? If not, then it's local scope-ending operations are the
end of its required lifetime.

Simplify BorrowedValue::gatherReborrows() to use OperandOwnership::Reborrow.

Author: atrick

include/swift/SIL/OwnershipUtils.h

@@ -15,9 +15,10 @@
 
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/SILArgument.h"
-#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -29,6 +30,7 @@ class SILInstruction;
 class SILModule;
 class SILValue;
 class DeadEndBlocks;
+class PrunedLiveness;
 
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
@@ -535,14 +537,19 @@ struct BorrowedValue {
 
   bool isLocalScope() const { return kind.isLocalScope(); }
 
-  /// Returns true if the passed in set of uses is completely within
-  /// the lifetime of this borrow introducer.
+  /// Add this scopes live blocks into the PrunedLiveness result.
+  void computeLiveness(PrunedLiveness &liveness) const;
+
+  /// Returns true if \p uses are completely within this borrow introducer's
+  /// local scope.
+  ///
+  /// Precondition: \p uses are dominated by the local borrow introducer.
   ///
-  /// NOTE: Scratch space is used internally to this method to store the end
-  /// borrow scopes if needed.
-  bool areUsesWithinScope(ArrayRef<Operand *> uses,
-                          SmallVectorImpl<Operand *> &scratchSpace,
-                          DeadEndBlocks &deadEndBlocks) const;
+  /// This ignores reborrows. The assumption is that, since \p uses are
+  /// dominated by this local scope, checking the extended borrow scope should
+  /// not be necessary to determine they are within the scope.
+  bool areUsesWithinLocalScope(ArrayRef<Operand *> uses,
+                               DeadEndBlocks &deadEndBlocks) const;
 
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments. \p
@@ -583,6 +590,14 @@ struct BorrowedValue {
         func, InteriorPointerOperandVisitorKind::YesNestedYesReborrows);
   }
 
+  bool hasReborrow() const {
+    for (auto *op : value->getUses()) {
+      if (op->getOperandOwnership() == OperandOwnership::Reborrow)
+        return true;
+    }
+    return false;
+  }
+
   /// Visit all immediate uses of this borrowed value and if any of them are
   /// reborrows, place them in BorrowingOperand form into \p
   /// foundReborrows. Returns true if we appended any such reborrows to
@@ -591,12 +606,10 @@ struct BorrowedValue {
                            &foundReborrows) const {
     bool foundAnyReborrows = false;
     for (auto *op : value->getUses()) {
-      if (auto borrowingOperand = BorrowingOperand(op)) {
-        if (borrowingOperand.isReborrow()) {
-          foundReborrows.push_back(
-              {value->getParentBlock(), op->getOperandNumber()});
-          foundAnyReborrows = true;
-        }
+      if (op->getOperandOwnership() == OperandOwnership::Reborrow) {
+        foundReborrows.push_back(
+            {value->getParentBlock(), op->getOperandNumber()});
+        foundAnyReborrows = true;
       }
     }
     return foundAnyReborrows;

lib/SIL/Utils/OwnershipUtils.cpp

@@ -550,14 +550,17 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
   return os;
 }
 
-bool BorrowedValue::areUsesWithinScope(
-    ArrayRef<Operand *> uses, SmallVectorImpl<Operand *> &scratchSpace,
-    DeadEndBlocks &deadEndBlocks) const {
-  // Make sure that we clear our scratch space/utilities before we exit.
-  SWIFT_DEFER {
-    scratchSpace.clear();
-  };
+/// Add this scopes live blocks into the PrunedLiveness result.
+void BorrowedValue::computeLiveness(PrunedLiveness &liveness) const {
+  liveness.initializeDefBlock(value->getParentBlock());
+  visitLocalScopeEndingUses([&](Operand *endOp) {
+    liveness.updateForUse(endOp->getUser(), true);
+    return true;
+  });
+}
 
+bool BorrowedValue::areUsesWithinLocalScope(
+    ArrayRef<Operand *> uses, DeadEndBlocks &deadEndBlocks) const {
   // First make sure that we actually have a local scope. If we have a non-local
   // scope, then we have something (like a SILFunctionArgument) where a larger
   // semantic construct (in the case of SILFunctionArgument, the function
@@ -566,15 +569,10 @@ bool BorrowedValue::areUsesWithinScope(
   if (!isLocalScope())
     return true;
 
-  // Otherwise, gather up our local scope ending instructions, looking through
-  // guaranteed phi nodes.
-  visitExtendedLocalScopeEndingUses([&scratchSpace](Operand *op) {
-    scratchSpace.emplace_back(op);
-    return true;
-  });
-
-  LinearLifetimeChecker checker(deadEndBlocks);
-  return checker.validateLifetime(value, scratchSpace, uses);
+  // Compute the local scope's liveness.
+  PrunedLiveness liveness;
+  computeLiveness(liveness);
+  return liveness.areUsesWithinBoundary(uses, deadEndBlocks);
 }
 
 // The visitor \p func is only called on final scope-ending uses, not reborrows.

lib/SILOptimizer/SemanticARC/CopyValueOpts.cpp

@@ -186,9 +186,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
       return false;
     SmallVector<Operand *, 8> scratchSpace;
     if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-          return !borrowScope.areUsesWithinScope(lr.getAllConsumingUses(),
-                                                 scratchSpace,
-                                                 getDeadEndBlocks());
+          return !borrowScope.areUsesWithinLocalScope(lr.getAllConsumingUses(),
+                                                      getDeadEndBlocks());
         })) {
       return false;
     }
@@ -216,9 +215,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
       }
 
       if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-            return !borrowScope.areUsesWithinScope(
-                phiArgLR.getAllConsumingUses(), scratchSpace,
-                getDeadEndBlocks());
+            return !borrowScope.areUsesWithinLocalScope(
+                phiArgLR.getAllConsumingUses(), getDeadEndBlocks());
           })) {
         return false;
       }