[swift-inspect] Add a command for dumping metadata cache nodes.

include/swift/Reflection/ReflectionContext.h

@@ -850,6 +850,36 @@ class ReflectionContext
     }
   }
 
+  llvm::Optional<MetadataCacheNode<Runtime>>
+  metadataAllocationCacheNode(MetadataAllocation<Runtime> Allocation) {
+    switch (Allocation.Tag) {
+    case BoxesTag:
+    case ObjCClassWrappersTag:
+    case FunctionTypesTag:
+    case MetatypeTypesTag:
+    case ExistentialMetatypeValueWitnessTablesTag:
+    case ExistentialMetatypesTag:
+    case ExistentialTypesTag:
+    case OpaqueExistentialValueWitnessTablesTag:
+    case ClassExistentialValueWitnessTablesTag:
+    case ForeignWitnessTablesTag:
+    case TupleCacheTag:
+    case GenericMetadataCacheTag:
+    case ForeignMetadataCacheTag:
+    case GenericWitnessTableCacheTag: {
+      auto NodeBytes = getReader().readBytes(
+          RemoteAddress(Allocation.Ptr), sizeof(MetadataCacheNode<Runtime>));
+      auto Node =
+          reinterpret_cast<const MetadataCacheNode<Runtime> *>(NodeBytes.get());
+      if (!Node)
+        return llvm::None;
+      return *Node;
+    }
+    default:
+      return llvm::None;
+    }
+  }
+
   /// Iterate the metadata allocations in the target process, calling Call with
   /// each allocation found. Returns None on success, and a string describing
   /// the error on failure.

include/swift/Reflection/RuntimeInternals.h

@@ -41,6 +41,11 @@ struct MetadataAllocation {
   unsigned Size;
 };
 
+template <typename Runtime> struct MetadataCacheNode {
+  typename Runtime::StoredPointer Left;
+  typename Runtime::StoredPointer Right;
+};
+
 } // end namespace reflection
 } // end namespace swift
 

include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h

@@ -339,6 +339,12 @@ const char *
 swift_reflection_metadataAllocationTagName(SwiftReflectionContextRef ContextRef,
                                            swift_metadata_allocation_tag_t Tag);
 
