Merge pull request #64700 from meg-gupta/updatehaspointerescapedce

Support all BorrowedValueKind in hasPointerEscape(BorrowedValue) api

Author: swift-ci

lib/SIL/Utils/OwnershipUtils.cpp

@@ -25,59 +25,44 @@
 
 using namespace swift;
 
-bool swift::hasPointerEscape(BorrowedValue value) {
-  assert(value.kind == BorrowedValueKind::BeginBorrow ||
-         value.kind == BorrowedValueKind::LoadBorrow);
-  GraphNodeWorklist<Operand *, 8> worklist;
-  for (Operand *use : value->getUses()) {
-    if (use->getOperandOwnership() != OperandOwnership::NonUse)
-      worklist.insert(use);
-  }
-
-  while (Operand *op = worklist.pop()) {
-    switch (op->getOperandOwnership()) {
-    case OperandOwnership::NonUse:
-    case OperandOwnership::TrivialUse:
-    case OperandOwnership::ForwardingConsume:
-    case OperandOwnership::DestroyingConsume:
-      llvm_unreachable("this operand cannot handle an inner guaranteed use");
+bool swift::hasPointerEscape(BorrowedValue original) {
+  ValueWorklist worklist(original->getFunction());
+  worklist.push(*original);
 
-    case OperandOwnership::ForwardingUnowned:
-    case OperandOwnership::PointerEscape:
+  if (auto *phi = SILArgument::asPhi(*original)) {
+    phi->visitTransitiveIncomingPhiOperands([&](auto *phi, auto *operand) {
+      worklist.pushIfNotVisited(operand->get());
       return true;
+    });
+  }
 
-    case OperandOwnership::Borrow:
-    case OperandOwnership::EndBorrow:
-    case OperandOwnership::InstantaneousUse:
-    case OperandOwnership::UnownedInstantaneousUse:
-    case OperandOwnership::InteriorPointer:
-    case OperandOwnership::BitwiseEscape:
-      break;
-    case OperandOwnership::Reborrow: {
-      SILArgument *phi = cast<BranchInst>(op->getUser())
-                             ->getDestBB()
-                             ->getArgument(op->getOperandNumber());
-      for (auto *use : phi->getUses()) {
-        if (use->getOperandOwnership() != OperandOwnership::NonUse)
-          worklist.insert(use);
+  while (auto value = worklist.pop()) {
+    for (auto *op : value->getUses()) {
+      switch (op->getOperandOwnership()) {
+      case OperandOwnership::ForwardingUnowned:
+      case OperandOwnership::PointerEscape:
+        return true;
+
+      case OperandOwnership::Reborrow: {
+        SILArgument *phi = PhiOperand(op).getValue();
+        worklist.pushIfNotVisited(phi);
+        break;
       }
-      break;
-    }
-    case OperandOwnership::GuaranteedForwarding: {
-      // This may follow a guaranteed phis.
-      ForwardingOperand(op).visitForwardedValues([&](SILValue result) {
-        // Do not include transitive uses with 'none' ownership
-        if (result->getOwnershipKind() == OwnershipKind::None)
+
+      case OperandOwnership::GuaranteedForwarding: {
+        // This may follow guaranteed phis.
+        ForwardingOperand(op).visitForwardedValues([&](SILValue result) {
+          // Do not include transitive uses with 'none' ownership
+          if (result->getOwnershipKind() == OwnershipKind::None)
+            return true;
+          worklist.pushIfNotVisited(result);
           return true;
-        for (auto *resultUse : result->getUses()) {
-          if (resultUse->getOperandOwnership() != OperandOwnership::NonUse) {
-            worklist.insert(resultUse);
-          }
-        }
-        return true;
-      });
-      break;
-    }
+        });
+        break;
+      }
+      default:
+        break;
+      }
     }
   }
   return false;

lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -281,7 +281,16 @@ void DCE::markLive() {
         }
         break;
       }
-      case SILInstructionKind::EndBorrowInst:
+      case SILInstructionKind::EndBorrowInst: {
+        auto phi = PhiValue(I.getOperand(0));
+        // If there is a pointer escape or phi is lexical, disable DCE.
+        if (phi && (hasPointerEscape(phi) || phi->isLexical())) {
+          markInstructionLive(&I);
+        }
+        // The instruction is live only if it's operand value is also live
+        addReverseDependency(I.getOperand(0), &I);
+        break;
+      }
       case SILInstructionKind::EndLifetimeInst: {
         // The instruction is live only if it's operand value is also live
         addReverseDependency(I.getOperand(0), &I);
@@ -311,11 +320,6 @@ void DCE::markLive() {
             disableBorrowDCE(root);
           }
         }
-        // If we have a lexical borrow scope or a pointer escape, disable DCE.
-        if (borrowInst->isLexical() ||
-            hasPointerEscape(BorrowedValue(borrowInst))) {
-          disableBorrowDCE(borrowInst);
-        }
         break;
       }
       case SILInstructionKind::LoadBorrowInst: {