Merge pull request #39948 from aschwaighofer/swift-inspect-reflection-metadata

swift-inspect: load reflection metadata and use it to print whether array metadata is of a class element type

Author: aschwaighofer

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

@@ -34,6 +34,15 @@ class Inspector {
     mach_port_deallocate(mach_task_self_, task)
   }
 
+  func addReflectionInfoFromLoadedImages(context: SwiftReflectionContextRef) {
+    var numSuccessfulImages = 0
+    CSSymbolicatorForeachSymbolOwnerAtTime(symbolicator, kCSNow, { owner in
+      let address = CSSymbolOwnerGetBaseAddress(owner);
+      let name = CSSymbolOwnerGetName(owner)
+      let _ = swift_reflection_addImage(context, address)
+      })
+  }
+
   static func findTask(_ pid: pid_t, tryForkCorpse: Bool) -> task_t {
     var task = task_t()
     var kr = task_for_pid(mach_task_self_, pid, &task)

tools/swift-inspect/Sources/swift-inspect/Metadata.swift

@@ -35,7 +35,8 @@ extension Allocation {
     let ptr = context.metadataPointer(allocation: allocation_t)
     if ptr != 0 {
       let name = context.name(metadata: ptr) ?? "<unknown>"
-      return .init(ptr: ptr, name: name)
+      let isClass = context.isAContiguousArrayOfClassElementType(metadata: ptr)
+      return .init(ptr: ptr, name: name, isArrayOfClass: isClass)
     } else {
       return nil
     }
@@ -59,6 +60,7 @@ struct Metadata {
   let ptr: swift_reflection_ptr_t
   var allocation: Allocation? = nil
   let name: String
+  let isArrayOfClass: Bool
 
   var offset: Int? { allocation.map { Int(self.ptr - $0.ptr) } }
 }

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

@@ -31,6 +31,29 @@ extension SwiftReflectionContextRef {
     return String(cString: cstr)
   }
 
+  func isAContiguousArrayOfClassElementType(metadata: swift_reflection_ptr_t) ->
+  Bool {
+    guard let name = name(metadata: metadata) else { return false }
+    guard name.starts(with: "Swift._ContiguousArrayStorage") else {
+        return false
+    }
+    let tr = swift_reflection_typeRefForMetadata(self, UInt(metadata));
+    guard tr != 0 else {
+        return false
+    }
+    let genericArgCnt = swift_reflection_genericArgumentCountOfTypeRef(tr);
+    guard genericArgCnt == 1 else {
+        return false
+    }
+
+    let argTr = swift_reflection_genericArgumentOfTypeRef(tr, 0)
+    guard argTr != 0 else {
+        return false
+    }
+    let typeInfo = swift_reflection_infoForTypeRef(self, argTr)
+    return typeInfo.Kind == SWIFT_STRONG_REFERENCE
+  }
+
   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

@@ -56,7 +56,7 @@ func dumpGenericMetadata(
   let metadatas = allocations.findGenericMetadata(in: context)
   let backtraces = backtraceStyle != nil ? context.allocationBacktraces : [:]
 
-  print("Address","Allocation","Size","Offset","Name", separator: "\t")
+  print("Address","Allocation","Size","Offset","isArrayOfClass", "Name", separator: "\t")
   for metadata in metadatas {
     print("\(hex: metadata.ptr)", terminator: "\t")
 
@@ -66,6 +66,7 @@ func dumpGenericMetadata(
     } else {
       print("???\t???\t???", terminator: "\t")
     }
+    print(metadata.isArrayOfClass, terminator: "\t")
     print(metadata.name)
     if let allocation = metadata.allocation {
       printBacktrace(style: backtraceStyle, for: allocation.ptr, in: backtraces, inspector: inspector)
@@ -126,6 +127,8 @@ func makeReflectionContext(
     argFail("Failed to create reflection context")
   }
 
+  inspector.addReflectionInfoFromLoadedImages(context: reflectionContext)
+
   return (inspector, reflectionContext)
 }
 

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

@@ -69,6 +69,13 @@ enum Sym {
     symbol(symbolicationHandle, "task_peek_string")
   static let task_stop_peeking: @convention(c) (task_t) -> kern_return_t =
     symbol(symbolicationHandle, "task_stop_peeking")
+
+  static let CSSymbolicatorForeachSymbolOwnerAtTime:
+    @convention(c) (CSSymbolicatorRef, CSMachineTime, @convention(block) (CSSymbolOwnerRef) -> Void) -> UInt =
+      symbol(coreSymbolicationHandle, "CSSymbolicatorForeachSymbolOwnerAtTime")
+
+  static let CSSymbolOwnerGetBaseAddress: @convention(c) (CSSymbolOwnerRef) -> mach_vm_address_t =
+    symbol(symbolicationHandle, "CSSymbolOwnerGetBaseAddress")
 }
 
 typealias CSMachineTime = UInt64
@@ -145,6 +152,19 @@ func CSSymbolicatorGetSymbolWithAddressAtTime(
   Sym.CSSymbolicatorGetSymbolWithAddressAtTime(symbolicator, address, time)
 }
 
+func CSSymbolicatorForeachSymbolOwnerAtTime(
+  _ symbolicator: CSSymbolicatorRef,
+  _ time: CSMachineTime,
+  _ symbolIterator: (CSSymbolOwnerRef) -> Void
+  ) ->  UInt {
+      return Sym.CSSymbolicatorForeachSymbolOwnerAtTime(symbolicator, time,
+                                                        symbolIterator)
+}
+
+func CSSymbolOwnerGetBaseAddress(_ symbolOwner: CSSymbolOwnerRef) -> mach_vm_address_t {
+    return Sym.CSSymbolOwnerGetBaseAddress(symbolOwner)
+}
+
 func task_start_peeking(_ task: task_t) -> Bool {
   let result = Sym.task_start_peeking(task)
   if result == KERN_SUCCESS {