[SIL] Add hasPointerEscape(SILValue).

There is a preexisting function with this name that takes a
BorrowedValue.  The new function calls that preexisting function if a
BorrowedValue can be constructed from the SILValue.  Otherwise, it looks
for direct uses of the value which qualify as "pointer escapes".

Author: nate-chandler

include/swift/SIL/OwnershipUtils.h

@@ -122,6 +122,12 @@ inline bool isForwardingConsume(SILValue value) {
 
 bool hasPointerEscape(BorrowedValue value);
 
+/// Whether the specified OSSA-lifetime introducer has a pointer escape.
+///
+/// precondition: \p value introduces an OSSA-lifetime, either a BorrowedValue
+/// can be constructed from it or it's an owned value
+bool hasPointerEscape(SILValue value);
+
 /// Find leaf "use points" of \p guaranteedValue that determine its lifetime
 /// requirement. Return true if no PointerEscape use was found.
 ///

lib/SIL/Utils/OwnershipUtils.cpp

@@ -83,6 +83,44 @@ bool swift::hasPointerEscape(BorrowedValue value) {
   return false;
 }
 
+bool swift::hasPointerEscape(SILValue original) {
+  if (auto borrowedValue = BorrowedValue(original)) {
+    return hasPointerEscape(borrowedValue);
+  }
+  assert(original->getOwnershipKind() == OwnershipKind::Owned);
+
+  ValueWorklist worklist(original->getFunction());
+  worklist.push(original);
+  if (auto *phi = SILArgument::asPhi(original)) {
+    phi->visitTransitiveIncomingPhiOperands([&](auto *phi, auto *operand) {
+      worklist.pushIfNotVisited(operand->get());
+      return true;
+    });
+  }
+  while (auto value = worklist.popAndForget()) {
+    for (auto use : value->getUses()) {
+      switch (use->getOperandOwnership()) {
+      case OperandOwnership::PointerEscape:
+      case OperandOwnership::ForwardingUnowned:
+        return true;
+      case OperandOwnership::ForwardingConsume: {
+        SILArgument *phi = dyn_cast<BranchInst>(use->getUser())
+                               ->getDestBB()
+                               ->getArgument(use->getOperandNumber());
+        if (!phi) {
+          break;
+        }
+        worklist.pushIfNotVisited(phi);
+        break;
+      }
+      default:
+        break;
+      }
+    }
+  }
+  return false;
+}
+
 bool swift::canOpcodeForwardInnerGuaranteedValues(SILValue value) {
   // If we have an argument from a transforming terminator, we can forward
   // guaranteed.

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -71,6 +71,7 @@
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OSSALifetimeCompletion.h"
 #include "swift/SIL/OwnershipLiveness.h"
+#include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/PrunedLiveness.h"
 #include "swift/SIL/SILArgumentArrayRef.h"
 #include "swift/SIL/SILBasicBlock.h"
@@ -267,6 +268,22 @@ struct TestSpecificationTest : UnitTest {
   }
 };
 
+// Arguments:
+// - value: the value to check for escaping
+// Dumps:
+// - the value
+// - whether it has a pointer escape
+struct OwnershipUtilsHasPointerEscape : UnitTest {
+  OwnershipUtilsHasPointerEscape(UnitTestRunner *pass) : UnitTest(pass) {}
+  void invoke(Arguments &arguments) override {
+    auto value = arguments.takeValue();
+    auto has = hasPointerEscape(value);
+    value->print(llvm::errs());
+    auto *boolString = has ? "true" : "false";
+    llvm::errs() << boolString << "\n";
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // MARK: OSSA Lifetime Unit Tests
 //===----------------------------------------------------------------------===//
@@ -789,6 +806,7 @@ void UnitTestRunner::withTest(StringRef name, Doit doit) {
     ADD_UNIT_TEST_SUBCLASS("find-borrow-introducers", FindBorrowIntroducers)
     ADD_UNIT_TEST_SUBCLASS("find-enclosing-defs", FindEnclosingDefsTest)
     ADD_UNIT_TEST_SUBCLASS("function-get-self-argument-index", FunctionGetSelfArgumentIndex)
+    ADD_UNIT_TEST_SUBCLASS("has-pointer-escape", OwnershipUtilsHasPointerEscape)
     ADD_UNIT_TEST_SUBCLASS("interior-liveness", InteriorLivenessTest)
     ADD_UNIT_TEST_SUBCLASS("is-deinit-barrier", IsDeinitBarrierTest)
     ADD_UNIT_TEST_SUBCLASS("is-lexical", IsLexicalTest)

test/SILOptimizer/ownership-utils-unit.sil

@@ -0,0 +1,44 @@
+// RUN: %target-sil-opt -unit-test-runner %s -o /dev/null 2>&1 | %FileCheck %s
+
+sil_stage canonical
+
+import Builtin
+
+class C {}
+
+sil @getOwned : $@convention(thin) () -> (@owned C)
+
+sil @borrow : $@convention(thin) (@guaranteed C) -> ()
+
+sil @useUnmanaged : $@convention(thin) (@sil_unmanaged C) -> ()
+
+sil [ossa] @test_escape_of_phi_transitive_incoming_value : $@convention(thin) () -> () {
+entry:
+  %getOwned = function_ref @getOwned : $@convention(thin) () -> (@owned C)
+  %useUnmanaged = function_ref @useUnmanaged : $@convention(thin) (@sil_unmanaged C) -> ()
+  cond_br undef, left, right
+left:
+  cond_br undef, left_left, left_right
+left_left:
+  %llinstance = apply %getOwned() : $@convention(thin) () -> (@owned C)
+  br left_bottom(%llinstance : $C)
+left_right:
+  %lrinstance = apply %getOwned() : $@convention(thin) () -> (@owned C)
+  %escape = ref_to_unmanaged %lrinstance : $C to $@sil_unmanaged C
+  apply %useUnmanaged(%escape) : $@convention(thin) (@sil_unmanaged C) -> ()
+  br left_bottom(%lrinstance : $C)
+left_bottom(%linstance : @owned $C):
+  br exit(%linstance : $C)
+right:
+  %rinstance = apply %getOwned() : $@convention(thin) () -> (@owned C)
+  br exit(%rinstance : $C)
+exit(%instance : @owned $C):
+// CHECK-LABEL: begin running test {{[0-9]+}} of {{[0-9]+}} on test_escape_of_phi_transitive_incoming_value: has-pointer-escape
+// CHECK:       %14 = argument of bb6 : $C
+// CHECK:       true
+// CHECK-LABEL: end running test {{[0-9]+}} of {{[0-9]+}} on test_escape_of_phi_transitive_incoming_value: has-pointer-escape with
+  test_specification "has-pointer-escape @block.argument"
+  destroy_value %instance : $C
+  %retval = tuple ()
+  return %retval : $()
+}