Add findEnclosingDefs and findBorrowIntroducers utilities.

These APIs are essential for complete OSSA liveness analysis.  The
existing ad-hoc OSSA logic always misses some of the cases handled by
these new utilities. We need to start replacing that ad-hoc logic with
new utilities built on top of these APIs to define away potential
latent bugs.

Add FIXMEs to the inverse API: visitAdjacentBorrowsOfPhi. It should
probably be redesigned in terms of these new APIs.

Author: atrick

include/swift/SIL/OwnershipUtils.h

@@ -50,6 +50,7 @@
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
+#include "swift/SIL/StackList.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
@@ -1319,6 +1320,24 @@ bool visitForwardedGuaranteedOperands(
 bool visitAdjacentReborrowsOfPhi(SILPhiArgument *phi,
                                  function_ref<bool(SILPhiArgument *)> visitor);
 
+/// Visit each definition of a scope that immediately encloses a guaranteed
+/// value. The guaranteed value effectively keeps these scopes alive.
+///
+/// This means something different depepending on whether \p value is itself a
+/// borrow introducer vs. a forwarded guaranteed value. If \p value is an
+/// introducer, then this discovers the enclosing borrow scope and visits all
+/// introducers of that scope. If \p value is a forwarded value, then this
+/// visits the introducers of the current borrow scope.
+bool visitEnclosingDefs(SILValue value, function_ref<bool(SILValue)> visitor);
+
+/// Visit the values that introduce the borrow scopes that includes \p
+/// value. If value is owned, or introduces a borrow scope, then this only
+/// visits \p value.
+///
+/// Returns false if the visitor returned false and exited early.
+bool visitBorrowIntroducers(SILValue value,
+                            function_ref<bool(SILValue)> visitor);
+
 /// Given a begin of a borrow scope, visit all end_borrow users of the borrow or
 /// its reborrows.
 void visitTransitiveEndBorrows(

include/swift/SIL/SILArgument.h

@@ -205,7 +205,7 @@ class SILArgument : public ValueBase {
   /// Precondition: this->isTerminatorResult()
   ///
   /// TODO: Move this and other APIs into a TerminatorResult abstraction.
-  const Operand *forwardedTerminatorResultOperand() const;
+  Operand *forwardedTerminatorResultOperand() const;
 
   /// Return the SILArgumentKind of this argument.
   SILArgumentKind getKind() const {

include/swift/SIL/SILInstruction.h

@@ -8500,9 +8500,14 @@ class TermInst : public NonValueInstruction {
   /// example, a switch forwards ownership of the enum type into ownership of
   /// the payload.
   ///
-  /// Postcondition: each successor has zero or one block arguments which
-  /// represents the forwaded result.
+  /// Postcondition: if the result is non-null, then each successor has zero or
+  /// one block arguments which represents the forwaded result.
   const Operand *forwardedOperand() const;
+
+  Operand *forwardedOperand() {
+    return const_cast<Operand *>(
+      static_cast<const TermInst *>(this)->forwardedOperand());
+  }
 };
 
 // Forwards the first operand to a result in each successor block.

lib/SIL/Utils/MemAccessUtils.cpp

@@ -862,7 +862,7 @@ SILValue swift::findOwnershipReferenceRoot(SILValue ref) {
   return ref;
 }
 
-void swift::findGuaranteedReferenceRoots(SILValue value,
+void swift::findGuaranteedReferenceRoots(SILValue referenceValue,
                                          bool lookThroughNestedBorrows,
                                          SmallVectorImpl<SILValue> &roots) {
   ValueWorklist worklist(referenceValue->getFunction());