Add iSeqToWasmMapping to InstanceEntity

Author: MaxDesiatov

Sources/GDBRemoteProtocol/GDBTargetResponseEncoder.swift

@@ -19,7 +19,7 @@ package struct GDBTargetResponseEncoder: MessageToByteEncoder {
         case .ok:
             out.writeBytes("ok#da".utf8)
 
-        case .hostInfo(let info):
+        case .keyValuePairs(let info):
             out.writeBytes(info.map { (key, value) in "\(key):\(value);" }.joined().appendedChecksum)
 
         case .vContSupportedActions(let actions):

Sources/WasmKit/Execution/Errors.swift

@@ -8,16 +8,30 @@ struct Backtrace: CustomStringConvertible, Sendable {
     struct Symbol {
         /// The name of the symbol.
         let name: String?
+        let debuggingAddress: DebuggingAddress
+
+        /// Address of the symbol for debugging purposes.
+        enum DebuggingAddress: CustomStringConvertible, @unchecked Sendable {
+            case iseq(Pc)
+            case wasm(UInt64)
+
+            var description: String {
+                switch self {
+                    case .iseq(let pc): "iseq(\(Int(bitPattern: pc)))"
+                    case .wasm(let wasmAddress): "wasm(\(wasmAddress))"
+                }
+            }
+        }
     }
 
     /// The symbols in the backtrace.
-    let symbols: [Symbol?]
+    let symbols: [Symbol]
 
     /// Textual description of the backtrace.
     var description: String {
         symbols.enumerated().map { (index, symbol) in
-            let name = symbol?.name ?? "unknown"
-            return "    \(index): \(name)"
+            let name = symbol.name ?? "unknown"
+            return "    \(symbol.debuggingAddress): \(name)"
         }.joined(separator: "\n")
     }
 }

Sources/WasmKit/Execution/Execution.swift

@@ -61,18 +61,14 @@ struct Execution {
 
     static func captureBacktrace(sp: Sp, store: Store) -> Backtrace {
         var frames = FrameIterator(sp: sp)
-        var symbols: [Backtrace.Symbol?] = []
+        var symbols: [Backtrace.Symbol] = []
         while let frame = frames.next() {
             guard let function = frame.function else {
-                symbols.append(nil)
+                symbols.append(.init(name: nil, debuggingAddress: .iseq(frame.pc)))
                 continue
             }
             let symbolName = store.nameRegistry.symbolicate(.wasm(function))
-            symbols.append(
-                Backtrace.Symbol(
-                    name: symbolName
-                )
-            )
+            symbols.append(.init(name: symbolName, debuggingAddress: .iseq(frame.pc)))
         }
         return Backtrace(symbols: symbols)
     }

Sources/WasmKit/Execution/Function.swift

@@ -243,7 +243,7 @@ struct WasmFunctionEntity {
         switch code {
         case .uncompiled(let code):
             return try compile(store: store, code: code)
-        case .compiled(let iseq), .compiledAndPatchable(_, let iseq):
+        case .compiled(let iseq), .debuggable(_, let iseq):
             return iseq
         }
     }
@@ -280,10 +280,14 @@ extension EntityHandle<WasmFunctionEntity> {
         case .uncompiled(let code):
             return try self.withValue {
                 let iseq = try $0.compile(store: store, code: code)
-                $0.code = .compiled(iseq)
+                if $0.instance.isDebuggable {
+                    $0.code = .debuggable(code, iseq)
+                } else {
+                    $0.code = .compiled(iseq)
+                }
                 return iseq
             }
-        case .compiled(let iseq), .compiledAndPatchable(_, let iseq):
+        case .compiled(let iseq), .debuggable(_, let iseq):
             return iseq
         }
     }
@@ -316,7 +320,7 @@ struct InstructionSequence {
 enum CodeBody {
     case uncompiled(InternalUncompiledCode)
     case compiled(InstructionSequence)
-    case compiledAndPatchable(InternalUncompiledCode, InstructionSequence)
+    case debuggable(InternalUncompiledCode, InstructionSequence)
 }
 
 extension Reference {

Sources/WasmKit/Execution/Instances.swift

@@ -83,6 +83,8 @@ struct InstanceEntity /* : ~Copyable */ {
     var functionRefs: Set<InternalFunction>
     var features: WasmFeatureSet
     var dataCount: UInt32?
+    var isDebuggable: Bool
+    var iSeqToWasmMapping: [Pc: UInt64]
 
     static var empty: InstanceEntity {
         InstanceEntity(
@@ -96,7 +98,9 @@ struct InstanceEntity /* : ~Copyable */ {
             exports: [:],
             functionRefs: [],
             features: [],
-            dataCount: nil
+            dataCount: nil,
+            isDebuggable: false,
+            iSeqToWasmMapping: [:]
         )
     }
 

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -251,7 +251,8 @@ extension StoreAllocator {
         module: Module,
         engine: Engine,
         resourceLimiter: any ResourceLimiter,
-        imports: Imports
+        imports: Imports,
+        isDebuggable: Bool
     ) throws -> InternalInstance {
         // Step 1 of module allocation algorithm, according to Wasm 2.0 spec.
 
@@ -450,7 +451,9 @@ extension StoreAllocator {
             exports: exports,
             functionRefs: functionRefs,
             features: module.features,
-            dataCount: module.dataCount
+            dataCount: module.dataCount,
+            isDebuggable: isDebuggable,
+            iSeqToWasmMapping: [:]
         )
         instancePointer.initialize(to: instanceEntity)
         instanceInitialized = true

Sources/WasmKit/Module.swift

@@ -138,9 +138,21 @@ public struct Module {
         Instance(handle: try self.instantiateHandle(store: store, imports: imports), store: store)
     }
 
+#if WasmDebuggingSupport
+    /// Instantiate this module in the given imports.
+    ///
+    /// - Parameters:
+    ///   - store: The ``Store`` to allocate the instance in.
+    ///   - imports: The imports to use for instantiation. All imported entities
+    ///     must be allocated in the given store.
+    public func instantiate(store: Store, imports: Imports = [:], isDebuggable: Bool) throws -> Instance {
+        Instance(handle: try self.instantiateHandle(store: store, imports: imports, isDebuggable: isDebuggable), store: store)
+    }
+#endif
+
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/modules.html#instantiation>
-    private func instantiateHandle(store: Store, imports: Imports) throws -> InternalInstance {
+    private func instantiateHandle(store: Store, imports: Imports, isDebuggable: Bool = false) throws -> InternalInstance {
         try ModuleValidator(module: self).validate()
 
         // Steps 5-8.
@@ -152,7 +164,8 @@ public struct Module {
         let instance = try store.allocator.allocate(
             module: self, engine: store.engine,
             resourceLimiter: store.resourceLimiter,
-            imports: imports
+            imports: imports,
+            isDebuggable: isDebuggable
         )
 
         if let nameSection = customSections.first(where: { $0.name == "name" }) {

Sources/WasmKit/Translator.swift

@@ -822,8 +822,6 @@ struct InstructionTranslator: InstructionVisitor {
     let functionIndex: FunctionIndex
     /// Whether a call to this function should be intercepted
     let isIntercepting: Bool
-    /// Whether Wasm debugging facilities are currently enabled.
-    let isDebugging: Bool
     var constantSlots: ConstSlots
     let validator: InstructionValidator
 
@@ -836,8 +834,7 @@ struct InstructionTranslator: InstructionVisitor {
         locals: [WasmTypes.ValueType],
         functionIndex: FunctionIndex,
         codeSize: Int,
-        isIntercepting: Bool,
-        isDebugging: Bool = false
+        isIntercepting: Bool
     ) throws {
         self.allocator = allocator
         self.funcTypeInterner = funcTypeInterner
@@ -854,7 +851,6 @@ struct InstructionTranslator: InstructionVisitor {
         self.locals = Locals(types: type.parameters + locals)
         self.functionIndex = functionIndex
         self.isIntercepting = isIntercepting
-        self.isDebugging = isDebugging
         self.constantSlots = ConstSlots(stackLayout: stackLayout)
         self.validator = InstructionValidator(context: module)
 
@@ -2262,7 +2258,7 @@ struct InstructionTranslator: InstructionVisitor {
     }
 
     mutating func visitUnknown(_ opcode: [UInt8]) throws -> Bool {
-        guard self.isDebugging && opcode.count == 1 && opcode[0] == 0xFF else {
+        guard self.module.isDebuggable && opcode.count == 1 && opcode[0] == 0xFF else {
             return false
         }
 

Tests/GDBRemoteProtocolTests/RemoteProtocolTests.swift

@@ -1,12 +1,15 @@
 import GDBRemoteProtocol
+import Logging
 import NIOCore
 import Testing
 
 @Suite
 struct LLDBRemoteProtocolTests {
     @Test
     func decoding() throws {
-        var decoder = GDBHostCommandDecoder()
+        var logger = Logger(label: "com.swiftwasm.WasmKit.tests")
+        logger.logLevel = .critical
+        var decoder = GDBHostCommandDecoder(logger: logger)
 
         var buffer = ByteBuffer(string: "+$g#67")
         var packet = try decoder.decode(buffer: &buffer)

Tests/WasmKitTests/ExecutionTests.swift

@@ -111,7 +111,7 @@
                 """
             ) { trap in
                 #expect(
-                    trap.backtrace?.symbols.compactMap(\.?.name) == [
+                    trap.backtrace?.symbols.compactMap(\.name) == [
                         "foo",
                         "bar",
                         "_start",
@@ -138,7 +138,7 @@
                 """
             ) { trap in
                 #expect(
-                    trap.backtrace?.symbols.compactMap(\.?.name) == [
+                    trap.backtrace?.symbols.compactMap(\.name) == [
                         "wasm function[1]",
                         "bar",
                         "_start",