GDB RP: support qWasmCallStack and debugger breakpoints

Sources/WasmKit/DebuggerInstructionMapping.swift

@@ -0,0 +1,86 @@
+
+/// Two-way mapping between Wasm and internal iseq bytecode instructions. The implementation of the mapping
+/// is private and is empty when `WasmDebuggingSupport` package trait is disabled.
+struct DebuggerInstructionMapping {
+#if WasmDebuggingSupport
+
+    /// Mapping from iseq Pc to instruction addresses in the original binary.
+    /// Used for handling current call stack requests issued by a ``Debugger`` instance.
+    private var iseqToWasm = [Pc: Int]()
+
+    /// Mapping from Wasm instruction addresses in the original binary to iseq instruction addresses.
+    /// Used for handling breakpoint requests issued by a ``Debugger`` instance.
+    private var wasmToIseq = [Int: Pc]()
+
+    /// Wasm addresses sorted in ascending order for binary search when of the next closest mapped
+    /// instruction, when no key is found in `wasmToIseqMapping`.
+    private var wasmMappings = [Int]()
+
+    mutating func add(wasm: Int, iseq: Pc) {
+        // Don't override the existing mapping, only store a new pair if there's no mapping for a given key.
+        if self.iseqToWasm[iseq] == nil {
+            self.iseqToWasm[iseq] = wasm
+        }
+        if self.wasmToIseq[wasm] == nil {
+            self.wasmToIseq[wasm] = iseq
+        }
+        self.wasmMappings.append(wasm)
+    }
+
+    /// Computes an address of WasmKit's iseq bytecode instruction that matches a given Wasm instruction address.
+    /// - Parameter address: the Wasm instruction to find a mapping for.
+    /// - Returns: A tuple with an address of found iseq instruction and the original Wasm instruction or next
+    /// closest match if no direct match was found.
+    func findIseq(forWasmAddress address: Int) -> (iseq: Pc, wasm: Int)? {
+        // Look in the main mapping
+        if let iseq = self.wasmToIseq[address] {
+            return (iseq, address)
+        }
+
+        // If nothing found, find the closest Wasm address using binary search
+        guard let nextAddress = self.wasmMappings.binarySearch(nextClosestTo: address),
+            // Look in the main mapping again with the next closest address if binary search produced anything
+            let iseq = self.wasmToIseq[nextAddress]
+        else {
+            return nil
+        }
+
+        return (iseq, nextAddress)
+    }
+
+    func findWasm(forIseqAddress pc: Pc) -> Int? {
+        self.iseqToWasm[pc]
+    }
+#endif
+}
+
+
+#if WasmDebuggingSupport
+    extension [Int] {
+        /// Uses binary search to find an element in `self` that's next closest to a given value.
+        /// - Parameter value: the array element to search for or to use as a baseline when searching.
+        /// - Returns: array element `result`, where `result - value` is the smallest possible, while
+        /// `result > value` also holds.
+        package func binarySearch(nextClosestTo value: Int) -> Int? {
+            switch self.count {
+            case 0:
+                return nil
+            default:
+                var slice = self[0..<self.count]
+                while slice.count > 1 {
+                    let middle = (slice.endIndex - slice.startIndex) / 2
+                    if slice[middle] < value {
+                        // Not found anything in the lower half, assigning higher half to `slice`.
+                        slice = slice[(middle + 1)..<slice.endIndex]
+                    } else {
+                        // Not found anything in the higher half, assigning lower half to `slice`.
+                        slice = slice[slice.startIndex..<middle]
+                    }
+                }
+
+                return self[slice.startIndex]
+            }
+        }
+    }
+
+#endif

Sources/WasmKit/Execution/Debugger.swift

@@ -1,55 +1,4 @@
 #if WasmDebuggingSupport
-
-    extension [Int] {
-        /// Uses binary search to find an element in `self` that's next closest to a given value.
-        /// - Parameter value: the array element to search for or to use as a baseline when searching.
-        /// - Returns: array element `result`, where `result - value` is the smallest possible, while
-        /// `result > value` also holds.
-        package func binarySearch(nextClosestTo value: Int) -> Int? {
-            switch self.count {
-            case 0:
-                return nil
-            default:
-                var slice = self[0..<self.count]
-                while slice.count > 1 {
-                    let middle = (slice.endIndex - slice.startIndex) / 2
-                    if slice[middle] < value {
-                        // Not found anything in the lower half, assigning higher half to `slice`.
-                        slice = slice[(middle + 1)..<slice.endIndex]
-                    } else {
-                        // Not found anything in the higher half, assigning lower half to `slice`.
-                        slice = slice[slice.startIndex..<middle]
-                    }
-                }
-
-                return self[slice.startIndex]
-            }
-        }
-    }
-
-    extension Instance {
-        /// Computes an address of WasmKit's iseq bytecode instruction that matches a given Wasm instruction address.
-        /// - Parameter address: the Wasm instruction to find a mapping for.
-        /// - Returns: A tuple with an address of found iseq instruction and the original Wasm instruction or next
-        /// closest match if no direct match was found.
-        fileprivate func findIseq(forWasmAddress address: Int) throws(Debugger.Error) -> (iseq: Pc, wasm: Int) {
-            // Look in the main mapping
-            if let iseq = handle.wasmToIseqMapping[address] {
-                return (iseq, address)
-            }
-
-            // If nothing found, find the closest Wasm address using binary search
-            guard let nextAddress = handle.wasmMappings.binarySearch(nextClosestTo: address),
-                // Look in the main mapping again with the next closest address if binary search produced anything
-                let iseq = handle.wasmToIseqMapping[nextAddress]
-            else {
-                throw Debugger.Error.noInstructionMappingAvailable(address)
-            }
-
-            return (iseq, nextAddress)
-        }
-    }
-
     /// User-facing debugger state driven by a debugger host. This implementation has no knowledge of the exact
     /// debugger protocol, which allows any protocol implementation or direct API users to be layered on top if needed.
     package struct Debugger: ~Copyable {
@@ -140,7 +89,9 @@
                 return
             }
 
