Handle more host commands, up to qWasmCallStack

Author: MaxDesiatov

Sources/GDBRemoteProtocol/GDBHostCommand.swift

@@ -23,6 +23,11 @@ package struct GDBHostCommand: Equatable {
         case subsequentThreadInfo
         case targetStatus
         case registerInfo
+        case structuredDataPlugins
+        case transfer
+        case readMemoryBinaryData
+        case readMemory
+        case wasmCallStack
 
         case generalRegisters
 
@@ -56,6 +61,12 @@ package struct GDBHostCommand: Equatable {
                 self = .subsequentThreadInfo
             case "?":
                 self = .targetStatus
+            case "qStructuredDataPlugins":
+                self = .structuredDataPlugins
+            case "qXfer":
+                self = .transfer
+            case "qWasmCallStack":
+                self = .wasmCallStack
 
             default:
                 return nil
@@ -69,7 +80,16 @@ package struct GDBHostCommand: Equatable {
 
     package init(kindString: String, arguments: String) throws {
         let registerInfoPrefix = "qRegisterInfo"
-        if kindString.starts(with: registerInfoPrefix) {
+
+        if kindString.starts(with: "x") {
+           self.kind = .readMemoryBinaryData
+           self.arguments = String(kindString.dropFirst())
+           return
+        } else if kindString.starts(with: "m") {
+           self.kind = .readMemory
+           self.arguments = String(kindString.dropFirst())
+           return
+        } else if kindString.starts(with: registerInfoPrefix) {
             self.kind = .registerInfo
 
             guard arguments.isEmpty else {

Sources/WasmKitGDBHandler/WasmKitDebugger.swift

@@ -5,30 +5,35 @@ import SystemPackage
 import WasmKit
 
 package actor WasmKitDebugger {
+    enum Error: Swift.Error {
+        case unknownTransferArguments
+    }
+
     private let module: Module
+    private let moduleFilePath: FilePath
     private let logger: Logger
 
     package init(logger: Logger, moduleFilePath: FilePath) throws {
         self.logger = logger
         self.module = try parseWasm(filePath: moduleFilePath)
+        self.moduleFilePath = moduleFilePath
     }
 
-    package func handle(command: GDBHostCommand) -> GDBTargetResponse {
+    package func handle(command: GDBHostCommand) throws -> GDBTargetResponse {
         let responseKind: GDBTargetResponse.Kind
         logger.trace("handling GDB host command", metadata: ["GDBHostCommand": .string(command.kind.rawValue)])
 
         var isNoAckModeActivated = false
-        responseKind =
             switch command.kind {
             case .startNoAckMode:
                 isNoAckModeActivated = true
                 fallthrough
 
             case .isThreadSuffixSupported, .listThreadsInStopReply:
-                .ok
+                responseKind = .ok
 
             case .hostInfo:
-                .keyValuePairs([
+                responseKind = .keyValuePairs([
                     "arch": "wasm32",
                     "ptrsize": "4",
                     "endian": "little",
@@ -37,15 +42,16 @@ package actor WasmKitDebugger {
                 ])
 
             case .supportedFeatures:
-                .raw("qXfer:libraries:read+;PacketSize=1000;")
+                responseKind = .raw("qXfer:libraries:read+;PacketSize=1000;")
 
             case .vContSupportedActions:
-                .vContSupportedActions([.continue, .step])
+                responseKind = .vContSupportedActions([.continue, .step])
+
+            case .isVAttachOrWaitSupported, .enableErrorStrings, .structuredDataPlugins, .readMemoryBinaryData:
+                responseKind = .empty
 
-            case .isVAttachOrWaitSupported, .enableErrorStrings:
-                .empty
             case .processInfo:
-                .keyValuePairs([
+                responseKind = .keyValuePairs([
                     "pid": "1",
                     "parent-pid": "1",
                     "arch": "wasm32",
@@ -54,23 +60,23 @@ package actor WasmKitDebugger {
                 ])
 
             case .currentThreadID:
-                .raw("QC1")
+                responseKind = .raw("QC1")
 
             case .firstThreadInfo:
-                .raw("m1")
+                responseKind = .raw("m1")
 
             case .subsequentThreadInfo:
-                .raw("l")
+                responseKind = .raw("l")
 
             case .targetStatus:
-                .keyValuePairs([
+                responseKind = .keyValuePairs([
                     "T05thread": "1",
                     "reason": "trace",
                 ])
 
             case .registerInfo:
                 if command.arguments == "0" {
-                    .keyValuePairs([
+                    responseKind = .keyValuePairs([
                         "name": "pc",
                         "bitsize": "64",
                         "offset": "0",
@@ -82,10 +88,24 @@ package actor WasmKitDebugger {
                         "generic": "pc",
                     ])
                 } else {
-                    .raw("E45")
+                    responseKind = .raw("E45")
                 }
 
-            case .generalRegisters:
+            case .transfer:
+                if command.arguments.starts(with: "libraries:read:") {
+                    responseKind = .raw("""
+                    l<library-list>
+                        <library name="\(self.moduleFilePath.string)"><section address="0x4000000000000000"/></library>
+                    </library-list>
+                    """)
+                } else {
+                    throw Error.unknownTransferArguments
+                }
+
+            case .readMemory:
+                responseKind = .empty
+
+            case .wasmCallStack, .generalRegisters:
                 fatalError()
             }