Fix breakpoints in loops & recursive functions

Currently, when continuing from a breakpoint, the debugger needs to remove it and restore the original instruction before resuming. The conventionally expected behaviour is for the original breakpoint to be preserved. For that, we don't fully resume, but only step to the next instruction, restore the original breakpoint, and then finally resume again.

This still doesn't account for branching instructions, in the same way that the current instruction stepping does not. To be resolved in a future PR, as that requires precise instruction control flow analysis.

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -209,12 +209,12 @@
                         case .token:
                             try self.execution.runTokenThreaded(sp: &sp, pc: &pc, md: &md, ms: &ms)
                         }
-                    } catch is Execution.EndOfExecution {
+                    } catch let end as Execution.EndOfExecution {
                         // The module successfully executed till the "end of execution" instruction.
-                        let type = self.store.engine.funcTypeInterner.resolve(currentFunction.type)
+                        let type = self.entrypointFunction.type
                         self.state = .entrypointReturned(
                             type.results.enumerated().map { (i, type) in
-                                sp[VReg(i)].cast(to: type)
+                                end.sp[VReg(i)].cast(to: type)
                             }
                         )
                     }
@@ -256,6 +256,21 @@
             try self.run()
         }
 
+        /// Resumes the module instantiated by the debugger stopped at a breakpoint. The breakpoint from which
+        /// the debugger resumes is preserved. If the module is current not stopped at a breakpoint, this function
+        /// returns immediately.
+        package mutating func runPreservingCurrentBreakpoint() throws {
+            guard case .stoppedAtBreakpoint(let breakpoint) = self.state else {
+                return
+            }
+
+            // TODO: analyze actual instruction branching to set the breakpoint correctly.
+            try self.enableBreakpoint(address: breakpoint.wasmPc + 1)
+            try self.run()
+            try self.enableBreakpoint(address: breakpoint.wasmPc)
+            try self.run()
+        }
+
         package func getLocal(frameIndex: UInt, localIndex: UInt) throws -> UInt64 {
             guard case .stoppedAtBreakpoint(let breakpoint) = self.state else {
                 throw Error.notStoppedAtBreakpoint

Sources/WasmKit/Execution/Execution.swift

@@ -410,7 +410,9 @@ extension Execution {
     }
 
     /// An ``Error`` thrown when the execution normally ends.
-    struct EndOfExecution: Error {}
+    struct EndOfExecution: Error, @unchecked Sendable {
+        let sp: Sp
+    }
 
     /// An ``Error`` thrown when a breakpoint is triggered.
     struct Breakpoint: Error, @unchecked Sendable {

Sources/WasmKit/Execution/Instructions/Control.swift

@@ -52,7 +52,7 @@ extension Execution {
     }
 
     mutating func endOfExecution(sp: inout Sp, pc: Pc) throws -> (Pc, CodeSlot) {
-        throw EndOfExecution()
+        throw EndOfExecution(sp: sp)
     }
 
     @inline(__always)

Sources/WasmKitGDBHandler/WasmKitGDBHandler.swift

@@ -268,13 +268,13 @@
                 case .step:
                     try self.debugger.step()
                 case .continue:
-                    try self.debugger.run()
+                    try self.debugger.runPreservingCurrentBreakpoint()
                 }
 
                 responseKind = try self.currentThreadStopInfo
 
             case .continue:
-                try self.debugger.run()
+                try self.debugger.runPreservingCurrentBreakpoint()
 
                 responseKind = try self.currentThreadStopInfo
 

Tests/WasmKitTests/DebuggerTests.swift

@@ -61,6 +61,28 @@
         )
         """
 
+    private let factorialWAT = """
+        (module
+          (func (export "_start") (result i64)
+            (i64.const 3)
+            (call $factorial)
+          )
+
+          (func $factorial (param $arg i64) (result i64)
+            (if (result i64)
+              (i64.eqz (local.get $arg))
+              (then (i64.const 1))
+              (else
+                (i64.mul
+                  (local.get $arg)
+                  (call $factorial
+                    (i64.sub
+                      (local.get $arg)
+                      (i64.const 1)
+                    ))))))
+        )
+        """
+
     @Suite
     struct DebuggerTests {
         @Test
@@ -145,6 +167,41 @@
             let secondLocal = try debugger.getLocal(frameIndex: 0, localIndex: 1)
             #expect(secondLocal == 24)
         }
+
+        @Test
+        func runPreservingCurrentBreakpoint() throws {
+            let store = Store(engine: Engine())
+            let bytes = try wat2wasm(factorialWAT)
+            let module = try parseWasm(bytes: bytes)
+            var debugger = try Debugger(module: module, store: store, imports: [:])
+
+            _ = try debugger.enableBreakpoint(
+                module: module,
+                function: 1,
+                // if 1 byte + i64.const 2 bytes + i64.eqz 1 byte + local.set 4 bytes
+                offsetWithinFunction: 8
+            )
+
+            try debugger.run()
+            var local = try debugger.getLocal(frameIndex: 0, localIndex: 0)
+            #expect(local == 3)
+            try debugger.runPreservingCurrentBreakpoint()
+
+            local = try debugger.getLocal(frameIndex: 0, localIndex: 0)
+            #expect(local == 2)
+            try debugger.runPreservingCurrentBreakpoint()
+
+            local = try debugger.getLocal(frameIndex: 0, localIndex: 0)
+            #expect(local == 1)
+            try debugger.runPreservingCurrentBreakpoint()
+
+            guard case .entrypointReturned(let values) = debugger.state else {
+                Issue.record()
+                return
+            }
+
+            #expect(values == [.i64(6)])
+        }
     }
 
 #endif