+SWIFT_REMOTE_MIRROR_LINKAGE
+int swift_reflection_metadataAllocationCacheNode(
+    SwiftReflectionContextRef ContextRef,
+    swift_metadata_allocation_t Allocation,
+    swift_metadata_cache_node_t *OutNode);
+
 /// Backtrace iterator callback passed to
 /// swift_reflection_iterateMetadataAllocationBacktraces
 typedef void (*swift_metadataAllocationBacktraceIterator)(

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -162,6 +162,11 @@ typedef struct swift_metadata_allocation {
   unsigned Size;
 } swift_metadata_allocation_t;
 
+typedef struct swift_metadata_cache_node {
+  swift_reflection_ptr_t Left;
+  swift_reflection_ptr_t Right;
+} swift_metadata_cache_node_t;
+
 /// An opaque pointer to a context which maintains state and
 /// caching of reflection structure for heap instances.
 typedef struct SwiftReflectionContext *SwiftReflectionContextRef;

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -645,6 +645,25 @@ const char *swift_reflection_metadataAllocationTagName(
   return returnableCString(ContextRef, Result);
 }
 
+int swift_reflection_metadataAllocationCacheNode(
+    SwiftReflectionContextRef ContextRef,
+    swift_metadata_allocation_t Allocation,
+    swift_metadata_cache_node_t *OutNode) {
+  auto Context = ContextRef->nativeContext;
+  MetadataAllocation<Runtime> ConvertedAllocation;
+  ConvertedAllocation.Tag = Allocation.Tag;
+  ConvertedAllocation.Ptr = Allocation.Ptr;
+  ConvertedAllocation.Size = Allocation.Size;
+
+  auto Result = Context->metadataAllocationCacheNode(ConvertedAllocation);
+  if (!Result)
+    return 0;
+
+  OutNode->Left = Result->Left;
+  OutNode->Right = Result->Right;
+  return 1;
+}
+
 const char *swift_reflection_iterateMetadataAllocationBacktraces(
     SwiftReflectionContextRef ContextRef,
     swift_metadataAllocationBacktraceIterator Call, void *ContextPtr) {

tools/swift-inspect/Sources/swift-inspect/RemoteMirrorExtensions.swift

@@ -83,6 +83,23 @@ extension SwiftReflectionContextRef {
     swift_reflection_allocationMetadataPointer(self, allocation)
   }
 
+  func metadataTagName(_ tag: swift_metadata_allocation_tag_t) -> String? {
+    swift_reflection_metadataAllocationTagName(self, tag)
+      .map(String.init)
+  }
+
+  func metadataAllocationCacheNode(
+    _ allocation: swift_metadata_allocation_t
+  ) -> swift_metadata_cache_node_t? {
+    var node = swift_metadata_cache_node_t();
+    let success = swift_reflection_metadataAllocationCacheNode(
+      self, allocation, &node)
+    if success == 0 {
+      return nil
+    }
+    return node
+  }
+
   private func throwError(str: UnsafePointer<CChar>?) throws {
     if let str = str {
       throw Error(cString: str)

tools/swift-inspect/Sources/swift-inspect/main.swift

@@ -40,8 +40,7 @@ func dumpRawMetadata(
 ) throws {
   let backtraces = backtraceStyle != nil ? context.allocationBacktraces : [:]
   for allocation in context.allocations {
-    let tagNameC = swift_reflection_metadataAllocationTagName(context, allocation.tag)
-    let tagName = tagNameC.map(String.init) ?? "<unknown>"
+    let tagName = context.metadataTagName(allocation.tag) ?? "<unknown>"
     print("Metadata allocation at: \(hex: allocation.ptr) " +
           "size: \(allocation.size) tag: \(allocation.tag) (\(tagName))")
     printBacktrace(style: backtraceStyle, for: allocation.ptr, in: backtraces, inspector: inspector)
@@ -74,6 +73,22 @@ func dumpGenericMetadata(
   }
 }
 
+func dumpMetadataCacheNodes(
+  context: SwiftReflectionContextRef,
+  inspector: Inspector
+) throws {
+  print("Address","Tag","Tag Name","Size","Left","Right", separator: "\t")
+  for allocation in context.allocations {
+    guard let node = context.metadataAllocationCacheNode(allocation.allocation_t) else {
+      continue
+    }
+
+    let tagName = context.metadataTagName(allocation.tag) ?? "<unknown>"
+    print("\(hex: allocation.ptr)\t\(allocation.tag)\t\(tagName)\t" +
+          "\(allocation.size)\t\(hex: node.Left)\t\(hex: node.Right)")
+  }
+}
+
 func printBacktrace(
   style: Backtrace.Style?,
   for ptr: swift_reflection_ptr_t,
@@ -133,18 +148,38 @@ struct SwiftInspect: ParsableCommand {
       DumpConformanceCache.self,
       DumpRawMetadata.self,
       DumpGenericMetadata.self,
+      DumpCacheNodes.self,
     ])
 }
 
+struct UniversalOptions: ParsableArguments {
+  @Argument(help: "The pid or partial name of the target process")
+  var nameOrPid: String
+}
+
+struct BacktraceOptions: ParsableArguments {
+  @Flag(help: "Show the backtrace for each allocation")
+  var backtrace: Bool
+
+  @Flag(help: "Show a long-form backtrace for each allocation")
+  var backtraceLong: Bool
+
+  var style: Backtrace.Style? {
+    backtrace ? .oneLine :
+    backtraceLong ? .long :
+    nil
+  }
+}
+
 struct DumpConformanceCache: ParsableCommand {
   static let configuration = CommandConfiguration(
     abstract: "Print the contents of the target's protocol conformance cache.")
 
-  @Argument(help: "The pid or partial name of the target process")
-  var nameOrPid: String
+  @OptionGroup()
+  var options: UniversalOptions
 
   func run() throws {
-    try withReflectionContext(nameOrPid: nameOrPid) { context, _ in
+    try withReflectionContext(nameOrPid: options.nameOrPid) { context, _ in
       try dumpConformanceCache(context: context)
     }
   }
@@ -153,22 +188,18 @@ struct DumpConformanceCache: ParsableCommand {
 struct DumpRawMetadata: ParsableCommand {
   static let configuration = CommandConfiguration(
     abstract: "Print the target's metadata allocations.")
-  @Argument(help: "The pid or partial name of the target process")
-
-  var nameOrPid: String
 
-  @Flag(help: "Show the backtrace for each allocation")
-  var backtrace: Bool
+  @OptionGroup()
+  var universalOptions: UniversalOptions
 
-  @Flag(help: "Show a long-form backtrace for each allocation")
-  var backtraceLong: Bool
+  @OptionGroup()
+  var backtraceOptions: BacktraceOptions
 
   func run() throws {
-    let style = backtrace ? Backtrace.Style.oneLine :
-                backtraceLong ? Backtrace.Style.long :
-                nil
-    try withReflectionContext(nameOrPid: nameOrPid) {
-      try dumpRawMetadata(context: $0, inspector: $1, backtraceStyle: style)
+    try withReflectionContext(nameOrPid: universalOptions.nameOrPid) {
+      try dumpRawMetadata(context: $0,
+                          inspector: $1,
+                          backtraceStyle: backtraceOptions.style)
     }
   }
 }
@@ -177,23 +208,32 @@ struct DumpGenericMetadata: ParsableCommand {
   static let configuration = CommandConfiguration(
     abstract: "Print the target's generic metadata allocations.")
 
-  @Argument(help: "The pid or partial name of the target process")
-  var nameOrPid: String
+  @OptionGroup()
+  var universalOptions: UniversalOptions
 
-  @Flag(help: "Show the backtrace for each allocation")
-  var backtrace: Bool
-
-  @Flag(help: "Show a long-form backtrace for each allocation")
-  var backtraceLong: Bool
+  @OptionGroup()
+  var backtraceOptions: BacktraceOptions
 
   func run() throws {
-    let style = backtrace ? Backtrace.Style.oneLine :
-                backtraceLong ? Backtrace.Style.long :
-                nil
-    try withReflectionContext(nameOrPid: nameOrPid) {
+    try withReflectionContext(nameOrPid: universalOptions.nameOrPid) {
       try dumpGenericMetadata(context: $0,
                               inspector: $1,
-                              backtraceStyle: style)
+                              backtraceStyle: backtraceOptions.style)
+    }
+  }
+}
+
+struct DumpCacheNodes: ParsableCommand {
+  static let configuration = CommandConfiguration(
+    abstract: "Print the target's metadata cache nodes.")
+
+  @OptionGroup()
+  var options: UniversalOptions
+
+  func run() throws {
+    try withReflectionContext(nameOrPid: options.nameOrPid) {
+      try dumpMetadataCacheNodes(context: $0,
+                                 inspector: $1)
     }
   }
 }