Allocate and modify Pc directly as Debugger property

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -46,8 +46,8 @@
             case noInstructionMappingAvailable(Int)
         }
 
-        private let valueStack: Sp
-        private let execution: Execution
+        private var valueStack: Sp
+        private var execution: Execution
         private let store: Store
 
         /// Parsed in-memory representation of a Wasm module instantiated for debugging.
@@ -62,7 +62,8 @@
         /// Threading model of the Wasm engine configuration cached for a potentially hot path.
         private let threadingModel: EngineConfiguration.ThreadingModel
 
-        private var breakpoints = [Int: CodeSlot]()
+        private(set) var breakpoints = [Int: CodeSlot]()
+        private var pc: Pc
 
         package init(module: Module, store: Store, imports: Imports) throws {
             let limit = store.engine.configuration.stackSize / MemoryLayout<StackSlot>.stride
@@ -79,6 +80,13 @@
             self.store = store
             self.execution = Execution(store: StoreRef(store), stackEnd: valueStack.advanced(by: limit))
             self.threadingModel = store.engine.configuration.threadingModel
+            let endOfExecution = Instruction.endOfExecution.headSlot(
+                threadingModel: threadingModel
+            )
+            // TODO: clarify why `func executeWasm` allocates 2 Pc slots on the native stack
+            self.pc = Pc.allocate(capacity: 2)
+            self.pc[0] = endOfExecution
+
         }
 
         package mutating func stopAtEntrypoint() throws {
@@ -121,21 +129,32 @@
             iseq.pointee = oldCodeSlot
         }
 
-        package func run() throws {
-            try self.entrypointFunction()
+        package mutating func run() throws {
+            try self.execution.executeWasm(
+                threadingModel: self.threadingModel,
+                function: self.entrypointFunction.handle,
+                type: self.entrypointFunction.type,
+                arguments: [],
+                sp: &self.valueStack,
+                pc: &self.pc
+            )
         }
 
         /// Array of addresses in the Wasm binary of executed instructions on the call stack.
         package var currentCallStack: [Int] {
             let isDebuggable = self.instance.handle.isDebuggable
 
-            return Execution.captureBacktrace(sp: self.valueStack, store: self.store).symbols.map {
-                self.instance.handle.iseqToWasmMapping[$0.address]!
+            print(self.pc)
+            return Execution.captureBacktrace(sp: self.valueStack, store: self.store).symbols.compactMap {
+                print(self.instance.handle.iseqToWasmMapping)
+                print(self.instance.handle.wasmToIseqMapping)
+                return self.instance.handle.iseqToWasmMapping[$0.address]
             }
         }
 
         deinit {
-            valueStack.deallocate()
+            self.valueStack.deallocate()
+            self.pc.deallocate()
         }
     }
 

Sources/WasmKit/Execution/Execution.swift

@@ -293,7 +293,7 @@ func executeWasm(
     return try Execution.with(store: store) { (stack, sp) in
         // Advance the stack pointer to be able to reference negative indices
         // for saving slots.
-        let sp = sp.advanced(by: FrameHeaderLayout.numberOfSavingSlots)
+        var sp = sp.advanced(by: FrameHeaderLayout.numberOfSavingSlots)
         // Mark root stack pointer and current function as nil.
         sp.previousSP = nil
         sp.currentFunction = nil
@@ -305,9 +305,10 @@ func executeWasm(
             rootISeq[0] = Instruction.endOfExecution.headSlot(
                 threadingModel: store.value.engine.configuration.threadingModel
             )
+            var pc = rootISeq.baseAddress!
             try stack.execute(
-                sp: sp,
-                pc: rootISeq.baseAddress!,
+                sp: &sp,
+                pc: &pc,
                 handle: handle,
                 type: type
             )
@@ -318,6 +319,46 @@ func executeWasm(
     }
 }
 
+#if WasmDebuggingSupport
+    extension Execution {
+        @inline(never)
+        mutating func executeWasm(
+            threadingModel: EngineConfiguration.ThreadingModel,
+            function handle: InternalFunction,
+            type: FunctionType,
+            arguments: [Value],
+            sp: inout Sp,
+            pc: inout Pc
+        ) throws -> [Value] {
+            // Advance the stack pointer to be able to reference negative indices
+            // for saving slots.
+            sp = sp.advanced(by: FrameHeaderLayout.numberOfSavingSlots)
+            // Mark root stack pointer and current function as nil.
+            sp.previousSP = nil
+            sp.currentFunction = nil
+            for (index, argument) in arguments.enumerated() {
+                sp[VReg(index)] = UntypedValue(argument)
+            }
+
+            try withUnsafeTemporaryAllocation(of: CodeSlot.self, capacity: 2) { rootISeq in
+                rootISeq[0] = Instruction.endOfExecution.headSlot(
+                    threadingModel: threadingModel
+                )
+                pc = rootISeq.baseAddress!
+                try self.execute(
+                    sp: &sp,
+                    pc: &pc,
+                    handle: handle,
+                    type: type
+                )
+            }
+            return type.results.enumerated().map { (i, type) in
+                sp[VReg(i)].cast(to: type)
+            }
+        }
+    }
+#endif
+
 extension Execution {
     /// A namespace for the "current memory" (Md and Ms) management.
     enum CurrentMemory {
@@ -373,14 +414,12 @@ extension Execution {
     /// The entry point for the execution of the WebAssembly function.
     @inline(never)
     mutating func execute(
-        sp: Sp, pc: Pc,
+        sp: inout Sp, pc: inout Pc,
         handle: InternalFunction,
         type: FunctionType
     ) throws {
-        var sp: Sp = sp
         var md: Md = nil
         var ms: Ms = 0
-        var pc = pc
         (pc, sp) = try invoke(
             function: handle,
             callerInstance: nil,
@@ -390,7 +429,7 @@ extension Execution {
         do {
             switch self.store.value.engine.configuration.threadingModel {
             case .direct:
-                try runDirectThreaded(sp: sp, pc: pc, md: md, ms: ms)
+                try runDirectThreaded(sp: sp, pc: &pc, md: md, ms: ms)
             case .token:
                 try runTokenThreaded(sp: &sp, pc: &pc, md: &md, ms: &ms)
             }
@@ -402,12 +441,11 @@ extension Execution {
     /// Starts the main execution loop using the direct threading model.
     @inline(never)
     mutating func runDirectThreaded(
-        sp: Sp, pc: Pc, md: Md, ms: Ms
+        sp: Sp, pc: inout Pc, md: Md, ms: Ms
     ) throws {
         #if os(WASI)
             fatalError("Direct threading is not supported on WASI")
         #else
-            var pc = pc
             let handler = pc.read(wasmkit_tc_exec.self)
             wasmkit_tc_start(handler, sp, pc, md, ms, &self)
             if let (rawError, trappingSp) = self.trap {

Tests/WasmKitTests/DebuggerTests.swift

@@ -31,6 +31,10 @@
             #expect(throws: Execution.Breakpoint.self) {
                 try debugger.run()
             }
+
+            let callStack = debugger.currentCallStack
+            #expect(callStack.count == 1)
+            #expect(callStack.first == debugger.breakpoints.keys.first)
         }
 
         @Test