SwiftRemoteMirror: Dig into generic SIL boxes

Part 1: Generic SIL Boxes always have instatiated metadata with kind
HeapGenericLocalVariable, which includes a metadata pointer for the
boxed type.

Part 2, after this, is to provide some kind of outgoing pointer map for
fixed heap boxes, whose metadata may be shared among different but
destructor-compatible types.

rdar://problem/26240419

Author: bitjammer

include/swift/Reflection/ReflectionContext.h

@@ -135,6 +135,12 @@ class ReflectionContext
       if (!CDAddr.first)
         return nullptr;
 
+      // FIXME: Non-generic SIL boxes also use the HeapLocalVariable metadata
+      // kind, but with a null capture descriptor right now (see
+      // FixedBoxTypeInfoBase::allocate).
+      //
+      // Non-generic SIL boxes share metadata among types with compatible
+      // layout, but we need some way to get an outgoing pointer map for them.
       auto *CD = getBuilder().getCaptureDescriptor(CDAddr.second);
       if (CD == nullptr)
         return nullptr;
@@ -144,9 +150,16 @@ class ReflectionContext
       return getClosureContextInfo(ObjectAddress, Info);
     }
 
-    case MetadataKind::HeapGenericLocalVariable:
-      // SIL @box type
+    case MetadataKind::HeapGenericLocalVariable: {
+      // Generic SIL @box type - there is always an instantiated metadata
+      // pointer for the boxed type.
+      if (auto Meta = readMetadata(MetadataAddress.second)) {
+        auto GenericHeapMeta =
+          cast<TargetGenericBoxHeapMetadata<Runtime>>(Meta.getLocalBuffer());
+        return getMetadataTypeInfo(GenericHeapMeta->BoxedType);
+      }
       return nullptr;
+    }
 
     case MetadataKind::ErrorObject:
       // ErrorProtocol boxed existential on non-Objective-C runtime target

include/swift/Remote/MetadataReader.h

