[semantic-arc] Change LiveRange to work with Operand instead of Operand->getUser().

This is just better information to have since one wants to not only know the
instruction, but also the specific value used on the instruction since behavior
can vary depending upon that. The operand is what ties the two together so it is
a natural fit.

Now that this is done, I am going to work on refactoring out converting a
LiveRange from @owned -> @guaranteed. It will be a consuming operation using a
move operator since once the transformation has completed, the LiveRange no
longer exists.

I need this refactored functionality since I am going to need it when
eliminating phi-webs.

Author: gottesmm

include/swift/SIL/SILValue.h

@@ -669,6 +669,9 @@ class Operand {
     return constraint == UseLifetimeConstraint::MustBeInvalidated;
   }
 
+  SILBasicBlock *getParentBlock() const;
+  SILFunction *getParentFunction() const;
+
 private:
   void removeFromCurrent() {
     if (!Back) return;

lib/SIL/SILValue.cpp

@@ -322,3 +322,17 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
   }
   return os;
 }
+
+//===----------------------------------------------------------------------===//
+//                                  Operand
+//===----------------------------------------------------------------------===//
+
+SILBasicBlock *Operand::getParentBlock() const {
+  auto *self = const_cast<Operand *>(this);
+  return self->getUser()->getParent();
+}
+
+SILFunction *Operand::getParentFunction() const {
+  auto *self = const_cast<Operand *>(this);
+  return self->getUser()->getFunction();
+}

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -136,7 +136,7 @@ static void fixupReferenceCounts(
       // am going to change this to use a different API on the linear lifetime
       // checker that makes this clearer.
       LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
-      auto error = checker.checkValue(pai, {{applySite.getCalleeOperand()}}, {},
+      auto error = checker.checkValue(pai, {applySite.getCalleeOperand()}, {},
                                       errorBehavior, &leakingBlocks);
       if (error.getFoundLeak()) {
         while (!leakingBlocks.empty()) {

lib/SILOptimizer/Transforms/SemanticARCOpts.cpp

@@ -47,16 +47,16 @@ namespace {
 
 class LiveRange {
   /// A list of destroy_values of the live range.
-  SmallVector<SILInstruction *, 2> destroys;
+  SmallVector<Operand *, 2> destroyingUses;
 
   /// A list of forwarding instructions that forward our destroys ownership, but
   /// that are also able to forward guaranteed ownership.
-  SmallVector<SILInstruction *, 2> generalForwardingInsts;
+  SmallVector<Operand *, 2> generalForwardingUses;
 
   /// Consuming users 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.
-  SmallVector<SILInstruction *, 2> unknownConsumingUsers;
+  SmallVector<Operand *, 2> unknownConsumingUses;
 
 public:
   LiveRange(SILValue value);
@@ -68,18 +68,40 @@ class LiveRange {
   ///
   /// Semantically this implies that a value is never passed off as +1 to memory
   /// or another function implying it can be used everywhere at +0.
-  bool hasConsumingUse() const { return unknownConsumingUsers.size(); }
+  bool hasConsumingUse() const { return unknownConsumingUses.size(); }
 
-  ArrayRef<SILInstruction *> getDestroys() const { return destroys; }
-  ArrayRef<SILInstruction *> getNonConsumingForwardingInsts() const {
-    return generalForwardingInsts;
+  ArrayRef<Operand *> getDestroyingUses() const { return destroyingUses; }
+
+private:
+  struct OperandToUser;
+
+public:
+  using DestroyingInstsRange =
+      TransformRange<ArrayRef<Operand *>, OperandToUser>;
+  DestroyingInstsRange getDestroyingInsts() const;
+
+  ArrayRef<Operand *> getNonConsumingForwardingUses() const {
+    return generalForwardingUses;
   }
 };
 
 } // end anonymous namespace
 
+struct LiveRange::OperandToUser {
+  OperandToUser() {}
+
+  SILInstruction *operator()(const Operand *use) const {
+    auto *nonConstUse = const_cast<Operand *>(use);
+    return nonConstUse->getUser();
+  }
+};
+
+LiveRange::DestroyingInstsRange LiveRange::getDestroyingInsts() const {
+  return DestroyingInstsRange(getDestroyingUses(), OperandToUser());
+}
+
 LiveRange::LiveRange(SILValue value)
-    : destroys(), generalForwardingInsts(), unknownConsumingUsers() {
+    : destroyingUses(), generalForwardingUses(), unknownConsumingUses() {
   assert(value.getOwnershipKind() == ValueOwnershipKind::Owned);
 
   // We know that our silvalue produces an @owned value. Look through all of our
@@ -109,8 +131,8 @@ LiveRange::LiveRange(SILValue value)
 
     // Ok, we know now that we have a consuming use. See if we have a destroy
     // value, quickly up front. If we do have one, stash it and continue.
-    if (auto *dvi = dyn_cast<DestroyValueInst>(user)) {
-      destroys.push_back(dvi);
+    if (isa<DestroyValueInst>(user)) {
+      destroyingUses.push_back(op);
       continue;
     }
 
@@ -134,13 +156,13 @@ LiveRange::LiveRange(SILValue value)
                         return v.getOwnershipKind() ==
                                ValueOwnershipKind::Owned;
                       })) {
-      unknownConsumingUsers.push_back(user);
+      unknownConsumingUses.push_back(op);
       continue;
     }
 
     // Ok, this is a forwarding instruction whose ownership we can flip from
     // owned -> guaranteed.
-    generalForwardingInsts.push_back(user);
+    generalForwardingUses.push_back(op);
 
     // If we have a non-terminator, just visit its users recursively to see if
     // the the users force the live range to be alive.
@@ -303,14 +325,16 @@ bool IsAddressWrittenToDefUseAnalysis::isWrittenToHelper(SILValue initialValue)
 //             Convert Forwarding Insts from Owned -> Guaranteed
 //===----------------------------------------------------------------------===//
 
-static void convertForwardingInstsFromOwnedToGuaranteed(
-    ArrayRef<SILInstruction *> guaranteedForwardingInsts) {
+static void convertForwardingUsesFromOwnedToGuaranteed(
+    ArrayRef<Operand *> guaranteedForwardingUses) {
   // Then change all of our guaranteed forwarding insts to have guaranteed
   // ownership kind instead of what ever they previously had (ignoring trivial
   // results);
-  while (!guaranteedForwardingInsts.empty()) {
-    auto *i = guaranteedForwardingInsts.back();
-    guaranteedForwardingInsts = guaranteedForwardingInsts.drop_back();
+  while (!guaranteedForwardingUses.empty()) {
+    auto *use = guaranteedForwardingUses.back();
+    guaranteedForwardingUses = guaranteedForwardingUses.drop_back();
+
+    auto *i = use->getUser();
 
     // If this is a term inst, just convert all of its incoming values that are
     // owned to be guaranteed.
@@ -745,7 +769,7 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
         return borrowScope.isLocalScope();
       });
 
-  auto destroys = lr.getDestroys();
+  auto destroys = lr.getDestroyingUses();
   if (destroys.empty() && haveAnyLocalScopes) {
     return false;
   }
@@ -766,23 +790,17 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   //    non-local scopes.
   {
     bool foundNonDeadEnd = false;
-    for (auto *dvi : destroys) {
-      foundNonDeadEnd |= !getDeadEndBlocks().isDeadEnd(dvi->getParent());
+    for (auto *d : destroys) {
+      foundNonDeadEnd |= !getDeadEndBlocks().isDeadEnd(d->getParentBlock());
     }
     if (!foundNonDeadEnd && haveAnyLocalScopes)
       return false;
-    // TODO: In a future commit, when LiveRange converts to work with
-    // operands, this will not be needed. This is just to simplify
-    // patches.
-    SmallVector<Operand *, 8> destroyOperands;
-    transform(destroys, std::back_inserter(destroyOperands),
-              [](SILInstruction *i) { return &i->getAllOperands()[0]; });
     SmallVector<Operand *, 8> scratchSpace;
     SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
     if (llvm::any_of(borrowScopeIntroducers,
                      [&](BorrowScopeIntroducingValue borrowScope) {
                        return !borrowScope.areUsesWithinScope(
-                           destroyOperands, scratchSpace, visitedBlocks,
+                           destroys, scratchSpace, visitedBlocks,
                            getDeadEndBlocks());
                      })) {
       return false;
@@ -792,15 +810,15 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   // Otherwise, we know that our copy_value/destroy_values are all completely
   // within the guaranteed value scope. First delete the destroys/copies.
   while (!destroys.empty()) {
-    auto *dvi = destroys.back();
+    auto *d = destroys.back();
     destroys = destroys.drop_back();
-    eraseInstruction(dvi);
+    eraseInstruction(d->getUser());
     ++NumEliminatedInsts;
   }
 
   eraseAndRAUWSingleValueInstruction(cvi, cvi->getOperand());
-  convertForwardingInstsFromOwnedToGuaranteed(
-      lr.getNonConsumingForwardingInsts());
+  convertForwardingUsesFromOwnedToGuaranteed(
+      lr.getNonConsumingForwardingUses());
 
   ++NumEliminatedInsts;
   return true;
@@ -1153,17 +1171,10 @@ class StorageGuaranteesLoadVisitor
 
     SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
     LinearLifetimeChecker checker(visitedBlocks, ARCOpt.getDeadEndBlocks());
+
     // Returns true on success. So we invert.
-    auto destroys = liveRange.getDestroys();
-    // TODO: Once LiveRange uses operands, eliminate this!
-    SmallVector<Operand *, 16> destroyOperands;
-    transform(destroys, std::back_inserter(destroyOperands),
-              [](SILInstruction *i) {
-                assert(isa<DestroyValueInst>(i));
-                return &cast<DestroyValueInst>(i)->getAllOperands()[0];
-              });
-    bool foundError =
-        !checker.validateLifetime(baseObject, endScopeInsts, destroyOperands);
+    bool foundError = !checker.validateLifetime(baseObject, endScopeInsts,
+                                                liveRange.getDestroyingUses());
     return answer(foundError);
   }
 
@@ -1196,17 +1207,12 @@ class StorageGuaranteesLoadVisitor
 
     // Then make sure that all of our load [copy] uses are within the
     // destroy_addr.
-    SmallVector<Operand *, 16> destroyOperands;
-    transform(liveRange.getDestroys(), std::back_inserter(destroyOperands),
-              [](SILInstruction *i) {
-                return &cast<DestroyValueInst>(i)->getAllOperands()[0];
-              });
     SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
     LinearLifetimeChecker checker(visitedBlocks, ARCOpt.getDeadEndBlocks());
     // Returns true on success. So we invert.
     bool foundError = !checker.validateLifetime(
         stack, destroyAddrOperands /*consuming users*/,
-        destroyOperands /*non consuming users*/);
+        liveRange.getDestroyingUses() /*non consuming users*/);
     return answer(foundError);
   }
 
@@ -1258,8 +1264,7 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
   // to find the post-dominating block set of these destroy value to ensure that
   // we do not insert multiple end_borrow.
   assert(lifetimeFrontier.empty());
-  auto destroyValues = lr.getDestroys();
-  ValueLifetimeAnalysis analysis(li, destroyValues);
+  ValueLifetimeAnalysis analysis(li, lr.getDestroyingInsts());
   bool foundCriticalEdges = !analysis.computeFrontier(
       lifetimeFrontier, ValueLifetimeAnalysis::DontModifyCFG,
       &getDeadEndBlocks());
@@ -1273,10 +1278,11 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
   }
 
   // Then delete all of our destroy_value.
+  auto destroyValues = lr.getDestroyingUses();
   while (!destroyValues.empty()) {
     auto *dvi = destroyValues.back();
     destroyValues = destroyValues.drop_back();
-    eraseInstruction(dvi);
+    eraseInstruction(dvi->getUser());
     ++NumEliminatedInsts;
   }
 
@@ -1285,8 +1291,8 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
 
   // And then change the ownership all of our owned forwarding users to be
   // guaranteed.
-  convertForwardingInstsFromOwnedToGuaranteed(
-      lr.getNonConsumingForwardingInsts());
+  convertForwardingUsesFromOwnedToGuaranteed(
+      lr.getNonConsumingForwardingUses());
 
   ++NumEliminatedInsts;
   ++NumLoadCopyConvertedToLoadBorrow;