Add reverse wasm->iseq mapping, breakpoints toggling PoC

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -3,18 +3,29 @@
     package struct Debugger: ~Copyable {
         enum Error: Swift.Error {
             case entrypointFunctionNotFound
+            case noInstructionMappingAvailable(Int)
         }
 
-        let valueStack: Sp
-        let execution: Execution
-        let store: Store
+        private let valueStack: Sp
+        private let execution: Execution
+        private let store: Store
 
+        /// Parsed in-memory representation of a Wasm module instantiated for debugging.
         private let module: Module
+
+        /// Instance of parsed Wasm ``module``.
         private let instance: Instance
 
         /// Addresses of each function in the code section of ``module``
-        let functionAddresses: [Int]
-        let entrypointFunction: Function
+        private let functionAddresses: [FunctionAddress]
+
+        /// Reference to the entrypoint function of the currently debugged module, for use in ``stopAtEntrypoint``.
+        private let entrypointFunction: Function
+
+        /// Threading model of the Wasm engine configuration cached for a potentially hot path.
+        private let threadingModel: EngineConfiguration.ThreadingModel
+
+        private var breakpoints = [Int: CodeSlot]()
 
         package init(module: Module, store: Store, imports: Imports) throws {
             let limit = store.engine.configuration.stackSize / MemoryLayout<StackSlot>.stride
@@ -31,10 +42,11 @@
             self.valueStack = UnsafeMutablePointer<StackSlot>.allocate(capacity: limit)
             self.store = store
             self.execution = Execution(store: StoreRef(store), stackEnd: valueStack.advanced(by: limit))
+            self.threadingModel = store.engine.configuration.threadingModel
         }
 
         package mutating func stopAtEntrypoint() throws {
-            try self.toggleBreakpoint(address: self.originalAddress(function: entrypointFunction))
+            try self.enableBreakpoint(address: self.originalAddress(function: entrypointFunction))
         }
 
         package func originalAddress(function: Function) throws -> Int {
@@ -47,23 +59,50 @@
                 try function.handle.wasm.ensureCompiled(store: StoreRef(self.store))
                 return try self.originalAddress(function: function)
             case .compiled:
-                print(function.handle.wasm.code)
                 fatalError()
             }
         }
 
-        package mutating func toggleBreakpoint(address: Int) throws {
+        package mutating func enableBreakpoint(address: Int) throws {
             print("attempt to toggle a breakpoint at \(address)")
+
+            guard self.breakpoints[address] == nil else {
+                print("breakpoint at \(address) already enabled")
+                return
+            }
+
+            guard let iseq = self.instance.handle.wasmToIseqMapping[address] else {
+                throw Error.noInstructionMappingAvailable(address)
+            }
+            self.breakpoints[address] = iseq.pointee
+            iseq.pointee = Instruction.breakpoint.headSlot(threadingModel: self.threadingModel)
+        }
+
+        package mutating func disableBreakpoint(address: Int) throws {
+            print("attempt to toggle a breakpoint at \(address)")
+
+            guard let oldCodeSlot = self.breakpoints[address] else {
+                print("breakpoint at \(address) already disabled")
+                return
+            }
+
+            guard let iseq = self.instance.handle.wasmToIseqMapping[address] else {
+                throw Error.noInstructionMappingAvailable(address)
+            }
+            iseq.pointee = oldCodeSlot
+            self.breakpoints[address] = nil
+        }
+
+        mutating func enableBreakpoint(functionIndex: FunctionIndex, offset: Int) {
         }
 
         /// Array of addresses in the Wasm binary of executed instructions on the call stack.
         package var currentCallStack: [Int] {
-            guard let instance = self.valueStack.currentInstance else { return [] }
-            let isDebuggable = instance.isDebuggable
+            let isDebuggable = self.instance.handle.isDebuggable
             print("isDebuggable is \(isDebuggable)")
 
             return Execution.captureBacktrace(sp: self.valueStack, store: self.store).symbols.map {
-                instance.iSeqToWasmMapping[$0.address]!
+                self.instance.handle.iseqToWasmMapping[$0.address]!
             }
         }
 

Sources/WasmKit/Execution/Instances.swift

@@ -84,7 +84,14 @@ struct InstanceEntity /* : ~Copyable */ {
     var features: WasmFeatureSet
     var dataCount: UInt32?
     var isDebuggable: Bool
-    var iSeqToWasmMapping: [Pc: Int]
+
+    /// 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]
 
     static var empty: InstanceEntity {
         InstanceEntity(
@@ -100,7 +107,8 @@ struct InstanceEntity /* : ~Copyable */ {
             features: [],
             dataCount: nil,
             isDebuggable: false,
-            iSeqToWasmMapping: [:]
+            iseqToWasmMapping: [:],
+            wasmToIseqMapping: [:]
         )
     }
 

Sources/WasmKit/Execution/StoreAllocator.swift

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

Sources/WasmKit/Translator.swift

@@ -830,8 +830,10 @@ struct InstructionTranslator: InstructionVisitor {
     /// Current offset to an instruction in the original Wasm binary processed by this translator.
     var binaryOffset: Int = 0
 
-    /// Mapping from `self.iseqBuilder.instructions` to Wasm instructions
-    var iSeqToWasmMapping = [Int: Int]()
+    /// Mapping from `self.iseqBuilder.instructions` to Wasm instructions.
+    /// As mapping between iSeq to Wasm is many:many, but we only care about first mapping for overlapping address,
+    /// we need to iterate on it in the order the mappings were stored to ensure we don't overwrite the frist mapping.
+    var iseqToWasmMapping = [(iseq: Int, wasm: Int)]()
 
     init(
         allocator: ISeqAllocator,
@@ -1098,9 +1100,16 @@ struct InstructionTranslator: InstructionVisitor {
         let initializedElementsIndex = buffer.initialize(fromContentsOf: instructions)
         assert(initializedElementsIndex == instructions.endIndex)
 
-        for (iseq, wasm) in self.iSeqToWasmMapping {
+        for (iseq, wasm) in self.iseqToWasmMapping {
             self.module.withValue {
-                $0.iSeqToWasmMapping[iseq + buffer.baseAddress.unsafelyUnwrapped] = wasm
+                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
+                }
             }
         }
 
@@ -1117,7 +1126,7 @@ struct InstructionTranslator: InstructionVisitor {
         #if WasmDebuggingSupport
             guard self.module.isDebuggable else { return }
 
-            self.iSeqToWasmMapping[self.iseqBuilder.insertingPC.offsetFromHead] = self.binaryOffset
+            self.iseqToWasmMapping.append((self.iseqBuilder.insertingPC.offsetFromHead, self.binaryOffset))
         #endif
     }