[swift-inspect] Add json output option for dump-generic-metadata

This change adds json output option to dump-generic-metadata for
swift-inspect.

Author: w6sec

tools/swift-inspect/Sources/swift-inspect/Operations/DumpGenericMetadata.swift

@@ -12,15 +12,47 @@
 
 import ArgumentParser
 import SwiftRemoteMirror
+import Foundation
 
-private struct Metadata {
+private struct Metadata: Encodable {
   let ptr: swift_reflection_ptr_t
   var allocation: swift_metadata_allocation_t?
-
   let name: String
   let isArrayOfClass: Bool
-
+  var garbage: Bool = false
   var offset: Int? { allocation.map { Int(self.ptr - $0.ptr) } }
+  var backtrace: String?
+
+  enum CodingKeys: String, CodingKey {
+    case ptr = "address"
+    case allocation
+    case name
+    case isArrayOfClass
+    case garbage
+    case offset
+    case backtrace
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(ptr, forKey: .ptr)
+    try container.encode(name, forKey: .name)
+    if isArrayOfClass {
+      try container.encode(isArrayOfClass, forKey: .isArrayOfClass)
+    }
+    if garbage {
+      try container.encode(garbage, forKey: .garbage)
+    }
+    if let offset {
+      try container.encode(offset, forKey: .offset)
+    }
+    if let backtrace {
+      try container.encode(backtrace, forKey: .backtrace)
+    }
+    if let allocation {
+      try container.encode(allocation, forKey: .allocation)
+    }
+  }
 }
 
 internal struct DumpGenericMetadata: ParsableCommand {
@@ -41,52 +73,79 @@ internal struct DumpGenericMetadata: ParsableCommand {
       let allocations: [swift_metadata_allocation_t] =
           try process.context.allocations.sorted()
 
-      let generics: [Metadata] = allocations.compactMap { allocation -> Metadata? in
+      let stacks: [swift_reflection_ptr_t:[swift_reflection_ptr_t]] =
+          backtraceOptions.style == nil
+          ? [swift_reflection_ptr_t:[swift_reflection_ptr_t]]()
+          : try process.context.allocationStacks
+
+      let generics: [Metadata] = allocations.compactMap { allocation in
         let pointer = swift_reflection_allocationMetadataPointer(process.context, allocation)
         if pointer == 0 { return nil }
+        let allocation = allocations.last(where: { pointer >= $0.ptr && pointer < $0.ptr + UInt64($0.size) })
+        let garbage = (allocation == nil && swift_reflection_ownsAddressStrict(process.context, UInt(pointer)) == 0)
+        var currentBacktrace: String?
+        if let style = backtraceOptions.style, let allocation, let stack = stacks[allocation.ptr] {
+          currentBacktrace = backtrace(stack, style: style, process.symbolicate)
+        }
 
         return Metadata(ptr: pointer,
-                        allocation: allocations.last(where: { pointer >= $0.ptr && pointer < $0.ptr + swift_reflection_ptr_t($0.size) }),
-                        name: (process.context.name(type: pointer, mangled: genericMetadataOptions.mangled) ?? "<unknown>"),
-                        isArrayOfClass: process.context.isArrayOfClass(pointer))
+                        allocation: allocation,
+                        name: process.context.name(type: pointer, mangled: genericMetadataOptions.mangled) ?? "<unknown>",
+                        isArrayOfClass: process.context.isArrayOfClass(pointer),
+                        garbage: garbage,
+                        backtrace: currentBacktrace)
       }
 
-      let stacks: [swift_reflection_ptr_t:[swift_reflection_ptr_t]]? =
-          backtraceOptions.style == nil
-              ? nil
-              : try process.context.allocationStacks
-
-      var errorneousMetadata: [(ptr: swift_reflection_ptr_t, name: String)] = []
-
-      print("Address", "Allocation", "Size", "Offset", "isArrayOfClass", "Name", separator: "\t")
-      generics.forEach {
-        print("\(hex: $0.ptr)", terminator: "\t")
-        if let allocation = $0.allocation, let offset = $0.offset {
-          print("\(hex: allocation.ptr)\t\(allocation.size)\t\(offset)", terminator: "\t")
-        } else {
-          if (swift_reflection_ownsAddressStrict(process.context, UInt($0.ptr))) == 0 {
-            errorneousMetadata.append((ptr: $0.ptr, name: $0.name))
-          }
-          print("???\t??\t???", terminator: "\t")
-        }
-        print($0.isArrayOfClass, terminator: "\t")
-        print($0.name)
-        if let style = backtraceOptions.style, let allocation = $0.allocation {
-          if let stack = stacks?[allocation.ptr] {
-            print(backtrace(stack, style: style, process.symbolicate))
-          } else {
-            print("  No stacktrace available")
-          }
-        }
+      if let outputFile = genericMetadataOptions.outputJson {
+        try dumpToJson(process: process, generics: generics,
+                       outputPath: outputFile)
+      } else {
+        try dumpToStdout(process: process, generics: generics)
       }
+    }
+  }
 
-      if errorneousMetadata.count > 0 {
-        print("Error: The following metadata was not found in any DATA or AUTH segments, may be garbage.")
-        errorneousMetadata.forEach {
-          print("\(hex: $0.ptr)\t\($0.name)")
+  private func dumpToStdout(process: any RemoteProcess, generics: [Metadata]) throws {
+    var errorneousMetadata: [(ptr: swift_reflection_ptr_t, name: String)] = []
+
+    print("Address", "Allocation", "Size", "Offset", "isArrayOfClass", "Name", separator: "\t")
+    generics.forEach {
+      print("\(hex: $0.ptr)", terminator: "\t")
+      if let allocation = $0.allocation, let offset = $0.offset {
+        print("\(hex: allocation.ptr)\t\(allocation.size)\t\(offset)", terminator: "\t")
+      } else {
+        if $0.garbage {
+          errorneousMetadata.append((ptr: $0.ptr, name: $0.name))
         }
+        print("???\t??\t???", terminator: "\t")
+      }
+      print($0.isArrayOfClass, terminator: "\t")
+      print($0.name)
+      if let _ = backtraceOptions.style, let _ = $0.allocation {
+        print($0.backtrace ?? "  No stacktrace available")
       }
+    }
+
+    if errorneousMetadata.count > 0 {
+      print("Error: The following metadata was not found in any DATA or AUTH segments, may be garbage.")
+      errorneousMetadata.forEach {
+        print("\(hex: $0.ptr)\t\($0.name)")
+      }
+    }
+  }
 
+  private func dumpToJson(process: any RemoteProcess,
+                          generics: [Metadata],
+                          outputPath: String) throws {
+    struct AllMetadataEntries: Encodable {
+      var metadata: [Metadata]
     }
+    let allMetadataEntries = AllMetadataEntries(metadata: generics)
+    let encoder = JSONEncoder()
+    encoder.outputFormatting = .prettyPrinted
+    let data = try encoder.encode(allMetadataEntries)
+    try String(data: data, encoding: .utf8)!
+      .write(toFile: outputPath, atomically: true, encoding: .utf8)
   }
+
 }

tools/swift-inspect/Sources/swift-inspect/RemoteMirror+Extensions.swift

@@ -12,10 +12,21 @@
 
 import SwiftRemoteMirror
 
-extension swift_metadata_allocation_t {
+extension swift_metadata_allocation_t: Encodable {
   internal var tag: swift_metadata_allocation_tag_t { return self.Tag }
   internal var ptr: swift_reflection_ptr_t { return self.Ptr }
   internal var size: Int { return Int(self.Size) }
+  enum CodingKeys: String, CodingKey {
+      case tag
+      case ptr = "address"
+      case size
+  }
+  public func encode(to encoder: Encoder) throws {
+      var container = encoder.container(keyedBy: CodingKeys.self)
+      try container.encode(tag, forKey: .tag)
+      try container.encode(ptr, forKey: .ptr)
+      try container.encode(size, forKey: .size)
+  }
 }
 
 extension swift_metadata_allocation_t: Comparable {

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

@@ -45,6 +45,9 @@ internal struct BacktraceOptions: ParsableArguments {
 internal struct GenericMetadataOptions: ParsableArguments {
   @Flag(help: "Show allocations in mangled form")
   var mangled: Bool = false
+
+  @Option(help: "Path to output JSON file")
+  var outputJson: String? = nil
 }
 
 internal func inspect(options: UniversalOptions,