swift-inspect: enable dump-arrays on Windows

Hoist `iterateHeaps` into the `RemoteProcess` protocol, requiring an
implementation on all platforms.  If the platform is unable to implement
heap traversal, it would be possible to simply leave the callback
uncalled.

Be more careful about memory queries, we may receive invalid memory
addresses.

Author: compnerd

tools/swift-inspect/README.md

@@ -22,6 +22,9 @@ The following inspection operations are available currently.
 
 ##### All Platforms
 
+dump-arrays <name-or-pid>
+: Print information about array objects in the target
+
 dump-cache-nodes <name-or-pid>
 : Print the metadata cache nodes.
 
@@ -36,8 +39,5 @@ dump-raw-metadata <name-or-pid> [--backtrace] [--backtrace-long]
 
 ##### Darwin Only
 
-dump-arrays <name-or-pid>
-: Print information about array objects in the target
-
 dump-concurrency <name-or-pid>
-: Print information about tasks, actors, and threads under Concurrency.
+: Print information about tasks, actors, and threads under Concurrency.

tools/swift-inspect/Sources/swift-inspect/DarwinRemoteProcess.swift

@@ -141,9 +141,7 @@ internal final class DarwinRemoteProcess: RemoteProcess {
     let module = CSSymbolGetSymbolOwner(symbol)
     return (CSSymbolOwnerGetName(module), CSSymbolGetName(symbol))
   }
-}
 
-extension DarwinRemoteProcess {
   internal func iterateHeap(_ body: (swift_addr_t, UInt64) -> Void) {
     withoutActuallyEscaping(body) {
       withUnsafePointer(to: $0) {
@@ -160,7 +158,9 @@ extension DarwinRemoteProcess {
       }
     }
   }
+}
 
+extension DarwinRemoteProcess {
   internal var currentTasks: [(threadID: UInt64, currentTask: swift_addr_t)] {
     var threadList: UnsafeMutablePointer<thread_t>?
     var threadCount: mach_msg_type_number_t = 0

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

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if os(iOS) || os(macOS) || os(tvOS) || os(watchOS)
 import ArgumentParser
 import SwiftRemoteMirror
 
@@ -28,6 +27,7 @@ internal struct DumpArrays: ParsableCommand {
         let metadata: UInt =
             swift_reflection_metadataForObject(process.context, UInt(allocation))
         if metadata == 0 { return }
+
         guard process.context.isContiguousArray(swift_reflection_ptr_t(metadata)) else {
           return
         }
@@ -44,5 +44,3 @@ internal struct DumpArrays: ParsableCommand {
     }
   }
 }
-
-#endif

tools/swift-inspect/Sources/swift-inspect/RemoteProcess.swift

@@ -42,6 +42,7 @@ internal protocol RemoteProcess: AnyObject {
   static var GetSymbolAddress: GetSymbolAddressFunction { get }
 
   func symbolicate(_ address: swift_addr_t) -> (module: String?, symbol: String?)
+  func iterateHeap(_ body: (swift_addr_t, UInt64) -> Void)
 }
 
 extension RemoteProcess {

tools/swift-inspect/Sources/swift-inspect/WindowsRemoteProcess.swift

@@ -79,11 +79,13 @@ internal final class WindowsRemoteProcess: RemoteProcess {
 
       var information: WIN32_MEMORY_REGION_INFORMATION =
           WIN32_MEMORY_REGION_INFORMATION()
-      _ = QueryVirtualMemoryInformation(process.process,
+      if !QueryVirtualMemoryInformation(process.process,
                                         LPVOID(bitPattern: UInt(address)),
                                         MemoryRegionInfo, &information,
                                         SIZE_T(MemoryLayout.size(ofValue: information)),
-                                        nil)
+                                        nil) {
+        return 0
+      }
 
       // FIXME(compnerd) mapping in the memory region from the remote process
       // would be ideal to avoid a round-trip for each byte.  This seems to work
@@ -123,7 +125,7 @@ internal final class WindowsRemoteProcess: RemoteProcess {
   }
 
   init?(processId: ProcessIdentifier) {
-    // Setup process handle.
+    // Get process handle.
     self.process =
         OpenProcess(DWORD(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ), false,
                     processId)
@@ -223,6 +225,46 @@ internal final class WindowsRemoteProcess: RemoteProcess {
 
     return (context.1, symbol)
   }
+
+  internal func iterateHeap(_ body: (swift_addr_t, UInt64) -> Void) {
+    let dwProcessId: DWORD = GetProcessId(self.process)
+    if dwProcessId == 0 {
+      // FIXME(compnerd) log error
+      return
+    }
+
+    let hSnapshot: HANDLE =
+        CreateToolhelp32Snapshot(DWORD(TH32CS_SNAPHEAPLIST), dwProcessId)
+    if hSnapshot == INVALID_HANDLE_VALUE {
+      // FIXME(compnerd) log error
+      return
+    }
+    defer { CloseHandle(hSnapshot) }
+
+    var heap: HEAPLIST32 = HEAPLIST32()
+    heap.dwSize = SIZE_T(MemoryLayout<HEAPLIST32>.size)
+    if !Heap32ListFirst(hSnapshot, &heap) {
+      // FIXME(compnerd) log error
+      return
+    }
+
+    repeat {
+      var entry: HEAPENTRY32 = HEAPENTRY32()
+      entry.dwSize = SIZE_T(MemoryLayout<HEAPENTRY32>.size)
+
+      if !Heap32First(&entry, dwProcessId, heap.th32HeapID) {
+        // FIXME(compnerd) log error
+        continue
+      }
+
+      repeat {
+        if entry.dwFlags & DWORD(LF32_FREE) == DWORD(LF32_FREE) { continue }
+        body(swift_addr_t(entry.dwAddress), UInt64(entry.dwBlockSize))
+      } while Heap32Next(&entry)
+
+      heap.dwSize = SIZE_T(MemoryLayout<HEAPLIST32>.size)
+    } while Heap32ListNext(hSnapshot, &heap)
+  }
 }
 
 #endif

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

@@ -77,6 +77,7 @@ internal struct SwiftInspect: ParsableCommand {
     DumpRawMetadata.self,
     DumpGenericMetadata.self,
     DumpCacheNodes.self,
+    DumpArrays.self,
   ]
 #endif