@@ -957,7 +957,7 @@ class MetadataReader {
       case MetadataKind::Function:
         return _readMetadata<TargetFunctionTypeMetadata>(address);
       case MetadataKind::HeapGenericLocalVariable:
-        return _readMetadata<TargetHeapLocalVariableMetadata>(address);
+        return _readMetadata<TargetGenericBoxHeapMetadata>(address);
       case MetadataKind::HeapLocalVariable:
         return _readMetadata<TargetHeapLocalVariableMetadata>(address);
       case MetadataKind::Metatype:

include/swift/Runtime/Metadata.h

@@ -31,6 +31,7 @@
 #include "swift/Basic/Malloc.h"
 #include "swift/Basic/FlaggedPointer.h"
 #include "swift/Basic/RelativePointer.h"
+#include "../../../stdlib/public/SwiftShims/HeapObject.h"
 
 namespace swift {
 
@@ -2494,6 +2495,63 @@ struct TargetGenericMetadata {
 };
 using GenericMetadata = TargetGenericMetadata<InProcess>;
 
+/// Heap metadata for a box, which may have been generated statically by the
+/// compiler or by the runtime.
+template <typename Runtime>
+struct TargetBoxHeapMetadata : public TargetHeapMetadata<Runtime> {
+  /// The offset from the beginning of a box to its value.
+  unsigned Offset;
+
+  constexpr TargetBoxHeapMetadata(MetadataKind kind, unsigned offset)
+  : TargetHeapMetadata<Runtime>(kind), Offset(offset) {}
+};
+using BoxHeapMetadata = TargetBoxHeapMetadata<InProcess>;
+
+/// Heap metadata for runtime-instantiated generic boxes.
+template <typename Runtime>
+struct TargetGenericBoxHeapMetadata : public TargetBoxHeapMetadata<Runtime> {
+  using super = TargetBoxHeapMetadata<Runtime>;
+  using super::Offset;
+
+  /// The type inside the box.
+  ConstTargetMetadataPointer<Runtime, TargetMetadata> BoxedType;
+
+  constexpr
+  TargetGenericBoxHeapMetadata(MetadataKind kind, unsigned offset,
+    ConstTargetMetadataPointer<Runtime, TargetMetadata> boxedType)
+  : TargetBoxHeapMetadata<Runtime>(kind, offset), BoxedType(boxedType)
+  {}
+
+  static unsigned getHeaderOffset(const Metadata *boxedType) {
+    // Round up the header size to alignment.
+    unsigned alignMask = boxedType->getValueWitnesses()->getAlignmentMask();
+    return (sizeof(HeapObject) + alignMask) & ~alignMask;
+  }
+
+  /// Project the value out of a box of this type.
+  OpaqueValue *project(HeapObject *box) const {
+    auto bytes = reinterpret_cast<char*>(box);
+    return reinterpret_cast<OpaqueValue *>(bytes + Offset);
+  }
+
+  /// Get the allocation size of this box.
+  unsigned getAllocSize() const {
+    return Offset + BoxedType->getValueWitnesses()->getSize();
+  }
+
+  /// Get the allocation alignment of this box.
+  unsigned getAllocAlignMask() const {
+    // Heap allocations are at least pointer aligned.
+    return BoxedType->getValueWitnesses()->getAlignmentMask()
+    | (alignof(void*) - 1);
+  }
+
+  static bool classof(const TargetMetadata<Runtime> *metadata) {
+    return metadata->getKind() == MetadataKind::HeapGenericLocalVariable;
+  }
+};
+using GenericBoxHeapMetadata = TargetGenericBoxHeapMetadata<InProcess>;
+
 /// \brief The control structure of a generic or resilient protocol
 /// conformance.
 ///

stdlib/public/runtime/HeapObject.cpp

@@ -133,57 +133,6 @@ SWIFT_RUNTIME_EXPORT
 extern "C" intptr_t swift_bufferHeaderSize() { return sizeof(HeapObject); }
 
 namespace {
-/// Heap metadata for a box, which may have been generated statically by the
-/// compiler or by the runtime.
-struct BoxHeapMetadata : public HeapMetadata {
-  /// The offset from the beginning of a box to its value.
-  unsigned Offset;
-
-  constexpr BoxHeapMetadata(MetadataKind kind,
-                            unsigned offset)
-    : HeapMetadata{kind}, Offset(offset)
-  {}
-
-
-};
-
-/// Heap metadata for runtime-instantiated generic boxes.
-struct GenericBoxHeapMetadata : public BoxHeapMetadata {
-  /// The type inside the box.
-  const Metadata *BoxedType;
-
-  constexpr GenericBoxHeapMetadata(MetadataKind kind,
-                                   unsigned offset,
-                                   const Metadata *boxedType)
-    : BoxHeapMetadata{kind, offset},
-      BoxedType(boxedType)
-  {}
-
-  static unsigned getHeaderOffset(const Metadata *boxedType) {
-    // Round up the header size to alignment.
-    unsigned alignMask = boxedType->getValueWitnesses()->getAlignmentMask();
-    return (sizeof(HeapObject) + alignMask) & ~alignMask;
-  }
-
-  /// Project the value out of a box of this type.
-  OpaqueValue *project(HeapObject *box) const {
-    auto bytes = reinterpret_cast<char*>(box);
-    return reinterpret_cast<OpaqueValue *>(bytes + Offset);
-  }
-
-  /// Get the allocation size of this box.
-  unsigned getAllocSize() const {
-    return Offset + BoxedType->getValueWitnesses()->getSize();
-  }
-
-  /// Get the allocation alignment of this box.
-  unsigned getAllocAlignMask() const {
-    // Heap allocations are at least pointer aligned.
-    return BoxedType->getValueWitnesses()->getAlignmentMask()
-      | (alignof(void*) - 1);
-  }
-};
-
 /// Heap object destructor for a generic box allocated with swift_allocBox.
 static void destroyGenericBox(HeapObject *o) {
   auto metadata = static_cast<const GenericBoxHeapMetadata *>(o->metadata);