Fix DebuggerTests

Author: MaxDesiatov

Sources/WasmKit/Execution/Debugger.swift

@@ -1,5 +1,45 @@
 #if WasmDebuggingSupport
 
+    extension [Int] {
+        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 {
+        func findIseq(forWasmAddress address: Int) throws(Debugger.Error) -> Pc {
+            // Look in the main mapping first
+            guard
+                let iseq = handle.wasmToIseqMapping[address]
+                    // If nothing found, find the closest Wasm address using binary search
+                    ?? handle.wasmMappings.binarySearch(nextClosestTo: address)
+                    // Look in the main mapping again with the next closest address if binary search produced anything
+                    .flatMap({ handle.wasmToIseqMapping[$0] })
+            else {
+                throw Debugger.Error.noInstructionMappingAvailable(address)
+            }
+
+            return iseq
+        }
+    }
+
     package struct Debugger: ~Copyable {
         package enum Error: Swift.Error {
             case entrypointFunctionNotFound
@@ -60,17 +100,12 @@
         }
 
         package mutating func enableBreakpoint(address: Int) throws(Error) {
-            print("attempt to toggle a breakpoint at \(address)")
-            print("available mapping: \(self.instance.handle.wasmToIseqMapping)")
-
             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)
-            }
+            let iseq = try self.instance.findIseq(forWasmAddress: address)
+
             self.breakpoints[address] = iseq.pointee
             iseq.pointee = Instruction.breakpoint.headSlot(threadingModel: self.threadingModel)
         }
@@ -83,9 +118,8 @@
                 return
             }
 
-            guard let iseq = self.instance.handle.wasmToIseqMapping[address] else {
-                throw Error.noInstructionMappingAvailable(address)
-            }
+            let iseq = try self.instance.findIseq(forWasmAddress: address)
+
             self.breakpoints[address] = nil
             iseq.pointee = oldCodeSlot
         }

Sources/WasmKit/Execution/Instances.swift

@@ -87,11 +87,15 @@ struct InstanceEntity /* : ~Copyable */ {
 
     /// 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]
+    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]
+    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]()
 
     static var empty: InstanceEntity {
         InstanceEntity(

Sources/WasmKit/Translator.swift

@@ -1110,6 +1110,7 @@ struct InstructionTranslator: InstructionVisitor {
                 if $0.wasmToIseqMapping[wasm] == nil {
                     $0.wasmToIseqMapping[wasm] = absoluteISeq
                 }
+                $0.wasmMappings.append(wasm)
             }
         }
 
@@ -1127,7 +1128,6 @@ struct InstructionTranslator: InstructionVisitor {
             guard self.module.isDebuggable else { return }
 
             self.iseqToWasmMapping.append((self.iseqBuilder.insertingPC.offsetFromHead, self.binaryOffset))
-            print("added iSeqToWasmMapping[\(self.iseqBuilder.insertingPC.offsetFromHead)] = \(self.binaryOffset)")
         #endif
     }
 
@@ -1902,8 +1902,6 @@ struct InstructionTranslator: InstructionVisitor {
     }
 
     private mutating func visitConst(_ type: ValueType, _ value: Value) {
-        print("in \(#function) self.binaryOffset is \(self.binaryOffset)")
-
         // TODO: document this behavior
         if let constSlotIndex = constantSlots.allocate(value) {
             valueStack.pushConst(constSlotIndex, type: type)
@@ -1912,7 +1910,6 @@ struct InstructionTranslator: InstructionVisitor {
         }
         let value = UntypedValue(value)
         let is32Bit = type == .i32 || type == .f32
-        print("emitting const \(value)")
         if is32Bit {
             pushEmit(
                 type,

Tests/WasmKitTests/DebuggerTests.swift

@@ -1,38 +1,52 @@
 #if WasmDebuggingSupport
 
-import Testing
-import WAT
-@testable import WasmKit
-
-private let trivialModuleWAT = """
-(module
-    (func (export "_start") (result i32) (local $x i32)
-        (i32.const 42)
-        (i32.const 0)
-        (i32.eqz)
-        (drop)
-        (local.set $x)
-        (local.get $x)
-    )
-)
-"""
-
-@Suite
-struct DebuggerTests {
-    @Test
-    func stopAtEntrypoint() throws {
-        let store = Store(engine: Engine())
-        let bytes = try wat2wasm(trivialModuleWAT)
-        print(bytes.count)
-        let module = try parseWasm(bytes: bytes)
-        var debugger = try Debugger(module: module, store: store, imports: [:])
-
-        try debugger.stopAtEntrypoint()
-
-        #expect(throws: Execution.Breakpoint.self) {
-            try debugger.run()
+    import Testing
+    import WAT
+    @testable import WasmKit
+
+    private let trivialModuleWAT = """
+        (module
+            (func (export "_start") (result i32) (local $x i32)
+                (i32.const 42)
+                (i32.const 0)
+                (i32.eqz)
+                (drop)
+                (local.set $x)
+                (local.get $x)
+            )
+        )
+        """
+
+    @Suite
+    struct DebuggerTests {
+        @Test
+        func stopAtEntrypoint() throws {
+            let store = Store(engine: Engine())
+            let bytes = try wat2wasm(trivialModuleWAT)
+            print(bytes.count)
+            let module = try parseWasm(bytes: bytes)
+            var debugger = try Debugger(module: module, store: store, imports: [:])
+
+            try debugger.stopAtEntrypoint()
+
+            #expect(throws: Execution.Breakpoint.self) {
+                try debugger.run()
+            }
+        }
+
+        @Test
+        func binarySearch() throws {
+            #expect([Int]().binarySearch(nextClosestTo: 42) == nil)
+
+            var result = try #require([1].binarySearch(nextClosestTo: 8))
+            #expect(result == 1)
+
+            result = try #require([9, 15, 37].binarySearch(nextClosestTo: 28))
+            #expect(result == 37)
+
+            result = try #require([9, 15, 37].binarySearch(nextClosestTo: 0))
+            #expect(result == 9)
         }
     }
-}
 
 #endif