[ownership] Remove BranchPropagatedUser.

The only reason why BranchPropagatedUser existed was because early on in SIL, we
weren't sure if cond_br should be able to handle non-trivial values in
ossa. Now, we have reached the point where we have enough experience to make the
judgement that it is not worth having in the representation due to it not
holding its weight.

Now that in ToT we have banned cond_br from having non-trivial operands in ossa,
I can just eliminate BranchPropagatedUser and replace it with the operands that
we used to construct them!

A few notes:

1. Part of my motiviation in doing this is that I want to change LiveRange to
store operands instead of instructions. This is because we are interested in
being able to understand the LiveRange at a use granularity in cases where we
have multiple operands. While doing this, I discovered that I needed
SILInstructions to use the Linear Lifetime Checker. Then I realized that now was
the time to just unwind BranchPropagatedUser.

2. In certain places in SemanticARCOpts, I had to do add some extra copies to
transform arrays of instructions from LiveRange into their operand form. I am
going to remove them in a subsequent commit when I change LiveRange to work on
operands. I am doing this split to be incremental.

3. I changed isSingleInitAllocStack to have an out array of Operand *. The only
user of this code is today in SemanticARCOpts and this information is fed to the
Linear Lifetime Checker, so I needed to do it.

Author: gottesmm

include/swift/SIL/ApplySite.h

@@ -134,6 +134,9 @@ class ApplySite {
   /// Return the callee operand as a value.
   SILValue getCallee() const { return getCalleeOperand()->get(); }
 
+  /// Return the callee operand.
+  Operand *getCalleeOperand() { FOREACH_IMPL_RETURN(getCalleeOperand()); }
+
   /// Return the callee operand.
   const Operand *getCalleeOperand() const {
     FOREACH_IMPL_RETURN(getCalleeOperand());

include/swift/SIL/BasicBlockUtils.h

@@ -71,13 +71,13 @@ class DeadEndBlocks {
   DeadEndBlocks(const SILFunction *F) : F(F) {}
 
   /// Returns true if \p BB is a dead-end block.
-  bool isDeadEnd(SILBasicBlock *BB) {
+  bool isDeadEnd(const SILBasicBlock *block) {
     if (!isComputed) {
       // Lazily compute the dataflow.
       compute();
       isComputed = true;
     }
-    return ReachableBlocks.count(BB) == 0;
+    return ReachableBlocks.count(block) == 0;
   }
 };
 

include/swift/SIL/BranchPropagatedUser.h

@@ -15,7 +15,6 @@
 
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
-#include "swift/SIL/BranchPropagatedUser.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
@@ -29,7 +28,6 @@ class SILInstruction;
 class SILModule;
 class SILValue;
 class DeadEndBlocks;
-class BranchPropagatedUser;
 
 namespace ownership {
 
@@ -167,30 +165,21 @@ class LinearLifetimeChecker {
   /// \p leakingBlocks If non-null a list of blocks where the value was detected
   /// to leak. Can be used to insert missing destroys.
   LinearLifetimeError
-  checkValue(SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
-             ArrayRef<BranchPropagatedUser> nonConsumingUses,
+  checkValue(SILValue value, ArrayRef<Operand *> consumingUses,
+             ArrayRef<Operand *> nonConsumingUses,
              ownership::ErrorBehaviorKind errorBehavior,
              SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
 
   /// Returns true that \p value forms a linear lifetime with consuming uses \p
   /// consumingUses, non consuming uses \p nonConsumingUses. Returns false
   /// otherwise.
-  bool validateLifetime(SILValue value,
-                        ArrayRef<BranchPropagatedUser> consumingUses,
-                        ArrayRef<BranchPropagatedUser> nonConsumingUses) {
+  bool validateLifetime(SILValue value, ArrayRef<Operand *> consumingUses,
+                        ArrayRef<Operand *> nonConsumingUses) {
     return !checkValue(value, consumingUses, nonConsumingUses,
                        ownership::ErrorBehaviorKind::ReturnFalse,
                        nullptr /*leakingBlocks*/)
                 .getFoundError();
   }
-
-  bool validateLifetime(SILValue value,
-                        ArrayRef<SILInstruction *> consumingUses,
-                        ArrayRef<SILInstruction *> nonConsumingUses) {
-    return validateLifetime(
-        value, BranchPropagatedUser::convertFromInstArray(consumingUses),
-        BranchPropagatedUser::convertFromInstArray(nonConsumingUses));
-  }
 };
 
 } // namespace swift

include/swift/SIL/LinearLifetimeChecker.h

@@ -540,7 +540,7 @@ bool memInstMustInitialize(Operand *memOper);
 /// alloc_stack. If the alloc_stack is destroyed in pieces, we do not guarantee
 /// that the list of destroying users is a minimal jointly post-dominating set.
 bool isSingleInitAllocStack(AllocStackInst *asi,
-                            SmallVectorImpl<SILInstruction *> &destroyingUsers);
+                            SmallVectorImpl<Operand *> &destroyingUses);
 
 /// Return true if the given address producer may be the source of a formal
 /// access (a read or write of a potentially aliased, user visible variable).

include/swift/SIL/MemAccessUtils.h

@@ -319,16 +319,15 @@ struct BorrowScopeIntroducingValue {
 
   bool isLocalScope() const { return kind.isLocalScope(); }
 
-  /// Returns true if the passed in set of instructions is completely within the
-  /// lifetime of this borrow introducer.
+  /// Returns true if the passed in set of uses is completely within
+  /// the lifetime of this borrow introducer.
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool
-  areInstructionsWithinScope(ArrayRef<SILInstruction *> instructions,
-                             SmallVectorImpl<SILInstruction *> &scratchSpace,
-                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-                             DeadEndBlocks &deadEndBlocks) const;
+  bool areUsesWithinScope(ArrayRef<Operand *> instructions,
+                          SmallVectorImpl<Operand *> &scratchSpace,
+                          SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                          DeadEndBlocks &deadEndBlocks) const;
 
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments.

include/swift/SIL/OwnershipUtils.h

@@ -1875,6 +1875,7 @@ class ApplyInstBase<Impl, Base, false> : public Base {
   /// The operand number of the first argument.
   static unsigned getArgumentOperandNumber() { return NumStaticOperands; }
 
+  Operand *getCalleeOperand() { return &getAllOperands()[Callee]; }
   const Operand *getCalleeOperand() const { return &getAllOperands()[Callee]; }
   SILValue getCallee() const { return getCalleeOperand()->get(); }