[region-isolation] Convert TransferringOperand to be a bump allocated ptr type from a pointer type.

I need to start tracking the dynamic IsolationRegionInfo for the transferring
operand so I can ignore uses that are part of the same
IsolationRegionInfo. IsolationRegionInfo doesn't fit into a pointer, so just to
keep things the same, I am going to just allocate it.

This is an initial staging commit that tests out the bump ptr allocating without
expanding the type yet.

Author: gottesmm

include/swift/Basic/ImmutablePointerSet.h

@@ -250,6 +250,55 @@ class ImmutablePointerSetFactory {
     return NewNode;
   }
 
+  template <typename U, typename... Args>
+  struct IsTrivialTypedPointerAndHasProfile {
+    constexpr static bool hasProfile =
+        std::is_same_v<decltype(std::remove_pointer<U>::type::Profile(
+                           std::declval<Args>()...)),
+                       void>;
+    constexpr static bool value =
+        hasProfile && std::is_trivial_v<U> && std::is_pointer_v<U>;
+  };
+
+  /// Emplace a new value with \p args if we do not yet have one. We allocate
+  /// the object with our bump ptr allocator, so we require that the type be
+  /// trivial.
+  template <typename... Args>
+  typename std::enable_if_t<IsTrivialTypedPointerAndHasProfile<
+                                T, llvm::FoldingSetNodeID &, Args...>::value,
+                            PtrSet> *
+  emplace(Args... args) {
+    llvm::FoldingSetNodeID ID;
+    using NoPointerTy = typename std::remove_pointer<T>::type;
+    NoPointerTy::Profile(ID, std::forward<Args>(args)...);
+
+    void *InsertPt;
+    if (auto *PSet = Set.FindNodeOrInsertPos(ID, InsertPt)) {
+      return PSet;
+    }
+
+    size_t NumElts = 1;
+    size_t MemSize = sizeof(PtrSet) + sizeof(NoPointerTy);
+
+    // Allocate the memory.
+    auto *Mem =
+        reinterpret_cast<PtrSet *>(Allocator.Allocate(MemSize, AllocAlignment));
+
+    // Copy in the pointers into the tail allocated memory. We do not need to do
+    // any sorting/uniquing ourselves since we assume that our users perform
+    // this task for us.
+    llvm::MutableArrayRef<NoPointerTy *> DataMem(
+        reinterpret_cast<NoPointerTy **>(&Mem[1]), NumElts);
+    NoPointerTy *type =
+        new (Allocator) NoPointerTy(std::forward<Args>(args)...);
+    DataMem[0] = type;
+
+    // Allocate the new node and insert it into the Set.
+    auto *NewNode = new (Mem) PtrSet(this, DataMem);
+    Set.InsertNode(NewNode, InsertPt);
+    return NewNode;
+  }
+
   PtrSet *get(T value) {
     llvm::FoldingSetNodeID ID;
     ID.AddPointer(PtrTraits::getAsVoidPointer(value));

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -134,51 +134,20 @@ struct TransferringOperand {
        << "User: " << *getUser();
   }
 
-  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
-};
-
-} // namespace swift
-
-namespace llvm {
-
-template <>
-struct PointerLikeTypeTraits<swift::TransferringOperand> {
-  using TransferringOperand = swift::TransferringOperand;
-
-  static inline void *getAsVoidPointer(TransferringOperand ptr) {
-    return PointerLikeTypeTraits<
-        TransferringOperand::ValueType>::getAsVoidPointer(ptr.value);
-  }
-  static inline TransferringOperand getFromVoidPointer(void *ptr) {
-    return {PointerLikeTypeTraits<
-        TransferringOperand::ValueType>::getFromVoidPointer(ptr)};
+  static void Profile(llvm::FoldingSetNodeID &id, Operand *op,
+                      bool isClosureCaptured) {
+    id.AddPointer(op);
+    id.AddBoolean(isClosureCaptured);
   }
 
-  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
-      TransferringOperand::ValueType>::NumLowBitsAvailable;
-};
-
-template <>
-struct DenseMapInfo<swift::TransferringOperand> {
-  using TransferringOperand = swift::TransferringOperand;
-  using ParentInfo = DenseMapInfo<TransferringOperand::ValueType>;
-
-  static TransferringOperand getEmptyKey() {
-    return TransferringOperand(ParentInfo::getEmptyKey());
-  }
-  static TransferringOperand getTombstoneKey() {
-    return TransferringOperand(ParentInfo::getTombstoneKey());
+  void Profile(llvm::FoldingSetNodeID &id) const {
+    Profile(id, getOperand(), isClosureCaptured());
   }
 
-  static unsigned getHashValue(TransferringOperand operand) {
-    return ParentInfo::getHashValue(operand.value);
-  }
-  static bool isEqual(TransferringOperand LHS, TransferringOperand RHS) {
-    return ParentInfo::isEqual(LHS.value, RHS.value);
-  }
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 };
 
-} // namespace llvm
+} // namespace swift
 
 namespace swift {
 
@@ -371,9 +340,9 @@ class Partition {
 
   using Element = PartitionPrimitives::Element;
   using Region = PartitionPrimitives::Region;
-  using TransferringOperandSet = ImmutablePointerSet<TransferringOperand>;
+  using TransferringOperandSet = ImmutablePointerSet<TransferringOperand *>;
   using TransferringOperandSetFactory =
-      ImmutablePointerSetFactory<TransferringOperand>;
+      ImmutablePointerSetFactory<TransferringOperand *>;
 
 private:
   /// A map from a region number to a instruction that consumes it.
@@ -721,8 +690,8 @@ class Partition {
       bool isClosureCaptured = false;
       if (isTransferred) {
         isClosureCaptured = llvm::any_of(
-            iter->getSecond()->range(), [](const TransferringOperand &operand) {
-              return operand.isClosureCaptured();
+            iter->getSecond()->range(), [](const TransferringOperand *operand) {
+              return operand->isClosureCaptured();
             });
       }
 
@@ -765,8 +734,8 @@ class Partition {
       bool isClosureCaptured = false;
       if (isTransferred) {
         isClosureCaptured = llvm::any_of(
-            iter->getSecond()->range(), [](const TransferringOperand &operand) {
-              return operand.isClosureCaptured();
+            iter->getSecond()->range(), [](const TransferringOperand *operand) {
+              return operand->isClosureCaptured();
             });
       }
 
@@ -795,7 +764,7 @@ class Partition {
       if (isTransferred) {
         for (auto op : iter->getSecond()->data()) {
           os << "    ";
-          op.print(os);
+          op->print(os);
         }
       } else {
         os << "None.\n";
@@ -1208,7 +1177,7 @@ struct PartitionOpEvaluator {
 
   /// Call handleLocalUseAfterTransfer on our CRTP subclass.
   void handleLocalUseAfterTransfer(const PartitionOp &op, Element elt,
-                                   TransferringOperand transferringOp) const {
+                                   TransferringOperand *transferringOp) const {
     return asImpl().handleLocalUseAfterTransfer(op, elt, transferringOp);
   }
 
@@ -1326,9 +1295,9 @@ struct PartitionOpEvaluator {
       }
 
       // Mark op.getOpArgs()[0] as transferred.
-      p.markTransferred(
-          op.getOpArgs()[0],
-          ptrSetFactory.get({op.getSourceOp(), isClosureCapturedElt}));
+      auto *ptrSet =
+          ptrSetFactory.emplace(op.getSourceOp(), isClosureCapturedElt);
+      p.markTransferred(op.getOpArgs()[0], ptrSet);
       return;
     }
     case PartitionOpKind::UndoTransfer: {
@@ -1419,7 +1388,7 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
   /// region. Can be used to get the immediate value transferred or the
   /// transferring instruction.
   void handleLocalUseAfterTransfer(const PartitionOp &op, Element elt,
-                                   TransferringOperand transferringOp) const {}
+                                   TransferringOperand *transferringOp) const {}
 
   /// This is called if we detect a never transferred element that was passed to
   /// a transfer instruction.

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -1235,7 +1235,7 @@ struct DiagnosticEvaluator final
 
   void handleLocalUseAfterTransfer(const PartitionOp &partitionOp,
                                    TrackableValueID transferredVal,
-                                   TransferringOperand transferringOp) const {
+                                   TransferringOperand *transferringOp) const {
     // Ignore this if we have a gep like instruction that is returning a
     // sendable type and transferringOp was not set with closure
     // capture.
@@ -1244,7 +1244,7 @@ struct DiagnosticEvaluator final
       if (isa<TupleElementAddrInst, StructElementAddrInst>(svi) &&
           !regionanalysisimpl::isNonSendableType(svi->getType(),
                                                  svi->getFunction())) {
-        bool isCapture = transferringOp.isClosureCaptured();
+        bool isCapture = transferringOp->isClosureCaptured();
         if (!isCapture) {
           return;
         }
@@ -1254,14 +1254,14 @@ struct DiagnosticEvaluator final
     auto rep = info->getValueMap().getRepresentative(transferredVal);
     LLVM_DEBUG(llvm::dbgs()
                << "    Emitting Use After Transfer Error!\n"
-               << "        Transferring Inst: " << *transferringOp.getUser()
+               << "        Transferring Inst: " << *transferringOp->getUser()
                << "        Transferring Op Value: "
-               << transferringOp.getOperand()->get()
+               << transferringOp->getOperand()->get()
                << "        Require Inst: " << *partitionOp.getSourceInst()
                << "        ID:  %%" << transferredVal << "\n"
                << "        Rep: " << *rep << "        Transferring Op Num: "
-               << transferringOp.getOperand()->getOperandNumber() << '\n');
-    transferOpToRequireInstMultiMap.insert(transferringOp.getOperand(),
+               << transferringOp->getOperand()->getOperandNumber() << '\n');
+    transferOpToRequireInstMultiMap.insert(transferringOp->getOperand(),
                                            partitionOp.getSourceInst());
   }