Merge pull request #63876 from nate-chandler/lexical-phis

[SIL] Phi with incoming lexical value is lexical.

Author: nate-chandler

include/swift/SIL/SILArgument.h

@@ -241,6 +241,9 @@ class SILPhiArgument : public SILArgument {
   /// result.
   bool isPhi() const;
 
+  /// Whether any of the values incoming to this phi are lexical.
+  bool isLexical() const;
+
   /// Return true if this block argument is a terminator result.
   bool isTerminatorResult() const { return !isPhi(); }
 
@@ -291,7 +294,7 @@ class SILPhiArgument : public SILArgument {
   ///
   /// Returns false when called on a non-phi and when the visitor returns false.
   bool visitTransitiveIncomingPhiOperands(
-      function_ref<bool(SILPhiArgument *, Operand *)> visitor);
+      function_ref<bool(SILPhiArgument *, Operand *)> visitor) const;
 
   /// Returns true if we were able to find a single terminator operand value for
   /// each predecessor of this arguments basic block. The found values are

lib/SIL/IR/SILArgument.cpp

@@ -227,12 +227,12 @@ bool SILPhiArgument::getIncomingPhiValues(
 }
 
 bool SILPhiArgument::visitTransitiveIncomingPhiOperands(
-    function_ref<bool(SILPhiArgument *, Operand *)> visitor) {
+    function_ref<bool(SILPhiArgument *, Operand *)> visitor) const {
   if (!isPhi())
     return false;
 
   GraphNodeWorklist<SILPhiArgument *, 4> worklist;
-  worklist.initialize(this);
+  worklist.insert(const_cast<SILPhiArgument *>(this));
 
   while (auto *argument = worklist.pop()) {
     SmallVector<Operand *> operands;

lib/SIL/IR/SILValue.cpp

@@ -115,9 +115,38 @@ ValueBase::getDefiningInstructionResult() {
   return None;
 }
 
+bool SILPhiArgument::isLexical() const {
+  if (!isPhi())
+    return false;
+
+  // FIXME: Cache this on the node.
+
+  // Does there exist an incoming value which is lexical?
+  //
+  // Invert the condition to "is every incoming value non-lexical?" in order to
+  // stop visiting incoming values once one lexical value is
+  // found--visitTransitiveIncomingPhiOperands stops once false is returned
+  // from it.
+  auto isEveryIncomingValueNonLexical =
+      visitTransitiveIncomingPhiOperands([&](auto *, auto *operand) {
+        auto value = operand->get();
+        SILPhiArgument *phi = dyn_cast<SILPhiArgument>(value);
+        if (phi && phi->isPhi()) {
+          return true;
+        }
+        // If this non-phi incoming value is lexical, then there is one at least
+        // one lexical value incoming to this phi, to it's lexical.
+        return !value->isLexical();
+      });
+  return !isEveryIncomingValueNonLexical;
+}
+
 bool ValueBase::isLexical() const {
   if (auto *argument = dyn_cast<SILFunctionArgument>(this))
     return argument->getLifetime().isLexical();
+  auto *phi = dyn_cast<SILPhiArgument>(this);
+  if (phi && phi->isPhi())
+    return phi->isLexical();
   if (auto *bbi = dyn_cast<BeginBorrowInst>(this))
     return bbi->isLexical();
   if (auto *mvi = dyn_cast<MoveValueInst>(this))

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -434,6 +434,22 @@ struct IsDeinitBarrierTest : UnitTest {
   }
 };
 
+// Arguments:
+// - value
+// Dumps:
+// - value
+// - whether it's lexical
+struct IsLexicalTest : UnitTest {
+  IsLexicalTest(UnitTestRunner *pass) : UnitTest(pass) {}
+  void invoke(Arguments &arguments) override {
+    auto value = arguments.takeValue();
+    auto isLexical = value->isLexical();
+    value->dump();
+    auto *boolString = isLexical ? "true" : "false";
+    llvm::errs() << boolString << "\n";
+  }
+};
+
 struct ShrinkBorrowScopeTest : UnitTest {
   ShrinkBorrowScopeTest(UnitTestRunner *pass) : UnitTest(pass) {}
   void invoke(Arguments &arguments) override {
@@ -759,6 +775,7 @@ void UnitTestRunner::withTest(StringRef name, Doit doit) {
     ADD_UNIT_TEST_SUBCLASS("function-get-self-argument-index", FunctionGetSelfArgumentIndex)
     ADD_UNIT_TEST_SUBCLASS("interior-liveness", InteriorLivenessTest)
     ADD_UNIT_TEST_SUBCLASS("is-deinit-barrier", IsDeinitBarrierTest)
+    ADD_UNIT_TEST_SUBCLASS("is-lexical", IsLexicalTest)
     ADD_UNIT_TEST_SUBCLASS("linear-liveness", LinearLivenessTest)
     ADD_UNIT_TEST_SUBCLASS("multidef-liveness", MultiDefLivenessTest)
     ADD_UNIT_TEST_SUBCLASS("pruned-liveness-boundary-with-list-of-last-users-insertion-points", PrunedLivenessBoundaryWithListOfLastUsersInsertionPointsTest)

test/SILOptimizer/copy_propagation_canonicalize_with_reborrows.sil

@@ -297,14 +297,15 @@ bb1(%4 : @guaranteed $X, %5 : @owned $X):
 // Lifetime analysis is successful; the copy/destroy in bb1 are removed. The
 // end_borrow/destroy maintain their position.
 //
-// CHECK-LABEL: sil [ossa] @reborrow_adjacent_to_consume : $@convention(thin) (@owned X) -> () {
+// CHECK-LABEL: sil [ossa] @reborrow_adjacent_to_consume : $@convention(thin) () -> () {
 // CHECK: bb1(%{{.*}} : @guaranteed $X, %{{.*}} : @owned $X):
 // CHECK-NEXT:   br bb2
 // CHECK: bb2(%{{.*}} : @guaranteed $X, %{{.*}} : @owned $X):
 // CHECK-NEXT:   end_borrow
 // CHECK-NEXT:   destroy_value
-sil [ossa] @reborrow_adjacent_to_consume : $@convention(thin) (@owned X) -> () {
-bb0(%0 : @owned $X):
+sil [ossa] @reborrow_adjacent_to_consume : $@convention(thin) () -> () {
+bb0:
+  %0 = apply undef() : $@convention(thin) () -> (@owned X)
   %1 = begin_borrow %0 : $X
   br bb1(%1 : $X, %0 : $X)
 
@@ -328,14 +329,15 @@ bb2(%6 : @guaranteed $X, %7 : @owned $X):
 //
 // Lifetime analysis is successful; the copy/destroy in bb2 are removed.
 //
-// CHECK-LABEL: sil [ossa] @reborrow_no_adjacent_consume : $@convention(thin) (@owned X) -> () {
+// CHECK-LABEL: sil [ossa] @reborrow_no_adjacent_consume : $@convention(thin) () -> () {
 // CHECK: bb1(%{{.*}} : @guaranteed $X, %{{.*}} : @owned $X):
 // CHECK-NEXT:   br bb2
 // CHECK: bb2(%{{.*}} : @guaranteed $X):
 // CHECK-NEXT:   end_borrow
 // CHECK-NEXT:   destroy_value
-sil [ossa] @reborrow_no_adjacent_consume : $@convention(thin) (@owned X) -> () {
-bb0(%0 : @owned $X):
+sil [ossa] @reborrow_no_adjacent_consume : $@convention(thin) () -> () {
+bb0:
+  %0 = apply undef() : $@convention(thin) () -> (@owned X)
   %1 = begin_borrow %0 : $X
   br bb1(%1 : $X, %0 : $X)