Implement .readMemory command handling

Author: MaxDesiatov

[email protected]

@@ -134,9 +134,11 @@ let package = Package(
         .target(
             name: "WasmKitGDBHandler",
             dependencies: [
+                .product(name: "_NIOFileSystem", package: "swift-nio"),
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "SystemPackage", package: "swift-system"),
                 "WasmKit",
+                "WasmKitWASI",
                 "GDBRemoteProtocol",
             ],
         ),

Sources/GDBRemoteProtocol/GDBTargetResponse.swift

@@ -1,3 +1,5 @@
+import NIOCore
+
 /// Actions supported in the `vCont` host command.
 package enum VContActions: String {
     case `continue` = "c"
@@ -13,7 +15,8 @@ package struct GDBTargetResponse {
         case ok
         case keyValuePairs(KeyValuePairs<String, String>)
         case vContSupportedActions([VContActions])
-        case raw(String)
+        case string(String)
+        case hexEncodedBinary(ByteBufferView)
         case empty
     }
 

Sources/GDBRemoteProtocol/GDBTargetResponseEncoder.swift

@@ -30,9 +30,13 @@ package class GDBTargetResponseEncoder: MessageToByteEncoder {
         case .vContSupportedActions(let actions):
             out.writeString("vCont;\(actions.map { "\($0.rawValue);" }.joined())".appendedChecksum)
 
-        case .raw(let str):
+        case .string(let str):
             out.writeString(str.appendedChecksum)
 
+        case .hexEncodedBinary(let binary):
+            let hexDump = ByteBuffer(bytes: binary).hexDump(format: .compact)
+            out.writeString(hexDump.appendedChecksum)
+
         case .empty:
             out.writeString("".appendedChecksum)
         }

Sources/WasmKitGDBHandler/WasmKitDebugger.swift renamed to Sources/WasmKitGDBHandler/WasmKitGDBHandler.swift

@@ -1,27 +1,61 @@
 import GDBRemoteProtocol
 import Logging
+import NIOCore
+import NIOFileSystem
 import Synchronization
 import SystemPackage
 import WasmKit
+import WasmKitWASI
+
+extension BinaryInteger {
+    init?(hexEncoded: Substring) {
+        var result = Self.zero
+        for (offset, element) in hexEncoded.reversed().enumerated() {
+            guard let digit = element.hexDigitValue else { return nil }
+            result += Self(digit) << (offset * 4)
+        }
+
+        self = result
+    }
+}
 
 package actor WasmKitGDBHandler {
     enum Error: Swift.Error {
         case unknownTransferArguments
+        case unknownReadMemoryArguments
+        case entrypointFunctionNotFound
     }
 
+    private let wasmBinary: ByteBuffer
     private let module: Module
     private let moduleFilePath: FilePath
     private let logger: Logger
     private let debuggerExecution: DebuggerExecution
     private let instance: Instance
+    private let entrypointFunction: Function
+    private let functionsRLE: [(wasmAddress: Int, iSeqAddress: Int)] = []
 
-    package init(logger: Logger, moduleFilePath: FilePath) throws {
+    package init(logger: Logger, moduleFilePath: FilePath) async throws {
         self.logger = logger
-        self.module = try parseWasm(filePath: moduleFilePath)
+
+        self.wasmBinary = try await FileSystem.shared.withFileHandle(forReadingAt: moduleFilePath) {
+            try await $0.readToEnd(maximumSizeAllowed: .unlimited)
+        }
+
+        self.module = try parseWasm(bytes: .init(buffer: self.wasmBinary))
         self.moduleFilePath = moduleFilePath
         let store = Store(engine: Engine())
         self.debuggerExecution = DebuggerExecution(store: store)
-        self.instance = try module.instantiate(store: store)
+
+        var imports = Imports()
+        let wasi = try WASIBridgeToHost()
+        wasi.link(to: &imports, store: store)
+        self.instance = try module.instantiate(store: store, imports: imports)
+
+        guard case .function(let entrypointFunction) = self.instance.exports["_start"] else {
+            throw Error.entrypointFunctionNotFound
+        }
+        self.entrypointFunction = entrypointFunction
     }
 
     package func handle(command: GDBHostCommand) throws -> GDBTargetResponse {
@@ -47,7 +81,7 @@ package actor WasmKitGDBHandler {
             ])
 
         case .supportedFeatures:
-            responseKind = .raw("qXfer:libraries:read+;PacketSize=1000;")
+            responseKind = .string("qXfer:libraries:read+;PacketSize=1000;")
 
         case .vContSupportedActions:
             responseKind = .vContSupportedActions([.continue, .step])
@@ -65,13 +99,13 @@ package actor WasmKitGDBHandler {
             ])
 
         case .currentThreadID:
-            responseKind = .raw("QC1")
+            responseKind = .string("QC1")
 
         case .firstThreadInfo:
-            responseKind = .raw("m1")
+            responseKind = .string("m1")
 
         case .subsequentThreadInfo:
-            responseKind = .raw("l")
+            responseKind = .string("l")
 
         case .targetStatus:
             responseKind = .keyValuePairs([
@@ -93,12 +127,12 @@ package actor WasmKitGDBHandler {
                     "generic": "pc",
                 ])
             } else {
-                responseKind = .raw("E45")
+                responseKind = .string("E45")
             }
 
         case .transfer:
             if command.arguments.starts(with: "libraries:read:") {
-                responseKind = .raw(
+                responseKind = .string(
                     """
                     l<library-list>
                         <library name="\(self.moduleFilePath.string)"><section address="0x4000000000000000"/></library>
@@ -109,7 +143,20 @@ package actor WasmKitGDBHandler {
             }
 
         case .readMemory:
-            responseKind = .empty
+            let argumentsArray = command.arguments.split(separator: ",")
+            guard
+                argumentsArray.count == 2,
+                let address = UInt64(hexEncoded: argumentsArray[0]),
+                var length = Int(hexEncoded: argumentsArray[1])
+            else { throw Error.unknownReadMemoryArguments }
+
+            let binaryOffset = Int(address - 0x4000000000000000)
+
+            if binaryOffset + length > wasmBinary.readableBytes {
+                length = wasmBinary.readableBytes - binaryOffset
+            }
+
+            responseKind = .hexEncodedBinary(wasmBinary.readableBytesView[binaryOffset..<(binaryOffset + length)])
 
         case .wasmCallStack:
             print(self.debuggerExecution.captureBacktrace())

Sources/wasmkit-gdb-tool/Entrypoint.swift

@@ -81,7 +81,7 @@ struct Entrypoint: AsyncParsableCommand {
             /* the server will now be accepting connections */
             logger.info("listening on port \(port)")
 
-            let debugger = try WasmKitGDBHandler(logger: logger, moduleFilePath: self.wasmModulePath)
+            let debugger = try await WasmKitGDBHandler(logger: logger, moduleFilePath: self.wasmModulePath)
 
             try await withThrowingDiscardingTaskGroup { group in
                 try await serverChannel.executeThenClose { serverChannelInbound in