[swift-inspect] Add a command to dump information about allocated arrays in the target process.

Author: mikeash

include/swift/Demangling/Demangle.h

@@ -243,7 +243,8 @@ class Node {
     return getChild(getNumChildren() - 1);
   }
   NodePointer getChild(size_t index) const {
-    assert(getNumChildren() > index);
+    if (index >= getNumChildren())
+      return nullptr;
     return begin()[index];
   }
 

lib/Demangling/NodePrinter.cpp

@@ -1158,6 +1158,11 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     return nullptr;
   }
 
+  if (!Node) {
+    Printer << "<null node pointer>";
+    return nullptr;
+  }
+
   switch (auto kind = Node->getKind()) {
   case Node::Kind::Static:
     Printer << "static ";

tools/swift-inspect/Sources/SymbolicationShims/SymbolicationShims.h

@@ -21,7 +21,7 @@ struct Range {
   uintptr_t location, length;
 };
 
-uintptr_t GetPtrauthMask(void) {
+static inline uintptr_t GetPtrauthMask(void) {
 #if __has_feature(ptrauth_calls)
   return (uintptr_t)ptrauth_strip((void*)0x0007ffffffffffff, 0);
 #else

tools/swift-inspect/Sources/swift-inspect/Inspector.swift

@@ -35,10 +35,8 @@ class Inspector {
   }
 
   func addReflectionInfoFromLoadedImages(context: SwiftReflectionContextRef) {
-    var numSuccessfulImages = 0
-    CSSymbolicatorForeachSymbolOwnerAtTime(symbolicator, kCSNow, { owner in
+    _ = CSSymbolicatorForeachSymbolOwnerAtTime(symbolicator, kCSNow, { owner in
       let address = CSSymbolOwnerGetBaseAddress(owner);
-      let name = CSSymbolOwnerGetName(owner)
       let _ = swift_reflection_addImage(context, address)
       })
   }
@@ -89,6 +87,25 @@ class Inspector {
             CSSymbolOwnerGetName(CSSymbolGetSymbolOwner(symbol)))
   }
 
+  func enumerateMallocs(callback: (swift_addr_t, UInt64) -> Void) {
+    withoutActuallyEscaping(callback) {
+      withUnsafePointer(to: $0) {
+        task_enumerate_malloc_blocks(task, UnsafeMutableRawPointer(mutating: $0), CUnsignedInt(MALLOC_PTR_IN_USE_RANGE_TYPE), {
+          (task, context, type, ranges, count) in
+          let callback = context!.assumingMemoryBound(to: ((swift_addr_t, UInt64) -> Void).self).pointee
+          for i in 0..<Int(count) {
+            let range = ranges[i]
+            callback(swift_addr_t(range.address), UInt64(range.size))
+          }
+        })
+      }
+    }
+  }
+
+  func read(address: swift_addr_t, size: Int) -> UnsafeRawPointer? {
+    return task_peek(task, address, mach_vm_size_t(size))
+  }
+
   enum Callbacks {
     static let QueryDataLayout: @convention(c)
       (UnsafeMutableRawPointer?,

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

@@ -31,12 +31,15 @@ extension SwiftReflectionContextRef {
     return String(cString: cstr)
   }
 
-  func isAContiguousArrayOfClassElementType(metadata: swift_reflection_ptr_t) ->
+  func isAContiguousArray(metadata: swift_reflection_ptr_t) ->
   Bool {
     guard let name = name(metadata: metadata) else { return false }
-    guard name.starts(with: "Swift._ContiguousArrayStorage") else {
-        return false
-    }
+    return name.starts(with: "Swift._ContiguousArrayStorage")
+  }
+
+  func isAContiguousArrayOfClassElementType(metadata: swift_reflection_ptr_t) ->
+  Bool {
+    guard isAContiguousArray(metadata: metadata) else { return false }
     let tr = swift_reflection_typeRefForMetadata(self, UInt(metadata));
     guard tr != 0 else {
         return false
@@ -54,6 +57,17 @@ extension SwiftReflectionContextRef {
     return typeInfo.Kind == SWIFT_STRONG_REFERENCE
   }
 
+  func arrayCount(
+    array: swift_reflection_ptr_t,
+    reader: (swift_addr_t, Int) -> UnsafeRawPointer?
+  ) -> UInt? {
+    let size = MemoryLayout<UInt>.stride * 3
+    guard let ptr = reader(array, size) else { return nil }
+    let typedPtr = ptr.bindMemory(to: UInt.self, capacity: 3)
+    // Array layout goes: metadata, refcount, count
+    return typedPtr[2]
+  }
+
   func name(proto: swift_reflection_ptr_t) -> String? {
     guard let cstr = swift_reflection_copyDemangledNameForProtocolDescriptor(
       self, proto) else { return nil }

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

@@ -90,6 +90,22 @@ func dumpMetadataCacheNodes(
   }
 }
 
+func dumpArrays(
+  context: SwiftReflectionContextRef,
+  inspector: Inspector
+) throws {
+  print("Address","Size","Count","Is Class", separator: "\t")
+  inspector.enumerateMallocs(callback: { (pointer, size) in
+    let metadata = swift_reflection_ptr_t(swift_reflection_metadataForObject(context, UInt(pointer)))
+    guard metadata != 0 else { return }
+    guard context.isAContiguousArray(metadata: metadata) else { return }
+    let isClass = context.isAContiguousArrayOfClassElementType(metadata: metadata)
+    let count = context.arrayCount(array: pointer, reader: inspector.read)
+    let countStr = count.map({ String($0) }) ?? "<unknown>"
+    print("\(hex: pointer)\t\(size)\t\(countStr)\t\(isClass)")
+  })
+}
+
 func printBacktrace(
   style: Backtrace.Style?,
   for ptr: swift_reflection_ptr_t,
@@ -152,6 +168,7 @@ struct SwiftInspect: ParsableCommand {
       DumpRawMetadata.self,
       DumpGenericMetadata.self,
       DumpCacheNodes.self,
+      DumpArrays.self,
     ])
 }
 
@@ -241,4 +258,18 @@ struct DumpCacheNodes: ParsableCommand {
   }
 }
 
+struct DumpArrays: 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 dumpArrays(context: $0, inspector: $1)
+    }
+  }
+}
+
 SwiftInspect.main()

tools/swift-inspect/Sources/swift-inspect/symbolication.swift

@@ -70,6 +70,14 @@ enum Sym {
   static let task_stop_peeking: @convention(c) (task_t) -> kern_return_t =
     symbol(symbolicationHandle, "task_stop_peeking")
 
+  typealias vm_range_recorder_t =
+    @convention(c) (task_t, UnsafeMutableRawPointer?, CUnsignedInt,
+                    UnsafeMutablePointer<vm_range_t>, CUnsignedInt) -> Void
+  static let task_enumerate_malloc_blocks:
+    @convention(c) (task_t, UnsafeMutableRawPointer?, CUnsignedInt, vm_range_recorder_t)
+      -> Void =
+    symbol(symbolicationHandle, "task_enumerate_malloc_blocks")
+
   static let CSSymbolicatorForeachSymbolOwnerAtTime:
     @convention(c) (CSSymbolicatorRef, CSMachineTime, @convention(block) (CSSymbolOwnerRef) -> Void) -> UInt =
       symbol(coreSymbolicationHandle, "CSSymbolicatorForeachSymbolOwnerAtTime")
@@ -196,3 +204,12 @@ func task_peek_string(
 func task_stop_peeking(_ task: task_t) {
   _ = Sym.task_stop_peeking(task)
 }
+
+func task_enumerate_malloc_blocks(
+  _ task: task_t,
+  _ context: UnsafeMutableRawPointer?,
+  _ type_mask: CUnsignedInt,
+  _ recorder: Sym.vm_range_recorder_t
+) {
+  Sym.task_enumerate_malloc_blocks(task, context, type_mask, recorder)
+}