[NFC] OwnershipLiveRange: Track UsePoints.

Instead of tracking Operands, track UsePoints, i.e.
`Either<Operand, SILInstruction>`s.  For now, all use points wil remain
operands.  This change is necessary to allow tracking terminators in
dead-end region as implicit uses.

Author: nate-chandler

lib/SILOptimizer/SemanticARC/CopyValueOpts.cpp

@@ -170,7 +170,7 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
         return borrowScope.isLocalScope();
       });
 
-  auto destroys = lr.getDestroyingUses();
+  auto destroys = lr.getDestroyingInsts();
   if (destroys.empty() && haveAnyLocalScopes) {
     return false;
   }
@@ -196,8 +196,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
   // block.
   {
     if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-          return !borrowScope.areUsesWithinExtendedScope(
-              lr.getAllConsumingUses(), nullptr);
+          return !borrowScope.areWithinExtendedScope(lr.getAllConsumingInsts(),
+                                                     nullptr);
         })) {
       LLVM_DEBUG(llvm::dbgs() << "copy_value is extending borrow introducer "
                                  "lifetime, bailing out\n");
@@ -238,8 +238,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
       }
 
       if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-            return !borrowScope.areUsesWithinExtendedScope(
-                phiArgLR.getAllConsumingUses(), nullptr);
+            return !borrowScope.areWithinExtendedScope(
+                phiArgLR.getAllConsumingInsts(), nullptr);
           })) {
         return false;
       }

lib/SILOptimizer/SemanticARC/OwnershipLiveRange.cpp

@@ -26,9 +26,9 @@ OwnershipLiveRange::OwnershipLiveRange(SILValue value)
   assert(introducer);
   assert(introducer.value->getOwnershipKind() == OwnershipKind::Owned);
 
-  SmallVector<Operand *, 32> tmpDestroyingUses;
-  SmallVector<Operand *, 32> tmpForwardingConsumingUses;
-  SmallVector<Operand *, 32> tmpUnknownConsumingUses;
+  SmallVector<UsePoint, 32> tmpDestroyingUses;
+  SmallVector<UsePoint, 32> tmpForwardingConsumingUses;
+  SmallVector<UsePoint, 32> tmpUnknownConsumingUses;
 
   // We know that our silvalue produces an @owned value. Look through all of our
   // uses and classify them as either consuming or not.
