[NFC] OSSACanOwned: Record defs in SetVector.

In preparation for only recording the defs once, replace the
GraphNodeWorklist of defs with a SetVector.  Preserve the current
visitation order by creating a GraphNodeWorklist of indices to be
visited.

Author: nate-chandler

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -96,7 +96,6 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 #define SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 
-#include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/Basic/SmallPtrSetVector.h"
 #include "swift/Basic/TaggedUnion.h"
 #include "swift/SIL/PrunedLiveness.h"
@@ -342,12 +341,9 @@ class CanonicalizeOSSALifetime final {
     }
   };
   friend llvm::DenseMapInfo<Def>;
-  friend llvm::PointerLikeTypeTraits<Def>;
-  friend llvm::PointerLikeTypeTraits<
-      std::optional<swift::CanonicalizeOSSALifetime::Def>>;
 
   /// Visited set for general def-use traversal that prevents revisiting values.
-  GraphNodeWorklist<std::optional<Def>, 8> defUseWorklist;
+  llvm::SmallSetVector<Def, 8> defUseWorklist;
 
   /// The blocks that were discovered by PrunedLiveness.
   SmallVector<SILBasicBlock *, 32> discoveredBlocks;
@@ -585,72 +581,6 @@ struct DenseMapInfo<swift::CanonicalizeOSSALifetime::Def> {
     return LHS == RHS;
   }
 };
-template <>
-struct PointerLikeTypeTraits<swift::CanonicalizeOSSALifetime::Def> {
-private:
-  using Def = swift::CanonicalizeOSSALifetime::Def;
-
-public:
-  static void *getAsVoidPointer(Def def) {
-    return reinterpret_cast<void *>(
-        reinterpret_cast<uintptr_t>(def.getValue().getOpaqueValue()) |
-        ((uintptr_t)def.getKind()) << NumLowBitsAvailable);
-  }
-  static Def getFromVoidPointer(void *p) {
-    auto kind = (Def::Kind)((reinterpret_cast<uintptr_t>(p) & 0b110) >>
-                            NumLowBitsAvailable);
-    auto opaque =
-        reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p) & ~0b111);
-    auto value = swift::SILValue::getFromOpaqueValue(opaque);
-    switch (kind) {
-    case Def::Kind::Root:
-      return Def::root(value);
-    case Def::Kind::Copy:
-      return Def::copy(cast<swift::CopyValueInst>(value));
-    case Def::Kind::Reborrow:
-      return Def::reborrow(cast<swift::SILArgument>(value));
-    case Def::Kind::BorrowedFrom:
-      return Def::borrowedFrom(cast<swift::BorrowedFromInst>(value));
-    }
-  }
-
-  enum {
-    NumLowBitsAvailable =
-        llvm::PointerLikeTypeTraits<swift::SILValue>::NumLowBitsAvailable - 2
-  };
-};
-template <>
-struct PointerLikeTypeTraits<
-    std::optional<swift::CanonicalizeOSSALifetime::Def>> {
-private:
-  using Def = swift::CanonicalizeOSSALifetime::Def;
-  using Payload = std::optional<Def>;
-
-public:
-  static void *getAsVoidPointer(Payload payload) {
-    if (!payload)
-      return 0x0;
-    return reinterpret_cast<void *>(
-        reinterpret_cast<uintptr_t>(
-            PointerLikeTypeTraits<swift::CanonicalizeOSSALifetime::Def>::
-                getAsVoidPointer(*payload)) |
-        0b1);
-  }
-  static Payload getFromVoidPointer(void *p) {
-    auto none = reinterpret_cast<uintptr_t>(p) & 0b1;
-    if (none)
-      return std::nullopt;
-    auto opaque =
-        reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p) & ~0b1);
-    return {PointerLikeTypeTraits<
-        swift::CanonicalizeOSSALifetime::Def>::getFromVoidPointer(opaque)};
-  }
-
-  enum {
-    NumLowBitsAvailable =
-        llvm::PointerLikeTypeTraits<Def>::NumLowBitsAvailable - 1
-  };
-};
 } // end namespace llvm
 
 #endif

lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp

@@ -15,6 +15,7 @@
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/Defer.h"
+#include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/SIL/BasicBlockBits.h"
 #include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/DebugUtils.h"

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -65,8 +65,8 @@
 
 #define DEBUG_TYPE "copy-propagation"
 
-#include "swift/Basic/Assertions.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h"
+#include "swift/Basic/Assertions.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/NodeDatastructures.h"
 #include "swift/SIL/OSSALifetimeCompletion.h"
