Fix DebuggerMemoryCacheTests

Author: MaxDesiatov

[email protected]

@@ -195,6 +195,7 @@ if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
             name: "WasmKitGDBHandlerTests",
             dependencies: [
                 "WasmKitGDBHandler",
+                "WAT",
             ],
         ),
     ])

Sources/WasmKit/Execution/Debugger.swift

@@ -150,9 +150,14 @@
             return wasm
         }
 
-        package mutating func enableBreakpoint(module: Module, function: Int) throws -> Int {
-            try self.enableBreakpoint(address: module.functions[function].code.originalAddress)
+        package mutating func enableBreakpoint(
+            module: Module,
+            function: Int,
+            offsetWithinFunction: Int = 0
+        ) throws -> Int {
+            try self.enableBreakpoint(address: module.functions[function].code.originalAddress + offsetWithinFunction)
         }
+
         /// Disables a breakpoint at a given Wasm address. If no breakpoint at a given address was previously set with
         /// `self.enableBreakpoint(address:), this function immediately returns.
         /// - Parameter address: byte offset of the Wasm instruction that was replaced with a breakpoint. The original

Sources/WasmKit/Execution/DebuggerStackFrame.swift

@@ -51,13 +51,13 @@
 
                 for (i, type) in functionType.parameters.enumerated() {
                     // See ``FrameHeaderLayout`` documentation for offset calculation details.
-                    type.append(to: &span, frame, offset: i - max(functionType.parameters.count, functionType.results.count))
                     layout.localOffsets.append(span.byteCount)
+                    type.append(to: &span, frame, offset: i - 3 - max(functionType.parameters.count, functionType.results.count))
                 }
 
                 for (i, type) in wasm.locals.enumerated() {
-                    type.append(to: &span, frame, offset: i)
                     layout.localOffsets.append(span.byteCount)
+                    type.append(to: &span, frame, offset: i)
                 }
 
                 // FIXME: copy over actual stack values

Sources/WasmKitGDBHandler/DebuggerMemoryCache.swift

@@ -47,6 +47,7 @@
                 let (base, layout) = try debugger.packedStackFrame(frameIndex: frameIndex) { span, layout in
                     let baseAddress = self.stackFrames.writerIndex
                     self.stackFrames.writeBytes(span)
+                    print("written to stackFrames: \(self.stackFrames.hexDump(format: .plain))")
                     return (baseAddress, layout)
                 }
 
@@ -67,9 +68,7 @@
             var length = length
 
             if addressInProtocolSpace >= self.stackOffsetInProtocolSpace {
-                print("stackMemory")
                 let stackAddress = Int(addressInProtocolSpace - self.stackOffsetInProtocolSpace)
-                print("stackAddress is \(stackAddress)")
                 if stackAddress + length > self.stackFrames.readableBytes {
                     length = self.stackFrames.readableBytes - stackAddress
                 }
@@ -88,7 +87,7 @@
             }
         }
 
-        mutating func invalidate() {
+        package mutating func invalidate() {
             self.stackFrames = self.allocator.buffer(capacity: 0)
             self.stackFrameLayouts = [:]
         }

Tests/WasmKitGDBHandlerTests/DebuggerMemoryCacheTests.swift

@@ -16,17 +16,23 @@
                 (local.set $x)
                 (local.get $x)
                 (call $f)
+                (call $g)
             )
 
             (func $f (param $a i32) (result i32)
                 (local.get $a)
             )
+
+            (func $g (param $a i32) (result i32) (local $x i32)
+                (i32.const 24)
+                (local.set $x)
+                (local.get $a)
+            )
         )
         """
 
     @Suite
     struct DebuggerMemoryCacheTests {
-
         @Test
         func localAddress() throws {
             let store = Store(engine: Engine())
@@ -36,13 +42,29 @@
 
             var memoryCache = DebuggerMemoryCache(allocator: .init(), wasmBinary: .init(bytes: bytes))
 
-            let breakpointAddress = try debugger.enableBreakpoint(module: module, function: 1)
+            var breakpointAddress = try debugger.enableBreakpoint(module: module, function: 1)
+            try debugger.enableBreakpoint(address: breakpointAddress)
             try debugger.run()
 
-            let localAddress = try memoryCache.getAddressOfLocal(debugger: &debugger, frameIndex: 0, localIndex: 0)
+            var localAddress = try memoryCache.getAddressOfLocal(debugger: &debugger, frameIndex: 0, localIndex: 0)
             var buffer = ByteBuffer(memoryCache.readMemory(debugger: debugger, addressInProtocolSpace: localAddress, length: 4))
-            let value = buffer.readInteger(endianness: .little, as: UInt32.self)
+            var value = buffer.readInteger(endianness: .little, as: UInt32.self)
             #expect(value == 42)
+
+            breakpointAddress = try debugger.enableBreakpoint(
+                module: module,
+                function: 2,
+                // i32.const 2 bytes + local.set 4 bytes
+                offsetWithinFunction: 6
+            )
+            try debugger.enableBreakpoint(address: breakpointAddress)
+            try debugger.run()
+            memoryCache.invalidate()
+
+            localAddress = try memoryCache.getAddressOfLocal(debugger: &debugger, frameIndex: 0, localIndex: 1)
+            buffer = ByteBuffer(memoryCache.readMemory(debugger: debugger, addressInProtocolSpace: localAddress, length: 4))
+            value = buffer.readInteger(endianness: .little, as: UInt32.self)
+            #expect(value == 24)
         }
     }
 #endif