Add CallStack: Sequence, Debugger.LocalAddress types

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -21,6 +21,9 @@
             case unknownCurrentFunctionForResumedBreakpoint(UnsafeMutablePointer<UInt64>)
             case noInstructionMappingAvailable(Int)
             case noReverseInstructionMappingAvailable(UnsafeMutablePointer<UInt64>)
+            case stackFuncIndexOOB(LocalAddress)
+            case stackLocalIndexOOB(LocalAddress)
+            case notStoppedAtBreakpoint
         }
 
         private let valueStack: Sp
@@ -52,11 +55,6 @@
         /// was not compiled yet in lazy compilation mode).
         private let functionAddresses: [(address: Int, instanceFunctionIndex: Int)]
 
-        /// 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).
-        private let functionAddresses: [(address: Int, instanceFunctionIndex: Int)]
-
         /// Initializes a new debugger state instance.
         /// - Parameters:
         ///   - module: Wasm module to instantiate.
@@ -244,8 +242,38 @@
             try self.run()
         }
 
-        package func getLocal(frameIndex: Int, localIndex: Int) -> Address {
+        package struct LocalAddress {
+            let frameIndex: UInt32
+            let localIndex: UInt32
+
+            package init(frameIndex: Int, localIndex: Int) {
+                self.frameIndex = frameIndex
+                self.localIndex = localIndex
+            }
+        }
+
+
+        /// Iterates through Wasm call stack to return a local at a given address when
+        /// debugged module is stopped at a breakpoint.
+        /// - Parameter address: address of the local to return.
+        /// - Returns: Raw untyped Wasm value at a given address
+        package func getLocal(address: LocalAddress) throws(Error) -> UInt64 {
+            guard case let .stoppedAtBreakpoint(breakpoint) = self.state else {
+                throw Error.notStoppedAtBreakpoint
+            }
+
+            var i = 0
+            for frame in Execution.CallStack(sp: breakpoint.sp) {
+                guard address.frameIndex == i else {
+                    i += 1
+                    continue
+                }
+
+                // TODO: can we guarantee we have no local index OOB here?
+                return frame.sp[address.localIndex].storage
+            }
 
+            throw Error.stackFuncIndexOOB(address)
         }
 
         /// Array of addresses in the Wasm binary of executed instructions on the call stack.

Sources/WasmKit/Execution/Execution.swift

@@ -42,35 +42,43 @@ struct Execution: ~Copyable {
         sp.currentInstance.unsafelyUnwrapped
     }
 
-    /// An iterator for the call frames in the VM stack.
-    struct FrameIterator: IteratorProtocol {
-        struct Element {
-            let pc: Pc
-            let sp: Sp
-        }
+    struct CallStack: Sequence {
+        /// An iterator for the call frames in the VM stack.
+        struct FrameIterator: IteratorProtocol {
+            struct Element {
+                let pc: Pc
+                let sp: Sp
+            }
 
-        /// The stack pointer currently traversed.
-        private var sp: Sp?
+            /// The stack pointer currently traversed.
+            private var sp: Sp?
 
-        init(sp: Sp) {
-            self.sp = sp
-        }
+            init(sp: Sp) {
+                self.sp = sp
+            }
 
-        mutating func next() -> Element? {
-            guard let sp = self.sp, let pc = sp.returnPC else {
-                // Reached the root frame, whose stack pointer is nil.
-                return nil
+            mutating func next() -> Element? {
+                guard let sp = self.sp, let pc = sp.returnPC else {
+                    // Reached the root frame, whose stack pointer is nil.
+                    return nil
+                }
+                self.sp = sp.previousSP
+                return Element(pc: pc, sp: sp)
             }
-            self.sp = sp.previousSP
-            return Element(pc: pc, sp: sp)
+        }
+
+        let sp: Sp
+
+        func makeIterator() -> FrameIterator {
+            FrameIterator(sp: self.sp)
         }
     }
 
     static func captureBacktrace(sp: Sp, store: Store) -> Backtrace {
-        var frames = FrameIterator(sp: sp)
+        let callStack = CallStack(sp: sp)
         var symbols: [Backtrace.Symbol] = []
 
-        while let frame = frames.next() {
+        for frame in callStack {
             guard let function = frame.sp.currentFunction else {
                 symbols.append(.init(name: nil, address: frame.pc))
                 continue

Sources/WasmKitGDBHandler/WasmKitGDBHandler.swift

@@ -32,8 +32,17 @@
         }
     }
 
-    private let codeOffset = UInt64(0x4000_0000_0000_0000)
+
+    extension Debugger.LocalAddress {
+        package init(raw: UInt64) {
+            let rawAdjusted = raw - localOffset
+            self.init(frameIndex: UInt32(truncatingIfNeeded: rawAdjusted >> 32), localIndex: UInt32(truncatingIfNeeded: rawAdjusted))
+        }
+    }
+
+    private let codeOffset  = UInt64(0x4000_0000_0000_0000)
     private let stackOffset = UInt64(0x8000_0000_0000_0000)
+    private let localOffset = UInt64(0xC000_0000_0000_0000)
 
     package actor WasmKitGDBHandler {
         enum ResumeThreadsAction: String {
@@ -231,13 +240,14 @@
                 let argumentsArray = command.arguments.split(separator: ",")
                 guard
                     argumentsArray.count == 2,
-                    let hostAddress = UInt64(hexEncoded: argumentsArray[0]),
+                    let address = UInt64(hexEncoded: argumentsArray[0]),
                     var length = Int(hexEncoded: argumentsArray[1])
                 else { throw Error.unknownReadMemoryArguments }
 
-                if address > stackOffset {
-                    let stackOffset = address - codeOffset
-
+                if address > localOffset {
+                    let localRaw = address - localOffset
+                    let localAddress = Debugger.LocalAddress(frameIndex: )
+                } else if address > stackOffset {
                     fatalError("Stack reads are not implemented in the debugger yet")
                 } else if address > codeOffset {
                     let binaryOffset = address - stackOffset