Bring back getLocal, add more thorough tests

Author: MaxDesiatov

.swift-format

@@ -3,5 +3,6 @@
   "lineLength": 200,
   "indentation": {
     "spaces": 4
-  }
+  },
+  "ReturnVoidInsteadOfEmptyTuple": false
 }

Sources/WasmKit/Execution/Debugger.swift

@@ -20,9 +20,11 @@
             case unknownCurrentFunctionForResumedBreakpoint(UnsafeMutablePointer<UInt64>)
             case noInstructionMappingAvailable(Int)
             case noReverseInstructionMappingAvailable(UnsafeMutablePointer<UInt64>)
-            case stackFrameIndexOOB(Int)
-            case stackLocalIndexOOB(Int)
+            case stackFrameIndexOOB(UInt)
+            case stackLocalIndexOOB(UInt)
             case notStoppedAtBreakpoint
+            case linearMemoryNotInitialized
+            case linearMemoryOOB(Range<Int>)
         }
 
         private let valueStack: Sp
@@ -49,6 +51,9 @@
         /// Pc of the final instruction that a successful program will execute, initialized with `Instruction.endofExecution`
         private let endOfExecution = Pc.allocate(capacity: 1)
 
+        private var md: Md = nil
+        private var ms: Ms = 0
+
         /// Addresses of functions in the original Wasm binary, used for looking up functions when a breakpoint
         /// is enabled at an arbitrary address if it isn't present in ``InstructionMapping`` yet (i.e. the
         /// was not compiled yet in lazy compilation mode).
@@ -189,8 +194,6 @@
                     let iseq = breakpoint.iseq
                     var sp = iseq.sp
                     var pc = iseq.pc
-                    var md: Md = nil
-                    var ms: Ms = 0
 
                     guard let currentFunction = sp.currentFunction else {
                         throw Error.unknownCurrentFunctionForResumedBreakpoint(sp)
@@ -256,14 +259,74 @@
             try self.run()
         }
 
