Runtime: Wrap pack pointers in a fancy TargetPackPointer template instead of twiddling the LSB by hand

This is more type safe in theory, but in practice it's just catnip for C++ fans.

Author: slavapestov

include/swift/ABI/Metadata.h

@@ -4863,6 +4863,50 @@ class RuntimeDiscoverableAttributeRecord
   }
 };
 
+enum class PackLifetime : uint8_t {
+  OnStack = 0,
+  OnHeap = 1
+};
+
+/// A pointer to a metadata or witness table pack. If the LSB is set,
+/// the pack is allocated on the heap; otherwise, it is allocated on
+/// the stack.
+template<typename Runtime, template <typename> class Pointee>
+class TargetPackPointer {
+  typename Runtime::StoredSize Ptr;
+
+  using PointerType = typename Runtime::template Pointer<const Pointee<Runtime>>;
+
+public:
+  explicit TargetPackPointer(PointerType const *ptr, PackLifetime lifetime)
+    : Ptr(reinterpret_cast<typename Runtime::StoredSize>(ptr) |
+          (lifetime == PackLifetime::OnHeap ? 1 : 0)) {}
+
+  const PointerType *getElements() const {
+    return reinterpret_cast<const PointerType *>(Ptr & ~1);
+  }
+
+  PointerType *getElements() {
+    return reinterpret_cast<PointerType *>(Ptr & ~1);
+  }
+
+  PackLifetime getLifetime() const {
+    return (bool)(Ptr & 1) ? PackLifetime::OnHeap : PackLifetime::OnStack;
+  }
+};
+
+/// A pointer to a metadata pack.
+template<typename Runtime>
+using TargetMetadataPackPointer = TargetPackPointer<Runtime, TargetMetadata>;
+
+using MetadataPackPointer = TargetMetadataPackPointer<InProcess>;
+
+/// A pointer to a witness table pack.
+template<typename Runtime>
+using TargetWitnessTablePackPointer = TargetPackPointer<Runtime, TargetWitnessTable>;
+
+using WitnessTablePackPointer = TargetWitnessTablePackPointer<InProcess>;
+
 } // end namespace swift
 
 #pragma clang diagnostic pop

include/swift/Runtime/Metadata.h

@@ -456,8 +456,8 @@ bool swift_compareProtocolConformanceDescriptors(
 /// \returns a metadata pack allocated on the heap, with the least significant
 /// bit set to true.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-const Metadata * const *
-swift_allocateMetadataPack(const Metadata * const *pack, unsigned count);
+MetadataPackPointer
+swift_allocateMetadataPack(MetadataPackPointer pack, unsigned count);
 
 /// Allocate a witness table pack on the heap, unless this pack is already on
 /// the heap.
@@ -471,8 +471,8 @@ swift_allocateMetadataPack(const Metadata * const *pack, unsigned count);
 /// \returns a witness table pack allocated on the heap, with the least
 /// significant bit set to true.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-const WitnessTable * const *
-swift_allocateWitnessTablePack(const WitnessTable * const *pack, unsigned count);
+WitnessTablePackPointer
+swift_allocateWitnessTablePack(WitnessTablePackPointer pack, unsigned count);
 
 /// Fetch a uniqued metadata for a function type.
 SWIFT_RUNTIME_EXPORT

stdlib/public/runtime/Metadata.cpp

@@ -1231,32 +1231,31 @@ MetadataPackCacheEntry::MetadataPackCacheEntry(const Key &key) {
 static SimpleGlobalCache<MetadataPackCacheEntry, MetadataPackTag> MetadataPacks;
 
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-const Metadata * const *
-swift_allocateMetadataPack(const Metadata * const *pack, unsigned count) {
-  if (reinterpret_cast<uintptr_t>(pack) & 1)
+MetadataPackPointer
+swift_allocateMetadataPack(MetadataPackPointer pack, unsigned count) {
+  if (pack.getLifetime() == PackLifetime::OnHeap)
     return pack;
 
-  MetadataPackCacheEntry::Key key{pack, count};
+  MetadataPackCacheEntry::Key key{pack.getElements(), count};
   auto bytes = MetadataPacks.getOrInsert(key).first->getElements();
 
-  uintptr_t bytesWithLSBSet = reinterpret_cast<uintptr_t>(bytes) | 1;
-  return reinterpret_cast<const Metadata * const *>(bytesWithLSBSet);
+  return MetadataPackPointer(bytes, PackLifetime::OnHeap);
 }
 
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
-const WitnessTable * const *
-swift_allocateWitnessTablePack(const WitnessTable * const *pack, unsigned count) {
-  if (reinterpret_cast<uintptr_t>(pack) & 1)
+WitnessTablePackPointer
+swift_allocateWitnessTablePack(WitnessTablePackPointer pack, unsigned count) {
+  if (pack.getLifetime() == PackLifetime::OnHeap)
     return pack;
 
   size_t totalSize = (size_t) count * sizeof(const WitnessTable *);
 
-  auto bytes = (char*) MetadataAllocator(WitnessTablePackTag)
-    .Allocate(totalSize, alignof(const WitnessTable *));
-  memcpy(bytes, pack, totalSize);
+  auto bytes = (const WitnessTable **)
+    MetadataAllocator(WitnessTablePackTag)
+      .Allocate(totalSize, alignof(const WitnessTable *));
+  memcpy((char*) bytes, pack.getElements(), totalSize);
 
-  uintptr_t bytesWithLSBSet = reinterpret_cast<uintptr_t>(bytes) | 1;
-  return reinterpret_cast<const WitnessTable * const *>(bytesWithLSBSet);
+  return WitnessTablePackPointer(bytes, PackLifetime::OnHeap);
 }
 
 /***************************************************************************/