@@ -248,7 +248,8 @@ void OwnershipLiveRange::insertEndBorrowsAtDestroys(
 
 void OwnershipLiveRange::convertOwnedGeneralForwardingUsesToGuaranteed() && {
   while (!ownershipForwardingUses.empty()) {
-    auto *use = ownershipForwardingUses.back();
+    auto point = ownershipForwardingUses.back();
+    auto *use = point.getOperand();
     ownershipForwardingUses = ownershipForwardingUses.drop_back();
     ForwardingOperand operand(use);
     operand.replaceOwnershipKind(OwnershipKind::Owned,
@@ -260,9 +261,10 @@ void OwnershipLiveRange::convertToGuaranteedAndRAUW(
     SILValue newGuaranteedValue, InstModCallbacks callbacks) && {
   auto *value = cast<SingleValueInstruction>(introducer.value);
   while (!destroyingUses.empty()) {
-    auto *d = destroyingUses.back();
+    auto point = destroyingUses.back();
+    auto *destroy = point.getInstruction();
     destroyingUses = destroyingUses.drop_back();
-    callbacks.deleteInst(d->getUser());
+    callbacks.deleteInst(destroy);
   }
 
   callbacks.eraseAndRAUWSingleValueInst(value, newGuaranteedValue);
@@ -318,9 +320,10 @@ void OwnershipLiveRange::convertJoinedLiveRangePhiToGuaranteed(
 
   // Then eliminate all of the destroys...
   while (!destroyingUses.empty()) {
-    auto *d = destroyingUses.back();
+    auto point = destroyingUses.back();
+    auto *destroy = point.getInstruction();
     destroyingUses = destroyingUses.drop_back();
-    callbacks.deleteInst(d->getUser());
+    callbacks.deleteInst(destroy);
   }
 
   // and change all of our guaranteed forwarding insts to have guaranteed
@@ -362,15 +365,3 @@ OwnershipLiveRange::hasUnknownConsumingUse(bool assumingAtFixPoint) const {
   // to our introducer.
   return HasConsumingUse_t::YesButAllPhiArgs;
 }
-
-SILInstruction::OperandUserRange
-OwnershipLiveRange::getDestroyingInsts() const {
-  return SILInstruction::OperandUserRange(getDestroyingUses(),
-                                          SILInstruction::OperandToUser());
-}
-
-SILInstruction::OperandUserRange
-OwnershipLiveRange::getAllConsumingInsts() const {
-  return SILInstruction::OperandUserRange(consumingUses,
-                                          SILInstruction::OperandToUser());
-}

lib/SILOptimizer/SemanticARC/OwnershipLiveRange.h

@@ -54,12 +54,18 @@ class LLVM_LIBRARY_VISIBILITY OwnershipLiveRange {
   /// order. This is why it is important not to mutate consumingUses after we
   /// construct the LiveRange since going from small -> large could invalidate
   /// the uses.
-  SmallVector<Operand *, 6> consumingUses;
+  ///
+  /// These UsePoints may be Operands or SILInstructions (terminators of blocks
+  /// in dead-end regions along the value's availability boundary).
+  SmallVector<UsePoint, 6> consumingUses;
 
   /// A list of destroy_values of the live range.
   ///
-  /// This is just a view into consuming uses.
-  ArrayRef<Operand *> destroyingUses;
+  /// This is just a view into consumingUses.
+  ///
+  /// These UsePoints may be Operands or SILInstructions (terminators of blocks
+  /// in dead-end regions along the value's availability boundary).
+  ArrayRef<UsePoint> destroyingUses;
 
   /// A list of forwarding instructions that forward owned ownership, but that
   /// are also able to be converted to guaranteed ownership.
@@ -76,12 +82,16 @@ class LLVM_LIBRARY_VISIBILITY OwnershipLiveRange {
   /// "consumingUses" array the true lifetime of the OwnershipLiveRange.
   ///
   /// Corresponds to isOwnershipForwardingInst(...).
-  ArrayRef<Operand *> ownershipForwardingUses;
+  ///
+  /// These UsePoints must all be Operands.
+  ArrayRef<UsePoint> ownershipForwardingUses;
 
   /// Consuming uses that we were not able to understand as a forwarding
   /// instruction or a destroy_value. These must be passed a strongly control
   /// equivalent +1 value.
-  ArrayRef<Operand *> unknownConsumingUses;
+  ///
+  /// These UsePoints must all be Operands.
+  ArrayRef<UsePoint> unknownConsumingUses;
 
 public:
   OwnershipLiveRange(SILValue value);
@@ -102,28 +112,17 @@ class LLVM_LIBRARY_VISIBILITY OwnershipLiveRange {
   HasConsumingUse_t
   hasUnknownConsumingUse(bool assumingFixedPoint = false) const;
 
-  /// Return an array ref to /all/ consuming uses. Will include all 3 sorts of
-  /// consuming uses: destroying uses, forwarding consuming uses, and unknown
-  /// forwarding instruction.
-  ArrayRef<Operand *> getAllConsumingUses() const { return consumingUses; }
-
-  ArrayRef<Operand *> getDestroyingUses() const { return destroyingUses; }
-
-  ArrayRef<Operand *> getUnknownConsumingUses() const {
-    return unknownConsumingUses;
+  UsePointInstructionRange getDestroyingInsts() const {
+    return UsePointInstructionRange(destroyingUses, UsePointToInstruction());
   }
 
-  SILInstruction::OperandUserRange getDestroyingInsts() const;
-
-  SILInstruction::OperandUserRange getAllConsumingInsts() const;
+  UsePointInstructionRange getUnknownConsumingInsts() const {
+    return UsePointInstructionRange(unknownConsumingUses,
+                                    UsePointToInstruction());
+  }
 
-  /// If this LiveRange has a single destroying use, return that use. Otherwise,
-  /// return nullptr.
-  Operand *getSingleDestroyingUse() const {
-    if (destroyingUses.size() != 1) {
-      return nullptr;
-    }
-    return destroyingUses.front();
+  UsePointInstructionRange getAllConsumingInsts() const {
+    return UsePointInstructionRange(consumingUses, UsePointToInstruction());
   }
 
   /// If this LiveRange has a single unknown destroying use, return that
@@ -132,13 +131,14 @@ class LLVM_LIBRARY_VISIBILITY OwnershipLiveRange {
     if (unknownConsumingUses.size() != 1) {
       return nullptr;
     }
-    return unknownConsumingUses.front();
+    auto point = unknownConsumingUses.front();
+    return point.getOperand();
   }
 
   OwnedValueIntroducer getIntroducer() const { return introducer; }
 
-  ArrayRef<Operand *> getOwnershipForwardingUses() const {
-    return ownershipForwardingUses;
+  PointOperandRange getOwnershipForwardingUses() const {
+    return PointOperandRange(ownershipForwardingUses, PointToOperand());
   }
 
   void convertOwnedGeneralForwardingUsesToGuaranteed() &&;