@@ -132,18 +132,27 @@ static bool isDestroyOfCopyOf(SILInstruction *instruction, SILValue def) {
 bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
   LLVM_DEBUG(llvm::dbgs() << "Computing canonical liveness from:\n";
              getCurrentDef()->print(llvm::dbgs()));
-  defUseWorklist.initialize(Def::root(getCurrentDef()));
+  SmallVector<unsigned, 8> indexWorklist;
+  auto addDefToWorklist = [&](Def def) {
+    if (!defUseWorklist.insert(def))
+      return;
+    indexWorklist.push_back(defUseWorklist.size() - 1);
+  };
+  defUseWorklist.clear();
+  addDefToWorklist(Def::root(getCurrentDef()));
   // Only the first level of reborrows need to be consider. All nested inner
   // adjacent reborrows and phis are encapsulated within their lifetimes.
   SILPhiArgument *arg;
   if ((arg = dyn_cast<SILPhiArgument>(getCurrentDef())) && arg->isPhi()) {
     visitInnerAdjacentPhis(arg, [&](SILArgument *reborrow) {
-      defUseWorklist.insert(Def::reborrow(reborrow));
+      addDefToWorklist(Def::reborrow(reborrow));
       return true;
     });
   }
-  while (auto def = defUseWorklist.pop()) {
-    auto value = def->getValue();
+  while (!indexWorklist.empty()) {
+    auto index = indexWorklist.pop_back_val();
+    auto def = defUseWorklist[index];
+    auto value = def.getValue();
     LLVM_DEBUG(llvm::dbgs() << "  Uses of value:\n";
                value->print(llvm::dbgs()));
 
@@ -154,11 +163,11 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
       auto *user = use->getUser();
       // Recurse through copies.
       if (auto *copy = dyn_cast<CopyValueInst>(user)) {
-        defUseWorklist.insert(Def::copy(copy));
+        addDefToWorklist(Def::copy(copy));
         continue;
       }
       if (auto *bfi = dyn_cast<BorrowedFromInst>(user)) {
-        defUseWorklist.insert(Def::borrowedFrom(bfi));
+        addDefToWorklist(Def::borrowedFrom(bfi));
         continue;
       }
       // Handle debug_value instructions separately.
@@ -245,7 +254,7 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
         // This branch reborrows a guaranteed phi whose lifetime is dependent on
         // currentDef.  Uses of the reborrowing phi extend liveness.
         auto *reborrow = PhiOperand(use).getValue();
-        defUseWorklist.insert(Def::reborrow(reborrow));
+        addDefToWorklist(Def::reborrow(reborrow));
         break;
       }
     }
@@ -1152,6 +1161,13 @@ void CanonicalizeOSSALifetime::rewriteCopies(
   // Shadow defUseWorklist in order to constrain its uses.
   auto &defUseWorklist = this->defUseWorklist;
 
+  SmallVector<unsigned, 8> indexWorklist;
+  auto addDefToWorklist = [&](Def def) {
+    if (!defUseWorklist.insert(def))
+      return;
+    indexWorklist.push_back(defUseWorklist.size() - 1);
+  };
+
   InstructionSetVector instsToDelete(getCurrentDef()->getFunction());
 
   // Visit each operand in the def-use chain.
@@ -1162,7 +1178,7 @@ void CanonicalizeOSSALifetime::rewriteCopies(
     auto *user = use->getUser();
     // Recurse through copies.
     if (auto *copy = dyn_cast<CopyValueInst>(user)) {
-      defUseWorklist.insert(Def::copy(copy));
+      addDefToWorklist(Def::copy(copy));
       return true;
     }
     if (destroys.contains(user)) {
@@ -1197,18 +1213,22 @@ void CanonicalizeOSSALifetime::rewriteCopies(
     return true;
   };
 
-  defUseWorklist.initialize(Def::root(getCurrentDef()));
+  defUseWorklist.clear();
+  addDefToWorklist(Def::root(getCurrentDef()));
   // Perform a def-use traversal, visiting each use operand.
-  while (auto def = defUseWorklist.pop()) {
-    switch (*def) {
+
+  while (!indexWorklist.empty()) {
+    auto index = indexWorklist.pop_back_val();
+    auto def = defUseWorklist[index];
+    switch (def) {
     case Def::Kind::BorrowedFrom:
     case Def::Kind::Reborrow:
       // Direct uses of these defs never need to be rewritten.  Being guaranteed
       // values, none of their direct uses consume an owned value.
       assert(def.getValue()->getOwnershipKind() == OwnershipKind::Guaranteed);
       break;
     case Def::Kind::Root: {
-      SILValue value = def->getValue();
+      SILValue value = def.getValue();
       for (auto useIter = value->use_begin(), endIter = value->use_end();
            useIter != endIter;) {
         Operand *use = *useIter++;
@@ -1219,7 +1239,7 @@ void CanonicalizeOSSALifetime::rewriteCopies(
       break;
     }
     case Def::Kind::Copy: {
-      SILValue value = def->getValue();
+      SILValue value = def.getValue();
       CopyValueInst *srcCopy = cast<CopyValueInst>(value);
       // Recurse through copies while replacing their uses.
       Operand *reusedCopyOp = nullptr;