-        package mutating func packedStackFrame<T>(frameIndex: Int, reader: (RawSpan, DebuggerStackFrame.Layout) -> T) throws -> T {
+        package mutating func packedStackFrame<T>(frameIndex: UInt, reader: (RawSpan, DebuggerStackFrame.Layout) -> T) throws -> T {
             guard case .stoppedAtBreakpoint(let breakpoint) = self.state else {
                 throw Error.notStoppedAtBreakpoint
             }
 
             return try self.stackFrame.withFrames(sp: breakpoint.iseq.sp, frameIndex: frameIndex, store: self.store, reader: reader)
         }
 
+        package func getLocal(localIndex: UInt, frameIndex: UInt) throws -> UInt64 {
+            guard case .stoppedAtBreakpoint(let breakpoint) = self.state else {
+                throw Error.notStoppedAtBreakpoint
+            }
+
+            var i = 0
+            for frame in Execution.CallStack(sp: breakpoint.iseq.sp) {
+                guard frameIndex == i else {
+                    i += 1
+                    continue
+                }
+
+                guard let currentFunction = frame.sp.currentFunction else {
+                    throw Debugger.Error.unknownCurrentFunctionForResumedBreakpoint(frame.sp)
+                }
+
+                try currentFunction.ensureCompiled(store: StoreRef(store))
+
+                guard case .debuggable(let wasm, _) = currentFunction.code else {
+                    fatalError()
+                }
+
+                // Wasm function arguments are also addressed as locals.
+                let functionType = store.engine.funcTypeInterner.resolve(currentFunction.type)
+
+                let localsCount = functionType.parameters.count + wasm.locals.count
+
+                guard localIndex < localsCount else {
+                    throw Debugger.Error.stackLocalIndexOOB(localIndex)
+                }
+
+                if localIndex < functionType.parameters.count {
+                    let localIndex = Int(localIndex) - 3
+                    return frame.sp[localIndex].storage
+                } else {
+                    return frame.sp[localIndex].storage
+                }
+            }
+
+            throw Error.stackFrameIndexOOB(frameIndex)
+        }
+
+        package func readLinearMemory<T>(address: UInt, length: UInt, reader: (RawSpan) -> T) throws(Error) -> T {
+            guard let md, ms > 0 else {
+                throw Error.linearMemoryNotInitialized
+            }
+
+            let upperBound = address + length
+            let range = Int(address)..<Int(upperBound)
+
+            guard address + length < ms else {
+                throw Error.linearMemoryOOB(range)
+            }
+
+            let memory = UnsafeRawBufferPointer(start: md, count: ms)
+            print(Array(memory[range]))
+
+            return reader(UnsafeRawBufferPointer(rebasing: memory[range]).bytes)
+        }
+
         /// Array of addresses in the Wasm binary of executed instructions on the call stack.
         package var currentCallStack: [Int] {
             guard case .stoppedAtBreakpoint(let breakpoint) = self.state else {

Sources/WasmKit/Execution/DebuggerStackFrame.swift

@@ -14,7 +14,7 @@
             buffer.initializeMemory(as: Int.self, repeating: 0)
         }
 
-        mutating func withFrames<T>(sp: Sp, frameIndex: Int, store: Store, reader: (borrowing RawSpan, Layout) -> T) throws -> T {
+        mutating func withFrames<T>(sp: Sp, frameIndex: UInt, store: Store, reader: (borrowing RawSpan, Layout) -> T) throws -> T {
             self.buffer.initializeMemory(as: Int.self, repeating: 0)
 
             var i = 0

Sources/WasmKitGDBHandler/DebuggerMemoryCache.swift

@@ -44,11 +44,11 @@
             self.stackFrames = allocator.buffer(capacity: 0)
         }
 
-        package mutating func getAddressOfLocal(debugger: inout Debugger, frameIndex: Int, localIndex: Int) throws -> UInt64 {
+        package mutating func getAddressOfLocal(debugger: inout Debugger, frameIndex: UInt, localIndex: UInt) throws -> UInt64 {
             let frameBase: Int
             let frameLayout: DebuggerStackFrame.Layout
 
-            if let (base, layout) = self.stackFrameLayouts[frameIndex] {
+            if let (base, layout) = self.stackFrameLayouts[Int(frameIndex)] {
                 guard layout.localOffsets.count > localIndex else {
                     throw Debugger.Error.stackLocalIndexOOB(localIndex)
                 }
@@ -59,43 +59,49 @@
                 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)
                 }
 
-                self.stackFrameLayouts[frameIndex] = (base, layout)
+                self.stackFrameLayouts[Int(frameIndex)] = (base, layout)
 
                 frameBase = base
                 frameLayout = layout
             }
 
-            return self.stackOffsetInProtocolSpace + UInt64(frameBase + frameLayout.localOffsets[localIndex])
+            return self.stackOffsetInProtocolSpace + UInt64(frameBase + frameLayout.localOffsets[Int(localIndex)])
         }
 
         package func readMemory(
             debugger: borrowing Debugger,
             addressInProtocolSpace: UInt64,
-            length: Int
-        ) -> ByteBufferView {
-            var length = length
+            length: UInt
+        ) throws(Debugger.Error)-> ByteBufferView {
 
             if addressInProtocolSpace >= self.stackOffsetInProtocolSpace {
+                var length = Int(length)
                 let stackAddress = Int(addressInProtocolSpace - self.stackOffsetInProtocolSpace)
                 if stackAddress + length > self.stackFrames.readableBytes {
                     length = self.stackFrames.readableBytes - stackAddress
                 }
 
                 return self.stackFrames.readableBytesView[stackAddress..<(stackAddress + length)]
             } else if addressInProtocolSpace >= Self.executableCodeOffset {
-                print("wasmBinary")
+                var length = Int(length)
                 let codeAddress = Int(addressInProtocolSpace - Self.executableCodeOffset)
                 if codeAddress + length > wasmBinary.readableBytes {
                     length = wasmBinary.readableBytes - codeAddress
                 }
 
                 return wasmBinary.readableBytesView[codeAddress..<(codeAddress + length)]
             } else {
-                fatalError("Linear memory reads are not implemented in the debugger yet.")
+                return try debugger.readLinearMemory(address: UInt(addressInProtocolSpace), length: length) { span in
+                    var buffer = self.allocator.buffer(capacity: span.byteCount)
+                    span.withUnsafeBytes {
+                        print(Array($0))
+                    }
+                    buffer.writeBytes(span)
+                    return buffer.readableBytesView
+                }
             }
         }
 

Sources/WasmKitGDBHandler/WasmKitGDBHandler.swift

@@ -219,8 +219,10 @@
                 if command.arguments.starts(with: "libraries:read:") {
                     responseKind = .string(
                         """
-                        l<library-list>
-                            <library name="\(self.moduleFilePath.string)"><section address="0x4000000000000000"/></library>
+                        l<library-list>\
+                        <library name="\(self.moduleFilePath.string)">\
+                        <section address="0x\(String(DebuggerMemoryCache.executableCodeOffset, radix: 16))"/>\
+                        </library>\
                         </library-list>
                         """)
                 } else {
@@ -232,11 +234,11 @@
                 guard
                     argumentsArray.count == 2,
                     let addressInProtocolSpace = UInt64(hexEncoded: argumentsArray[0]),
-                    let length = Int(hexEncoded: argumentsArray[1])
+                    let length = UInt(hexEncoded: argumentsArray[1])
                 else { throw Error.unknownReadMemoryArguments }
 
                 responseKind = .hexEncodedBinary(
-                    self.memoryCache.readMemory(
+                    try self.memoryCache.readMemory(
                         debugger: self.debugger,
                         addressInProtocolSpace: addressInProtocolSpace,
                         length: length
@@ -320,11 +322,7 @@
 
                 responseKind = .hexEncodedBinary(
                     self.allocator.buffer(
-                        integer: try self.memoryCache.getAddressOfLocal(
-                            debugger: &self.debugger,
-                            frameIndex: Int(frameIndex),
-                            localIndex: Int(localIndex)
-                        ),
+                        integer: try self.debugger.getLocal(localIndex: localIndex, frameIndex: frameIndex),
                         endianness: .little
                     ).readableBytesView
                 )

Tests/WasmKitGDBHandlerTests/DebuggerMemoryCacheTests.swift

@@ -42,27 +42,25 @@
 
             var memoryCache = DebuggerMemoryCache(allocator: .init(), wasmBinary: .init(bytes: bytes))
 
-            var breakpointAddress = try debugger.enableBreakpoint(module: module, function: 1)
-            try debugger.enableBreakpoint(address: breakpointAddress)
+            _ = try debugger.enableBreakpoint(module: module, function: 1)
             try debugger.run()
 
             var localAddress = try memoryCache.getAddressOfLocal(debugger: &debugger, frameIndex: 0, localIndex: 0)
-            var buffer = ByteBuffer(memoryCache.readMemory(debugger: debugger, addressInProtocolSpace: localAddress, length: 4))
+            var buffer = ByteBuffer(try memoryCache.readMemory(debugger: debugger, addressInProtocolSpace: localAddress, length: 4))
             var value = buffer.readInteger(endianness: .little, as: UInt32.self)
             #expect(value == 42)
 
-            breakpointAddress = try debugger.enableBreakpoint(
+            _ = 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))
+            buffer = ByteBuffer(try memoryCache.readMemory(debugger: debugger, addressInProtocolSpace: localAddress, length: 4))
             value = buffer.readInteger(endianness: .little, as: UInt32.self)
             #expect(value == 24)
         }

Tests/WasmKitTests/DebuggerTests.swift

@@ -36,6 +36,31 @@
         )
         """
 
+private let manyLocalsWAT = """
+    (module
+        (func (export "_start") (result i32) (local $x i32)
+            (i32.const 42)
+            (i32.const 0)
+            (i32.eqz)
+            (drop)
+            (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 DebuggerTests {
         @Test
@@ -99,6 +124,27 @@
             #expect([106, 110, 111].binarySearch(nextClosestTo: 107) == 110)
             #expect([106, 110, 111, 113, 119, 120, 122, 128, 136].binarySearch(nextClosestTo: 121) == 122)
         }
+
+        @Test
+        func getLocal() throws {
+            let store = Store(engine: Engine())
+            let bytes = try wat2wasm(manyLocalsWAT)
+            let module = try parseWasm(bytes: bytes)
+            var debugger = try Debugger(module: module, store: store, imports: [:])
+
+            _ = try debugger.enableBreakpoint(
+                module: module,
+                function: 2,
+                // i32.const 2 bytes + local.set 4 bytes
+                offsetWithinFunction: 6
+            )
+
+            try debugger.run()
+            let firstLocal = try debugger.getLocal(localIndex: 0, frameIndex: 0)
+            #expect(firstLocal == 42)
+            let secondLocal = try debugger.getLocal(localIndex: 0, frameIndex: 1)
+            #expect(secondLocal == 24)
+        }
     }
 
 #endif