Add DebuggerExecution wrapper type

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugging.swift

@@ -0,0 +1,21 @@
+package struct DebuggerExecution: ~Copyable {
+    let valueStack: Sp
+    let execution: Execution
+    let store: Store
+
+    package init(store: Store) {
+        let limit = store.engine.configuration.stackSize / MemoryLayout<StackSlot>.stride
+        self.valueStack = UnsafeMutablePointer<StackSlot>.allocate(capacity: limit)
+        self.store = store
+        self.execution = Execution(store: StoreRef(store), stackEnd: valueStack.advanced(by: limit))
+    }
+
+    package func captureBacktrace() -> Backtrace {
+            return Execution.captureBacktrace(sp: self.valueStack, store: self.store)
+    }
+
+    deinit {
+        valueStack.deallocate()
+    }
+}
+

Sources/WasmKit/Execution/Errors.swift

@@ -3,9 +3,9 @@ import WasmTypes
 import struct WasmParser.Import
 
 /// The backtrace of the trap.
-struct Backtrace: CustomStringConvertible, Sendable {
+package struct Backtrace: CustomStringConvertible, Sendable {
     /// A symbol in the backtrace.
-    struct Symbol {
+    package struct Symbol {
         /// The name of the symbol.
         let name: String?
         let debuggingAddress: DebuggingAddress
@@ -31,8 +31,9 @@ struct Backtrace: CustomStringConvertible, Sendable {
     let symbols: [Symbol]
 
     /// Textual description of the backtrace.
-    var description: String {
-        symbols.enumerated().map { (index, symbol) in
+    package var description: String {
+        print("backtrace contains \(symbols.count) symbols")
+        return symbols.enumerated().map { (index, symbol) in
             let name = symbol.name ?? "unknown"
             return "    \(index): (\(symbol.debuggingAddress)) \(name)"
         }.joined(separator: "\n")

Sources/WasmKit/Execution/Execution.swift

@@ -4,7 +4,7 @@ import _CWasmKit
 ///
 /// Each new invocation through exported function has a separate ``Execution``
 /// even though the invocation happens during another invocation.
-struct Execution {
+struct Execution: ~Copyable {
     /// The reference to the ``Store`` associated with the execution.
     let store: StoreRef
     /// The end of the VM stack space.
@@ -14,6 +14,11 @@ struct Execution {
     /// - Note: If the trap is set, it must be released manually.
     private var trap: (error: UnsafeRawPointer, sp: Sp)? = nil
 
+    package init(store: StoreRef, stackEnd: UnsafeMutablePointer<StackSlot>) {
+        self.store = store
+        self.stackEnd = stackEnd
+    }
+
     /// Executes the given closure with a new execution state associated with
     /// the given ``Store`` instance.
     static func with<T>(

Sources/WasmKitGDBHandler/WasmKitDebugger.swift

@@ -4,19 +4,24 @@ import Synchronization
 import SystemPackage
 import WasmKit
 
-package actor WasmKitDebugger {
+package actor WasmKitGDBHandler {
     enum Error: Swift.Error {
         case unknownTransferArguments
     }
 
     private let module: Module
     private let moduleFilePath: FilePath
     private let logger: Logger
+    private let debuggerExecution: DebuggerExecution
+    private let instance: Instance
 
     package init(logger: Logger, moduleFilePath: FilePath) throws {
         self.logger = logger
         self.module = try parseWasm(filePath: moduleFilePath)
         self.moduleFilePath = moduleFilePath
+        let store = Store(engine: Engine())
+        self.debuggerExecution = DebuggerExecution(store: store)
+        self.instance = try module.instantiate(store: store)
     }
 
     package func handle(command: GDBHostCommand) throws -> GDBTargetResponse {
@@ -106,7 +111,11 @@ package actor WasmKitDebugger {
         case .readMemory:
             responseKind = .empty
 
-        case .wasmCallStack, .generalRegisters:
+        case .wasmCallStack:
+            print(self.debuggerExecution.captureBacktrace())
+            responseKind = .empty
+
+        case .generalRegisters:
             fatalError()
         }
 

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 WasmKitDebugger(logger: logger, moduleFilePath: self.wasmModulePath)
+            let debugger = try WasmKitGDBHandler(logger: logger, moduleFilePath: self.wasmModulePath)
 
             try await withThrowingDiscardingTaskGroup { group in
                 try await serverChannel.executeThenClose { serverChannelInbound in