Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Debugging: add a missing execution-version epoch bump. (#15222)

Chris Fallina16b5f83b6a6
diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rs
index 4c72bbd6d6..13eaa5dccd 100644
--- a/crates/cranelift/src/compiler.rs
+++ b/crates/cranelift/src/compiler.rs
@@ -274,24 +274,7 @@ impl Compiler {
&[callee_vmctx, caller_vmctx, args_base, args_len],
);
- // Increment the "execution version" on the VMStoreContext if
- // guest debugging is enabled.
- if self.tunables.debug_guest {
- let vmstore_ctx_ptr = alias_regions
- .vmctx()
- .store_context()
- .load(&mut builder.cursor(), caller_vmctx);
- let old_version = alias_regions
- .vm_store_context()
- .execution_version()
- .load(&mut builder.cursor(), vmstore_ctx_ptr);
- let new_version = builder.ins().iadd_imm_s(old_version, 1);
- alias_regions.vm_store_context().execution_version().store(
- &mut builder.cursor(),
- vmstore_ctx_ptr,
- new_version,
- );
- }
+ self.bump_execution_version(&mut builder, &mut alias_regions, caller_vmctx);
// Invoke `raise` if the callee (host) returned an error.
let succeeded = builder.func.dfg.inst_results(call)[0];
@@ -382,6 +365,8 @@ impl Compiler {
);
let results = builder.func.dfg.inst_results(call).to_vec();
+ self.bump_execution_version(&mut builder, &mut alias_regions, vmctx);
+
// Libcalls do not explicitly jump/raise on traps but instead return a
// code indicating whether they trapped or not. This means that it's the
// responsibility of the trampoline to check for an trapping return
@@ -1332,6 +1317,39 @@ impl Compiler {
}
}
+ /// Increments the "execution version" in the `VMStoreContext` if guest
+ /// debugging is enabled.
+ ///
+ /// This must be done whenever execution resumes in Wasm after the host
+ /// has had a chance to run (and thus possibly capture `FrameHandle`s),
+ /// so that any such handles are invalidated.
+ fn bump_execution_version<O>(
+ &self,
+ builder: &mut FunctionBuilder<'_>,
+ alias_regions: &mut AliasRegions<O>,
+ vmctx: ir::Value,
+ ) where
+ O: GetPtrSize,
+ {
+ if !self.tunables.debug_guest {
+ return;
+ }
+ let vmstore_ctx_ptr = alias_regions
+ .vmctx()
+ .store_context()
+ .load(&mut builder.cursor(), vmctx);
+ let old_version = alias_regions
+ .vm_store_context()
+ .execution_version()
+ .load(&mut builder.cursor(), vmstore_ctx_ptr);
+ let new_version = builder.ins().iadd_imm_s(old_version, 1);
+ alias_regions.vm_store_context().execution_version().store(
+ &mut builder.cursor(),
+ vmstore_ctx_ptr,
+ new_version,
+ );
+ }
+
/// Invokes the `raise` libcall in `vmctx` if the `succeeded` value
/// indicates if a trap happened.
///
diff --git a/tests/all/debug.rs b/tests/all/debug.rs
index 2593e25c0a..b5ab0bcc3c 100644
--- a/tests/all/debug.rs
+++ b/tests/all/debug.rs
@@ -1226,6 +1226,76 @@ async fn invalidated_frame_handles_in_dropped_future() -> wasmtime::Result<()> {
Ok(())
}
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn invalidated_frame_handles_from_breakpoint() -> wasmtime::Result<()> {
+ let _ = env_logger::try_init();
+
+ // Frame handles captured during a breakpoint/single-step event
+ // (delivered via a builtin, not a host call) must be invalidated
+ // once execution resumes.
+ let (module, mut store) = get_module_and_store(
+ |_config| {},
+ r#"
+ (module
+ (func (export "main") (result i32)
+ (local i32)
+ i32.const 123
+ local.set 0
+ local.get 0))
+ "#,
+ )?;
+
+ #[derive(Clone)]
+ struct H {
+ handle: Arc<Mutex<Option<FrameHandle>>>,
+ events: Arc<AtomicUsize>,
+ }
+ impl DebugHandler for H {
+ type Data = ();
+ async fn handle(&self, mut store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {
+ if !matches!(event, DebugEvent::Breakpoint) {
+ return;
+ }
+ self.events.fetch_add(1, Ordering::Relaxed);
+ let mut handle = self.handle.lock().unwrap();
+ if let Some(old) = handle.as_ref() {
+ // The handle from the previous step must be invalid,
+ // even though its frame is still live.
+ assert!(!old.is_valid(&mut store));
+ assert!(old.local(&mut store, 0).is_err());
+ } else {
+ let frame = store.debug_exit_frames().next().unwrap();
+ assert!(frame.is_valid(&mut store));
+ *handle = Some(frame);
+ }
+ }
+ }
+
+ let handle = Arc::new(Mutex::new(None));
+ let events = Arc::new(AtomicUsize::new(0));
+ store.edit_breakpoints().unwrap().single_step(true).unwrap();
+ store.set_debug_handler(H {
+ handle: handle.clone(),
+ events: events.clone(),
+ });
+
+ let instance = Instance::new_async(&mut store, &module, &[]).await?;
+ let main = instance.get_func(&mut store, "main").unwrap();
+ let mut results = [Val::I32(0)];
+ main.call_async(&mut store, &[], &mut results).await?;
+ assert_eq!(results[0].unwrap_i32(), 123);
+ assert!(events.load(Ordering::Relaxed) > 1);
+
+ // After the frame has returned, the handle must still be invalid
+ // and must not read the dead frame.
+ let frame = handle.lock().unwrap().take().unwrap();
+ assert!(!frame.is_valid(&mut store));
+ assert!(frame.local(&mut store, 0).is_err());
+
+ Ok(())
+}
+
#[test]
#[cfg_attr(miri, ignore)]
fn module_bytecode() -> wasmtime::Result<()> {
diff --git a/tests/disas/debug-exceptions.wat b/tests/disas/debug-exceptions.wat
index 3187a1574c..f49a71ff27 100644
--- a/tests/disas/debug-exceptions.wat
+++ b/tests/disas/debug-exceptions.wat
@@ -37,29 +37,29 @@
;; stur x2, [sp, #0x10]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x35, slot at FP-0xb0, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x35, patch bytes [69, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x35, patch bytes [94, 1, 0, 148]
;; ldur x0, [sp, #0x10]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x37, patch bytes [67, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x37, patch bytes [92, 1, 0, 148]
;; ldur x0, [sp, #0x10]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x3d, slot at FP-0xb0, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x3d, patch bytes [65, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x3d, patch bytes [90, 1, 0, 148]
;; mov w1, #0x2a
;; stur w1, [sp, #8]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x3f, slot at FP-0xb0, locals , stack I32 @ slot+0x8
-;; ╰─╼ breakpoint patch: wasm PC 0x3f, patch bytes [62, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x3f, patch bytes [87, 1, 0, 148]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x40, slot at FP-0xb0, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x40, patch bytes [61, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x40, patch bytes [86, 1, 0, 148]
;; stur w1, [sp, #8]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x42, slot at FP-0xb0, locals , stack I32 @ slot+0x8
-;; ╰─╼ breakpoint patch: wasm PC 0x42, patch bytes [59, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x42, patch bytes [84, 1, 0, 148]
;; ldur x2, [sp, #0x10]
-;; bl #0x4d0
+;; bl #0x50c
;; 88: ldur x0, [sp, #0x10]
;; mov x19, x2
;; ldr x0, [x0, #0x20]
@@ -90,7 +90,7 @@
;; mov w8, #0
;; str w8, [x1, #0x14]
;; ldur x2, [sp, #0x10]
-;; bl #0x508
+;; bl #0x558
;; ├─╼ exception frame offset: SP = FP - 0xb0
;; ╰─╼ exception handler: tag=0, context at [SP+0x10], handler=0x108
;; b #0x1c8
@@ -109,7 +109,7 @@
;; ldur x0, [sp, #0x10]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x48, slot at FP-0xb0, locals , stack I32 @ slot+0x8
-;; ╰─╼ breakpoint patch: wasm PC 0x48, patch bytes [11, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x48, patch bytes [36, 1, 0, 148]
;; ldur x14, [sp, #0x10]
;; ldr x0, [x14, #0x38]
;; ldr x2, [x14, #0x48]
@@ -119,10 +119,10 @@
;; 154: ldur x0, [sp, #0x10]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x4a, slot at FP-0xb0, locals , stack I32 @ slot+0x8
-;; ╰─╼ breakpoint patch: wasm PC 0x4a, patch bytes [4, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x4a, patch bytes [29, 1, 0, 148]
;; nop
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x4b, slot at FP-0xb0, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x4b, patch bytes [3, 1, 0, 148]
+;; ╰─╼ breakpoint patch: wasm PC 0x4b, patch bytes [28, 1, 0, 148]
;; add sp, sp, #0x20
;; ldp d8, d9, [sp], #0x10
;; ldp d10, d11, [sp], #0x10
@@ -151,29 +151,29 @@
;; 1c4: b #0xe4
;; 1c8: mov w3, #9
;; 1cc: ldur x2, [sp, #0x10]
-;; 1d0: bl #0x464
+;; 1d0: bl #0x478
;; 1d4: ldur x2, [sp, #0x10]
-;; 1d8: bl #0x49c
+;; 1d8: bl #0x4c4
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x42, slot at FP-0xb0, locals , stack I32 @ slot+0x8
;; 1dc: udf #0xc11f
;; 1e0: mov w3, #0xfe
;; 1e4: ldur x2, [sp, #0x10]
-;; 1e8: bl #0x464
+;; 1e8: bl #0x478
;; 1ec: ldur x2, [sp, #0x10]
-;; 1f0: bl #0x49c
+;; 1f0: bl #0x4c4
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack
;; 1f4: udf #0xc11f
;; 1f8: mov w3, #0xfe
;; 1fc: ldur x2, [sp, #0x10]
-;; 200: bl #0x464
+;; 200: bl #0x478
;; 204: ldur x2, [sp, #0x10]
-;; 208: bl #0x49c
+;; 208: bl #0x4c4
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack
;; 20c: udf #0xc11f
;; 210: stur x2, [sp, #0x10]
;; 214: mov w3, #0
-;; 218: bl #0x464
+;; 218: bl #0x478
;; 21c: ldur x2, [sp, #0x10]
-;; 220: bl #0x49c
+;; 220: bl #0x4c4
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x34, slot at FP-0xb0, locals , stack
;; 224: udf #0xc11f
diff --git a/tests/disas/debug.wat b/tests/disas/debug.wat
index c7fa9bea6c..085204fd0a 100644
--- a/tests/disas/debug.wat
+++ b/tests/disas/debug.wat
@@ -23,20 +23,20 @@
;; 29: movq %rdi, (%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x24, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack
-;; ╰─╼ breakpoint patch: wasm PC 0x24, patch bytes [232, 235, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x24, patch bytes [232, 27, 2, 0, 0]
;; movl %edx, 0x10(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x26, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10
-;; ╰─╼ breakpoint patch: wasm PC 0x26, patch bytes [232, 226, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x26, patch bytes [232, 18, 2, 0, 0]
;; movl %ecx, 0x14(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x28, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10, I32 @ slot+0x14
-;; ╰─╼ breakpoint patch: wasm PC 0x28, patch bytes [232, 217, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x28, patch bytes [232, 9, 2, 0, 0]
;; leal (%rdx, %rcx), %eax
;; movl %eax, 0x10(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x29, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10
-;; ╰─╼ breakpoint patch: wasm PC 0x29, patch bytes [232, 205, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x29, patch bytes [232, 253, 1, 0, 0]
;; movl %eax, 0x10(%rsp)
;; movq 0x20(%rsp), %r12
;; addq $0x30, %rsp
@@ -47,7 +47,7 @@
;; 65: xorl %esi, %esi
;; 67: callq 0x1bf
;; 6c: movq %r12, %rdi
-;; 6f: callq 0x1f0
+;; 6f: callq 0x208
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x23, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack
;; 74: ud2
;;
@@ -144,16 +144,21 @@
;; wasmtime_builtin_trap:
;; pushq %rbp
;; movq %rsp, %rbp
-;; movq %rbp, %r10
-;; movq 8(%rdi), %r9
-;; movq %r10, 0x30(%r9)
-;; movq %rbp, %r10
-;; movq 8(%r10), %r11
-;; movq %r11, 0x38(%r9)
+;; subq $0x10, %rsp
+;; movq %r12, (%rsp)
+;; movq %rbp, %r9
+;; movq 8(%rdi), %r12
+;; movq %r9, 0x30(%r12)
+;; movq %rbp, %r9
+;; movq 8(%r9), %r11
+;; movq %r11, 0x38(%r12)
;; movq 0x10(%rdi), %r11
;; movq 0x138(%r11), %r11
;; movzbq %sil, %rsi
;; callq *%r11
+;; addq $1, 0x10(%r12)
+;; movq (%rsp), %r12
+;; addq $0x10, %rsp
;; movq %rbp, %rsp
;; popq %rbp
;; retq
@@ -161,15 +166,20 @@
;; wasmtime_builtin_raise:
;; pushq %rbp
;; movq %rsp, %rbp
-;; movq %rbp, %r9
-;; movq 8(%rdi), %r8
-;; movq %r9, 0x30(%r8)
-;; movq %rbp, %r9
-;; movq 8(%r9), %r9
-;; movq %r9, 0x38(%r8)
+;; subq $0x10, %rsp
+;; movq %r12, (%rsp)
+;; movq %rbp, %r8
+;; movq 8(%rdi), %r12
+;; movq %r8, 0x30(%r12)
+;; movq %rbp, %r8
+;; movq 8(%r8), %r9
+;; movq %r9, 0x38(%r12)
;; movq 0x10(%rdi), %r9
;; movq 0x140(%r9), %r9
;; callq *%r9
+;; addq $1, 0x10(%r12)
+;; movq (%rsp), %r12
+;; addq $0x10, %rsp
;; movq %rbp, %rsp
;; popq %rbp
;; retq
@@ -189,6 +199,7 @@
;; movq %r11, 0x40(%rsp)
;; movq %r12, 0x48(%rsp)
;; movq %r13, 0x50(%rsp)
+;; movq %r14, 0x58(%rsp)
;; movdqu %xmm0, 0x60(%rsp)
;; movdqu %xmm1, 0x70(%rsp)
;; movdqu %xmm2, 0x80(%rsp)
@@ -205,19 +216,20 @@
;; movdqu %xmm13, 0x130(%rsp)
;; movdqu %xmm14, 0x140(%rsp)
;; movdqu %xmm15, 0x150(%rsp)
-;; movq %rbp, %r10
-;; movq 8(%rdi), %r9
-;; movq %r10, 0x30(%r9)
-;; movq %rbp, %r10
-;; movq 8(%r10), %r11
-;; movq %r11, 0x38(%r9)
+;; movq %rbp, %r9
+;; movq 8(%rdi), %r13
+;; movq %r9, 0x30(%r13)
+;; movq %rbp, %r9
+;; movq 8(%r9), %r11
+;; movq %r11, 0x38(%r13)
;; movq 0x10(%rdi), %r12
-;; movq %rdi, %r13
+;; movq %rdi, %r14
;; movq 0x168(%r12), %r11
;; callq *%r11
+;; addq $1, 0x10(%r13)
;; testb %al, %al
-;; je 0x3f4
-;; 320: movq (%rsp), %rax
+;; je 0x433
+;; 35a: movq (%rsp), %rax
;; movq 8(%rsp), %rcx
;; movq 0x10(%rsp), %rdx
;; movq 0x18(%rsp), %rsi
@@ -228,6 +240,7 @@
;; movq 0x40(%rsp), %r11
;; movq 0x48(%rsp), %r12
;; movq 0x50(%rsp), %r13
+;; movq 0x58(%rsp), %r14
;; movdqu 0x60(%rsp), %xmm0
;; movdqu 0x70(%rsp), %xmm1
;; movdqu 0x80(%rsp), %xmm2
@@ -248,7 +261,7 @@
;; movq %rbp, %rsp
;; popq %rbp
;; retq
-;; 3f4: movq 0x140(%r12), %rax
-;; 3fc: movq %r13, %rdi
-;; 3ff: callq *%rax
-;; 401: ud2
+;; 433: movq 0x140(%r12), %rax
+;; 43b: movq %r14, %rdi
+;; 43e: callq *%rax
+;; 440: ud2
diff --git a/tests/disas/issue-12808.wat b/tests/disas/issue-12808.wat
index 6c54a56a79..ab998f292c 100644
--- a/tests/disas/issue-12808.wat
+++ b/tests/disas/issue-12808.wat
@@ -23,23 +23,23 @@
;; 21: movq %rdi, (%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x1f, slot at FP-0x30, locals , stack
-;; ╰─╼ breakpoint patch: wasm PC 0x1f, patch bytes [232, 21, 2, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x1f, patch bytes [232, 69, 2, 0, 0]
;; movl $0, 8(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x21, slot at FP-0x30, locals , stack I32 @ slot+0x8
-;; ╰─╼ breakpoint patch: wasm PC 0x21, patch bytes [232, 8, 2, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x21, patch bytes [232, 56, 2, 0, 0]
;; movl $0, 0xc(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x23, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc
-;; ╰─╼ breakpoint patch: wasm PC 0x23, patch bytes [232, 251, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x23, patch bytes [232, 43, 2, 0, 0]
;; movl $0, 0x10(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x25, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc, I32 @ slot+0x10
-;; ╰─╼ breakpoint patch: wasm PC 0x25, patch bytes [232, 238, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x25, patch bytes [232, 30, 2, 0, 0]
;; movl $0, 0x14(%rsp)
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x27, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc, I32 @ slot+0x10, I32 @ slot+0x14
-;; ╰─╼ breakpoint patch: wasm PC 0x27, patch bytes [232, 225, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x27, patch bytes [232, 17, 2, 0, 0]
;; movq 0x30(%rdi), %rax
;; movq (%rax), %rcx
;; xorl %eax, %eax
@@ -48,7 +48,7 @@
;; movq %rax, %rcx
;; nopl (%rax, %rax)
;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x2b, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc
-;; ╰─╼ breakpoint patch: wasm PC 0x2b, patch bytes [232, 200, 1, 0, 0]
+;; ╰─╼ breakpoint patch: wasm PC 0x2b, patch bytes [232, 248, 1, 0, 0]
;; xorl %eax, %eax
;; movl $0, 8(%rsp)
;; movl %ecx, 0xc(%rsp)
@@ -61,6 +61,6 @@
;; 96: xorl %esi, %esi
;; 98: callq 0x1e1
;; 9d: movq %r14, %rdi
-;; a0: callq 0x212
+;; a0: callq 0x22a
;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x1e, slot at FP-0x30, locals , stack
;; a5: ud2