Merge pull request #29861 from gottesmm/pr-a7dde2547b804476719e9b64324acca8f5d05680

[ownership] Change BorrowScopeIntroducingValue::{visit,gather}LocalScopeEndingUses to use isConsumingUse instead of checking for isa<EndBorrowInst>().

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -236,9 +236,12 @@ struct BorrowScopeOperandKind {
   }
 
   void print(llvm::raw_ostream &os) const;
-  SWIFT_DEBUG_DUMP;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 };
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              BorrowScopeOperandKind kind);
+
 /// An operand whose user instruction introduces a new borrow scope for the
 /// operand's value. The value of the operand must be considered as implicitly
 /// borrowed until the user's corresponding end scope instruction.
@@ -258,25 +261,10 @@ struct BorrowScopeOperand {
     return BorrowScopeOperand(*kind, op);
   }
 
-  void visitEndScopeInstructions(function_ref<void(Operand *)> func) const {
-    switch (kind) {
-    case BorrowScopeOperandKind::BeginBorrow:
-      for (auto *use : cast<BeginBorrowInst>(op->getUser())->getUses()) {
-        if (isa<EndBorrowInst>(use->getUser())) {
-          func(use);
-        }
-      }
-      return;
-    case BorrowScopeOperandKind::BeginApply: {
-      auto *user = cast<BeginApplyInst>(op->getUser());
-      for (auto *use : user->getTokenResult()->getUses()) {
-        func(use);
-      }
-      return;
-    }
-    }
-    llvm_unreachable("Covered switch isn't covered");
-  }
+  void visitEndScopeInstructions(function_ref<void(Operand *)> func) const;
+
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 
 private:
   /// Internal constructor for failable static constructor. Please do not expand
@@ -286,7 +274,7 @@ struct BorrowScopeOperand {
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
-                              BorrowScopeOperandKind kind);
+                              const BorrowScopeOperand &operand);
 
 struct BorrowScopeIntroducingValueKind {
   using UnderlyingKindTy = std::underlying_type<ValueKind>::type;
@@ -336,7 +324,7 @@ struct BorrowScopeIntroducingValueKind {
   }
 
   void print(llvm::raw_ostream &os) const;
-  SWIFT_DEBUG_DUMP;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
@@ -419,6 +407,9 @@ struct BorrowScopeIntroducingValue {
                              SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
                              DeadEndBlocks &deadEndBlocks) const;
 
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+
 private:
   /// Internal constructor for failable static constructor. Please do not expand
   /// its usage since it assumes the code passed in is well formed.
@@ -427,6 +418,9 @@ struct BorrowScopeIntroducingValue {
       : kind(kind), value(value) {}
 };
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              const BorrowScopeIntroducingValue &value);
+
 /// Look up through the def-use chain of \p inputValue, recording any "borrow"
 /// introducing values that we find into \p out. If at any point, we find a
 /// point in the chain we do not understand, we bail and return false. If we are

lib/SIL/OwnershipUtils.cpp

@@ -87,6 +87,62 @@ bool swift::isOwnershipForwardingInst(SILInstruction *i) {
   return isOwnershipForwardingValueKind(SILNodeKind(i->getKind()));
 }
 
