Pass Sp in Breakpoint, add executeWasm instance method

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -49,7 +49,7 @@
         }
 
         private let valueStack: Sp
-        private let execution: Execution
+        private var execution: Execution
         private let store: Store
 
         /// Parsed in-memory representation of a Wasm module instantiated for debugging.
@@ -66,7 +66,9 @@
 
         private(set) var breakpoints = [Int: CodeSlot]()
 
-        private var iseqPc: Pc?
+        private var currentBreakpoint: Execution.Breakpoint?
+
+        private var pc = Pc.allocate(capacity: 1)
 
         package init(module: Module, store: Store, imports: Imports) throws {
             let limit = store.engine.configuration.stackSize / MemoryLayout<StackSlot>.stride
@@ -83,6 +85,7 @@
             self.store = store
             self.execution = Execution(store: StoreRef(store), stackEnd: valueStack.advanced(by: limit))
             self.threadingModel = store.engine.configuration.threadingModel
+            self.pc.pointee = Instruction.endOfExecution.headSlot(threadingModel: threadingModel)
         }
 
         package mutating func stopAtEntrypoint() throws {
@@ -125,33 +128,42 @@
             iseq.pointee = oldCodeSlot
         }
 
-        /// Returns: `true` if current instance ran to completion, `false` if it stopped at a breakpoint.
-        package mutating func run() throws -> Bool {
+        /// Returns: `[Value]` result of `entrypointFunction` if current instance ran to completion, `nil` if it stopped at a breakpoint.
+        package mutating func run() throws -> [Value]? {
             do {
-                try self.entrypointFunction()
-                return true
+                return try self.execution.executeWasm(
+                    threadingModel: self.threadingModel,
+                    function: self.entrypointFunction.handle,
+                    type: self.entrypointFunction.type,
+                    arguments: [],
+                    sp: self.valueStack,
+                    pc: self.pc
+                )
             } catch let breakpoint as Execution.Breakpoint {
-                self.iseqPc = breakpoint.pc
-                return false
+                self.currentBreakpoint = breakpoint
+                return nil
             }
         }
 
         /// Array of addresses in the Wasm binary of executed instructions on the call stack.
         package var currentCallStack: [Int] {
-            let isDebuggable = self.instance.handle.isDebuggable
+            guard let currentBreakpoint else {
+                return []
+            }
 
-            var result = Execution.captureBacktrace(sp: self.valueStack, store: self.store).symbols.compactMap {
+            var result = Execution.captureBacktrace(sp: currentBreakpoint.sp, store: self.store).symbols.compactMap {
                 return self.instance.handle.iseqToWasmMapping[$0.address]
             }
-            if let iseqPc, let wasmPc = self.instance.handle.iseqToWasmMapping[iseqPc] {
+            if let wasmPc = self.instance.handle.iseqToWasmMapping[currentBreakpoint.pc] {
                 result.append(wasmPc)
             }
 
             return result
         }
 
         deinit {
-            valueStack.deallocate()
+            self.valueStack.deallocate()
+            self.pc.deallocate()
         }
     }
 

Sources/WasmKit/Execution/Execution.swift

@@ -286,7 +286,6 @@ func executeWasm(
     function handle: InternalFunction,
     type: FunctionType,
     arguments: [Value],
-    callerInstance: InternalInstance
 ) throws -> [Value] {
     // NOTE: `store` variable must not outlive this function
     let store = StoreRef(store)
@@ -319,6 +318,41 @@ func executeWasm(
 }
 
 extension Execution {
+
+    #if WasmDebuggingSupport
+
+        mutating func executeWasm(
+            threadingModel: EngineConfiguration.ThreadingModel,
+            function handle: InternalFunction,
+            type: FunctionType,
+            arguments: [Value],
+            sp: Sp,
+            pc: Pc
+        ) throws -> [Value] {
+            // Advance the stack pointer to be able to reference negative indices
+            // for saving slots.
+            let 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 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
+
     /// A namespace for the "current memory" (Md and Ms) management.
     enum CurrentMemory {
         /// Assigns the current memory to the given internal memory.
@@ -369,6 +403,7 @@ extension Execution {
 
     /// An ``Error`` thrown when a breakpoint is triggered.
     struct Breakpoint: Error, @unchecked Sendable {
+        let sp: Sp
         let pc: Pc
     }
 

Sources/WasmKit/Execution/Function.swift

@@ -172,8 +172,7 @@ extension InternalFunction {
                 store: store,
                 function: self,
                 type: resolvedType,
-                arguments: arguments,
-                callerInstance: entity.instance
+                arguments: arguments
             )
         } else {
             let entity = host

Sources/WasmKit/Execution/Instructions/Control.swift

@@ -226,6 +226,7 @@ extension Execution {
 
     mutating func breakpoint(sp: inout Sp, pc: Pc) throws -> (Pc, CodeSlot) {
         throw Breakpoint(
+            sp: sp,
             // Throw `pc` value before the breakpoint was triggered to allow resumption in same place
             pc: pc - 1
         )

Tests/WasmKitTests/DebuggerTests.swift

@@ -29,7 +29,7 @@
             try debugger.stopAtEntrypoint()
             #expect(debugger.breakpoints.count == 1)
 
-            #expect(try debugger.run() == false)
+            #expect(try debugger.run() == nil)
 
             let expectedPc = try #require(debugger.breakpoints.keys.first)
             #expect(debugger.currentCallStack == [expectedPc])