-            let (iseq, wasm) = try self.instance.findIseq(forWasmAddress: address)
+            guard let (iseq, wasm) = try self.instance.handle.instructionMapping.findIseq(forWasmAddress: address) else {
+                throw Error.noInstructionMappingAvailable(address)
+            }
 
             self.breakpoints[wasm] = iseq.pointee
             iseq.pointee = Instruction.breakpoint.headSlot(threadingModel: self.threadingModel)
@@ -156,7 +107,9 @@
                 return
             }
 
-            let (iseq, wasm) = try self.instance.findIseq(forWasmAddress: address)
+            guard let (iseq, wasm) = try self.instance.handle.instructionMapping.findIseq(forWasmAddress: address) else {
+                throw Error.noInstructionMappingAvailable(address)
+            }
 
             self.breakpoints[wasm] = nil
             iseq.pointee = oldCodeSlot
@@ -216,7 +169,7 @@
                 }
             } catch let breakpoint as Execution.Breakpoint {
                 let pc = breakpoint.pc
-                guard let wasmPc = self.instance.handle.iseqToWasmMapping[pc] else {
+                guard let wasmPc = self.instance.handle.instructionMapping.findWasm(forIseqAddress: pc) else {
                     throw Error.noReverseInstructionMappingAvailable(pc)
                 }
 
@@ -232,7 +185,7 @@
             }
 
             var result = Execution.captureBacktrace(sp: currentBreakpoint.iseq.sp, store: self.store).symbols.compactMap {
-                return self.instance.handle.iseqToWasmMapping[$0.address]
+                return self.instance.handle.instructionMapping.findWasm(forIseqAddress: $0.address)
             }
             result.append(currentBreakpoint.wasmPc)
 

Sources/WasmKit/Execution/Instances.swift

@@ -85,17 +85,7 @@ struct InstanceEntity /* : ~Copyable */ {
     var dataCount: UInt32?
     var isDebuggable: Bool
 
-    /// Mapping from iseq Pc to instruction addresses in the original binary.
-    /// Used for handling current call stack requests issued by a ``Debugger`` instance.
-    var iseqToWasmMapping = [Pc: Int]()
-
-    /// Mapping from Wasm instruction addresses in the original binary to iseq instruction addresses.
-    /// Used for handling breakpoint requests issued by a ``Debugger`` instance.
-    var wasmToIseqMapping = [Int: Pc]()
-
-    /// Wasm addresses sorted in ascending order for binary search when of the next closest mapped
-    /// instruction, when no key is found in `wasmToIseqMapping`.
-    var wasmMappings = [Int]()
+    var instructionMapping: DebuggerInstructionMapping
 
     static var empty: InstanceEntity {
         InstanceEntity(
@@ -111,8 +101,7 @@ struct InstanceEntity /* : ~Copyable */ {
             features: [],
             dataCount: nil,
             isDebuggable: false,
-            iseqToWasmMapping: [:],
-            wasmToIseqMapping: [:]
+            instructionMapping: .init()
         )
     }
 

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -453,8 +453,7 @@ extension StoreAllocator {
             features: module.features,
             dataCount: module.dataCount,
             isDebuggable: isDebuggable,
-            iseqToWasmMapping: [:],
-            wasmToIseqMapping: [:]
+            instructionMapping: .init()
         )
         instancePointer.initialize(to: instanceEntity)
         instanceInitialized = true

Sources/WasmKit/Translator.swift

@@ -1100,19 +1100,14 @@ struct InstructionTranslator: InstructionVisitor {
         let initializedElementsIndex = buffer.initialize(fromContentsOf: instructions)
         assert(initializedElementsIndex == instructions.endIndex)
 
+        #if WasmDebuggingSupport
         for (iseq, wasm) in self.iseqToWasmMapping {
             self.module.withValue {
-                let absoluteISeq = iseq + buffer.baseAddress.unsafelyUnwrapped
-                // Don't override the existing mapping, only store a new pair if there's no mapping for a given key.
-                if $0.iseqToWasmMapping[absoluteISeq] == nil {
-                    $0.iseqToWasmMapping[absoluteISeq] = wasm
-                }
-                if $0.wasmToIseqMapping[wasm] == nil {
-                    $0.wasmToIseqMapping[wasm] = absoluteISeq
-                }
-                $0.wasmMappings.append(wasm)
+                let absoluteIseq = iseq + buffer.baseAddress.unsafelyUnwrapped
+                $0.instructionMapping.add(wasm: wasm, iseq: absoluteIseq)
             }
         }
+#endif
 
         let constants = allocator.allocateConstants(self.constantSlots.values)
         return InstructionSequence(
@@ -2305,16 +2300,6 @@ struct InstructionTranslator: InstructionVisitor {
             return .tableSize(Instruction.TableSizeOperand(tableIndex: table, result: LVReg(result)))
         }
     }
-
-    mutating func visitUnknown(_ opcode: [UInt8]) throws -> Bool {
-        guard self.module.isDebuggable && opcode.count == 1 && opcode[0] == 0xFF else {
-            return false
-        }
-
-        emit(.breakpoint)
-
-        return true
-    }
 }
 
 struct TranslationError: Error, CustomStringConvertible {