+//===----------------------------------------------------------------------===//
+//                           Borrow Scope Operand
+//===----------------------------------------------------------------------===//
+
+void BorrowScopeOperandKind::print(llvm::raw_ostream &os) const {
+  switch (value) {
+  case Kind::BeginBorrow:
+    os << "BeginBorrow";
+    return;
+  case Kind::BeginApply:
+    os << "BeginApply";
+    return;
+  }
+  llvm_unreachable("Covered switch isn't covered?!");
+}
+
+llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
+                                     BorrowScopeOperandKind kind) {
+  kind.print(os);
+  return os;
+}
+
+void BorrowScopeOperand::print(llvm::raw_ostream &os) const {
+  os << "BorrowScopeOperand:\n"
+        "Kind: " << kind << "\n"
+        "Value: " << op->get()
+     << "User: " << op->getUser();
+}
+
+llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
+                                     const BorrowScopeOperand &operand) {
+  operand.print(os);
+  return os;
+}
+
+void BorrowScopeOperand::visitEndScopeInstructions(
+    function_ref<void(Operand *)> func) const {
+  switch (kind) {
+  case BorrowScopeOperandKind::BeginBorrow:
+    for (auto *use : cast<BeginBorrowInst>(op->getUser())->getUses()) {
+      if (isa<EndBorrowInst>(use->getUser())) {
+        func(use);
+      }
+    }
+    return;
+  case BorrowScopeOperandKind::BeginApply: {
+    auto *user = cast<BeginApplyInst>(op->getUser());
+    for (auto *use : user->getTokenResult()->getUses()) {
+      func(use);
+    }
+    return;
+  }
+  }
+  llvm_unreachable("Covered switch isn't covered");
+}
+
 //===----------------------------------------------------------------------===//
 //                             Borrow Introducers
 //===----------------------------------------------------------------------===//
@@ -106,10 +162,10 @@ void BorrowScopeIntroducingValueKind::print(llvm::raw_ostream &os) const {
   llvm_unreachable("Covered switch isn't covered?!");
 }
 
-void BorrowScopeIntroducingValueKind::dump() const {
-#ifndef NDEBUG
-  print(llvm::dbgs());
-#endif
+void BorrowScopeIntroducingValue::print(llvm::raw_ostream &os) const {
+  os << "BorrowScopeIntroducingValue:\n"
+    "Kind: " << kind << "\n"
+    "Value: " << value;
 }
 
 void BorrowScopeIntroducingValue::getLocalScopeEndingInstructions(
@@ -120,12 +176,12 @@ void BorrowScopeIntroducingValue::getLocalScopeEndingInstructions(
   case BorrowScopeIntroducingValueKind::SILFunctionArgument:
     llvm_unreachable("Should only call this with a local scope");
   case BorrowScopeIntroducingValueKind::BeginBorrow:
-    llvm::copy(cast<BeginBorrowInst>(value)->getEndBorrows(),
-               std::back_inserter(scopeEndingInsts));
-    return;
   case BorrowScopeIntroducingValueKind::LoadBorrow:
-    llvm::copy(cast<LoadBorrowInst>(value)->getEndBorrows(),
-               std::back_inserter(scopeEndingInsts));
+    for (auto *use : value->getUses()) {
+      if (use->isConsumingUse()) {
+	scopeEndingInsts.push_back(use->getUser());
+      }
+    }
     return;
   }
   llvm_unreachable("Covered switch isn't covered?!");
@@ -137,16 +193,10 @@ void BorrowScopeIntroducingValue::visitLocalScopeEndingUses(
   switch (kind) {
   case BorrowScopeIntroducingValueKind::SILFunctionArgument:
     llvm_unreachable("Should only call this with a local scope");
-  case BorrowScopeIntroducingValueKind::BeginBorrow:
-    for (auto *use : value->getUses()) {
-      if (isa<EndBorrowInst>(use->getUser())) {
-        visitor(use);
-      }
-    }
-    return;
   case BorrowScopeIntroducingValueKind::LoadBorrow:
+  case BorrowScopeIntroducingValueKind::BeginBorrow:
     for (auto *use : value->getUses()) {
-      if (isa<EndBorrowInst>(use->getUser())) {
+      if (use->isConsumingUse()) {
         visitor(use);
       }
     }
@@ -212,6 +262,12 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
   return os;
 }
 
+llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
+                                     const BorrowScopeIntroducingValue &value) {
+  value.print(os);
+  return os;
+}
+
 bool BorrowScopeIntroducingValue::areInstructionsWithinScope(
     ArrayRef<SILInstruction *> instructions,
     SmallVectorImpl<SILInstruction *> &scratchSpace,