diff --git a/Cargo.toml b/Cargo.toml
index ff504efa3d12..32b62fe5754c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -532,6 +532,11 @@ default = [
 #
 # These features are off-by-default but may optionally be enabled.
 all-arch = ["wasmtime/all-arch"]
+# Internal feature ensuring async runtime support is compiled in. Features that
+# require async (like `run`, `wizer`, and `serve`) forward to this, giving
+# `build.rs` a single, stable feature to check rather than chasing which
+# top-level features happen to pull in async support.
+async = ["wasmtime-cli-flags/async"]
 winch = ["wasmtime/winch"]
 wmemcheck = ["wasmtime/wmemcheck"]
 trace-log = ["wasmtime/trace-log"]
@@ -604,7 +609,7 @@ serve = [
   "dep:http-body-util",
   "dep:http",
   "dep:pin-project-lite",
-  "wasmtime-cli-flags/async",
+  "async",
   "wasmtime-wasi-http?/p2",
 ]
 explore = ["dep:wasmtime-explorer", "dep:tempfile"]
@@ -616,7 +621,7 @@ run = [
   "wasmtime/runtime",
   "wasmtime/wave",
   "dep:tokio",
-  "wasmtime-cli-flags/async",
+  "async",
   "wasmtime-wasi-http?/p2",
   "dep:wasmtime-debugger",
 ]
@@ -639,6 +644,10 @@ wizer = [
   "dep:wasmtime-wasi",
   "dep:tokio",
   "wasmtime/wave",
+  # dep:wasmtime-wasi transitively enables wasmtime-cli-flags/async, but making
+  # it explicit here makes the expression determining the has_mmu_interruption
+  # cfg flag's value clear.
+  "async",
 ]
 
 [[test]]
diff --git a/build.rs b/build.rs
index a5416e6674cc..629c0525d637 100644
--- a/build.rs
+++ b/build.rs
@@ -14,6 +14,21 @@ fn main() {
         }
         _ => {}
     }
+
+    // Mirror the `has_mmu_interruption` cfg in `crates/wasmtime/build.rs`.
+    //
+    // We can omit the `std` check here, because `wasmtime` is always built with
+    // `std` from this crate.
+    println!("cargo:rustc-check-cfg=cfg(has_mmu_interruption)");
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    if target_os == "linux"
+        && (target_arch == "x86_64" || target_arch == "aarch64")
+        && cfg!(feature = "cranelift")
+        && cfg!(feature = "async")
+    {
+        println!("cargo:rustc-cfg=has_mmu_interruption");
+    }
 }
 
 fn set_commit_info_for_rustc() {
diff --git a/cranelift/codegen/meta/src/cdsl/instructions.rs b/cranelift/codegen/meta/src/cdsl/instructions.rs
index 2711bfe08af8..94bea9961d1d 100644
--- a/cranelift/codegen/meta/src/cdsl/instructions.rs
+++ b/cranelift/codegen/meta/src/cdsl/instructions.rs
@@ -131,7 +131,7 @@ pub(crate) struct InstructionBuilder {
     operands_in: Option<Vec<Operand>>,
     operands_out: Option<Vec<Operand>>,
 
-    // See Instruction comments for the meaning of these fields.
+    // See InstructionContent comments for the meaning of these fields.
     is_terminator: bool,
     is_branch: bool,
     is_call: bool,
diff --git a/cranelift/codegen/meta/src/shared/instructions.rs b/cranelift/codegen/meta/src/shared/instructions.rs
index 4a08164068f2..e2ef8b253ed9 100644
--- a/cranelift/codegen/meta/src/shared/instructions.rs
+++ b/cranelift/codegen/meta/src/shared/instructions.rs
@@ -380,6 +380,43 @@ fn define_control_flow(
         .call()
         .branches(),
     );
+
+    ig.push(
+        Inst::new(
+            "dead_load_with_context",
+            r#"
+        Load a pointer-sized value from memory at ``load_ptr`` while also
+        keeping ``context`` in a fixed register and reserving a second as
+        scratch space.
+
+        This is intended for implementing MMU-triggered jumps as in
+        `mmu-interruption`, where the load conditionally triggers a
+        segfault, which hands off control to a signal handler for further
+        action. The handler has access to ``context`` (typically the
+        ``VMContext``'s ``vm_store_context``) and can use the second
+        reserved register to store a temp value--like the original return
+        value--as needed on platforms where signal handlers cannot push stack
+        frames.
+
+        Which registers these are is ISA-specific; see each backend's
+        ``get_operands`` for the choices and the reasoning behind them.
+        "#,
+            &formats.binary,
+        )
+        .operands_in(vec![
+            Operand::new("load_ptr", iAddr).with_doc("memory location to load from"),
+            Operand::new("context", iAddr)
+                .with_doc("arbitrary address-sized context to pass to signal handler"),
+        ])
+        // Are we a call? stack_switch calls itself one "as it continues
+        // execution elsewhere". See reasoning at
+        // https://github.com/bytecodealliance/wasmtime/pull/9078#issuecomment-2273869774.
+        .call()
+        .can_load()
+        // Don't optimize me out just because I don't def anything. TODO: Can we use side_effects_idempotent()?
+        .other_side_effects(),
+        // If `load` is not can_trap(), this isn't either.
+    );
 }
 
 #[inline(never)]
diff --git a/cranelift/codegen/src/ir/instructions.rs b/cranelift/codegen/src/ir/instructions.rs
index d0d28365c8b3..8d060efd5246 100644
--- a/cranelift/codegen/src/ir/instructions.rs
+++ b/cranelift/codegen/src/ir/instructions.rs
@@ -616,9 +616,13 @@ impl InstructionData {
             Self::Ternary {
                 opcode: Opcode::StackSwitch,
                 ..
+            }
+            | Self::Binary {
+                opcode: Opcode::DeadLoadWithContext,
+                ..
             } => {
-                // `StackSwitch` is not actually a call, but has the .call() side
-                // effect as it continues execution elsewhere.
+                // These instructions aren't actually calls, but they have the
+                // .call() side effect, as they continue execution elsewhere.
                 CallInfo::NotACall
             }
             _ => {
diff --git a/cranelift/codegen/src/isa/aarch64/inst.isle b/cranelift/codegen/src/isa/aarch64/inst.isle
index 1a7ca003a580..3bc56ea05430 100644
--- a/cranelift/codegen/src/isa/aarch64/inst.isle
+++ b/cranelift/codegen/src/isa/aarch64/inst.isle
@@ -1013,7 +1013,13 @@
        ;; means that the internal codegen can't use these registers.
        (StackProbeLoop (start WritableReg)
                        (end Reg)
-                       (step Imm12))))
+                       (step Imm12))
+
+       ;; A load whose result is discarded; `context` is pinned to x0 and `dst`
+       ;; to x9.
+       (DeadLoadWithContext (dst WritableReg)
+                            (load_ptr Reg)
+                            (context Reg))))
 
 (spec (MInst.AluRRImmLogic alu_op size rd rn imml)
       (provide
diff --git a/cranelift/codegen/src/isa/aarch64/inst/emit.rs b/cranelift/codegen/src/isa/aarch64/inst/emit.rs
index 0c261c267e56..f010ad87e6ba 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/emit.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/emit.rs
@@ -3633,6 +3633,27 @@ impl MachInstEmit for Inst {
                 .emit(sink, emit_info, state);
                 sink.bind_label(loop_end, &mut state.ctrl_plane);
             }
+
+            &Inst::DeadLoadWithContext { dst, load_ptr, .. } => {
+                let start = sink.cur_offset();
+
+                // Emit `ldr dst, [load_ptr]`. Reuse the `dst` address as the
+                // destination of the dead load, since we are clobbering it
+                // anyway.
+                Inst::ULoad64 {
+                    rd: dst,
+                    mem: AMode::UnsignedOffset {
+                        rn: load_ptr,
+                        uimm12: UImm12Scaled::zero(I64),
+                    },
+                    flags: MemFlagsData::trusted(),
+                }
+                .emit(sink, emit_info, state);
+
+                // Mark the address of this instruction as part of mmu
+                // interrupt.
+                sink.add_mmu_interrupt_check(start, sink.cur_offset());
+            }
         }
 
         let end_off = sink.cur_offset();
diff --git a/cranelift/codegen/src/isa/aarch64/inst/mod.rs b/cranelift/codegen/src/isa/aarch64/inst/mod.rs
index 2c325cbc4901..c0c87d6886cd 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/mod.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/mod.rs
@@ -926,6 +926,25 @@ fn aarch64_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
             collector.reg_early_def(start);
             collector.reg_use(end);
         }
+        Inst::DeadLoadWithContext {
+            dst,
+            load_ptr,
+            context,
+        } => {
+            // `load_ptr` is an ordinary input.
+            collector.reg_use(load_ptr);
+            // Demand `context` (the vmctx) go into x0, where the signal
+            // handler can find it and hand it straight to
+            // `task_switch_trampoline` as its first argument.
+            collector.reg_fixed_use(context, regs::xreg(0));
+            // Reserve x9 as a place for the signal handler to put the address
+            // at which to resume once the task switch is done. x9 is caller
+            // saved and has no special role.
+            //
+            // Define it, so we can use it as the destination of the dead
+            // load rather than consuming another arbitrary reg.
+            collector.reg_fixed_def(dst, regs::xreg(9));
+        }
     }
 }
 
@@ -2929,6 +2948,16 @@ impl Inst {
                 let step = step.pretty_print(0);
                 format!("stack_probe_loop {start}, {end}, {step}")
             }
+            &Inst::DeadLoadWithContext {
+                dst,
+                load_ptr,
+                context,
+            } => {
+                let dst = pretty_print_reg(dst.to_reg());
+                let load_ptr = pretty_print_reg(load_ptr);
+                let context = pretty_print_reg(context);
+                format!("dead_load_with_context {dst}, {load_ptr}, {context}")
+            }
         }
     }
 }
diff --git a/cranelift/codegen/src/isa/aarch64/lower.isle b/cranelift/codegen/src/isa/aarch64/lower.isle
index 8073e4a851ee..bea82c3cd5b2 100644
--- a/cranelift/codegen/src/isa/aarch64/lower.isle
+++ b/cranelift/codegen/src/isa/aarch64/lower.isle
@@ -2440,6 +2440,18 @@
 (rule (lower (symbol_value _ (symbol_value_data extname dist offset)))
       (load_ext_name (box_external_name extname) offset dist))
 
+;;;; Rules for `dead_load_with_context` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (dead_load_with_context load_ptr context))
+      (let ((load_ptr Reg (put_in_reg load_ptr))
+            (context Reg (put_in_reg context))
+            (dst WritableReg (temp_writable_reg $I64))
+            (_ Unit (emit_side_effect (SideEffectNoResult.Inst
+                  (MInst.DeadLoadWithContext dst
+                                             load_ptr
+                                             context)))))
+       (output_none)))
+
 ;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;;
 
 (rule (lower (get_frame_pointer _))
diff --git a/cranelift/codegen/src/isa/x64/inst.isle b/cranelift/codegen/src/isa/x64/inst.isle
index e1104520d6f9..ab4af6559c80 100644
--- a/cranelift/codegen/src/isa/x64/inst.isle
+++ b/cranelift/codegen/src/isa/x64/inst.isle
@@ -52,7 +52,7 @@
        ;; =========================================
        ;; Stack manipulation.
 
-      ;; Emits a inline stack probe loop.
+      ;; Emits an inline stack probe loop.
       (StackProbeLoop (tmp WritableReg)
                       (frame_size u32)
                       (guard_size u32))
@@ -194,6 +194,10 @@
                     (offset i64)
                     (distance RelocDistance))
 
+       (DeadLoadWithContext (dst WritableGpr)
+                            (load_ptr Gpr)
+                            (context Gpr))
+
        ;; =========================================
        ;; Instructions pertaining to atomic memory accesses.
 
diff --git a/cranelift/codegen/src/isa/x64/inst/emit.rs b/cranelift/codegen/src/isa/x64/inst/emit.rs
index 7f6f1aeb763d..10d89ad98660 100644
--- a/cranelift/codegen/src/isa/x64/inst/emit.rs
+++ b/cranelift/codegen/src/isa/x64/inst/emit.rs
@@ -645,6 +645,20 @@ pub(crate) fn emit(
             sink.bind_label(resume, state.ctrl_plane_mut());
         }
 
+        Inst::DeadLoadWithContext { dst, load_ptr, .. } => {
+            let start = sink.cur_offset();
+
+            let load_ptr_addr = SyntheticAmode::real(Amode::imm_reg(0, **load_ptr));
+            // Since we're clobbering dst anyway to store the original return
+            // address, also use it as a destination for the dead load rather
+            // than sucking up another reg:
+            asm::inst::movq_rm::new(*dst, load_ptr_addr).emit(sink, info, state);
+
+            // Put the address of this instruction aside so we can later
+            // distinguish whether a segfault is its fault.
+            sink.add_mmu_interrupt_check(start, sink.cur_offset());
+        }
+
         Inst::JmpKnown { dst } => uncond_jmp(sink, *dst),
 
         Inst::WinchJmpIf { cc, taken } => one_way_jmp(sink, *cc, *taken),
diff --git a/cranelift/codegen/src/isa/x64/inst/mod.rs b/cranelift/codegen/src/isa/x64/inst/mod.rs
index 37e79b2faebc..1ae7d681c3ea 100644
--- a/cranelift/codegen/src/isa/x64/inst/mod.rs
+++ b/cranelift/codegen/src/isa/x64/inst/mod.rs
@@ -96,6 +96,7 @@ impl Inst {
             | Inst::Args { .. }
             | Inst::Rets { .. }
             | Inst::StackSwitchBasic { .. }
+            | Inst::DeadLoadWithContext { .. }
             | Inst::TrapIf { .. }
             | Inst::TrapIfAnd { .. }
             | Inst::TrapIfOr { .. }
@@ -671,6 +672,17 @@ impl PrettyPrint for Inst {
                 )
             }
 
+            Inst::DeadLoadWithContext {
+                dst,
+                load_ptr,
+                context,
+            } => {
+                let dst = pretty_print_reg(*dst.to_reg(), 8);
+                let load_ptr = pretty_print_reg(**load_ptr, 8);
+                let context = pretty_print_reg(**context, 8);
+                format!("dead_load_with_context {dst}, {load_ptr}, {context}")
+            }
+
             Inst::JmpKnown { dst } => {
                 let op = ljustify("jmp".to_string());
                 let dst = dst.to_string();
@@ -1051,6 +1063,30 @@ fn x64_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
             collector.reg_clobbers(clobbers);
         }
 
+        Inst::DeadLoadWithContext {
+            dst,
+            load_ptr,
+            context,
+        } => {
+            // load_ptr is an input param.
+            collector.reg_use(load_ptr);
+            // Demand context (vmctx) go into RDI.
+            collector.reg_fixed_use(context, regs::rdi());
+            // Reserve r10 as a place for the signal handler to stow the return
+            // address (which we're overwriting with that of the epoch-ending
+            // stub). Picking r10 because it's caller-saved and not used for arg
+            // passing in Linux/x64. It is used as "a static chain pointer
+            // in case of nested functions" according to SystemV, but that's
+            // inapplicable to compiled Wasm code. It is also used to store the
+            // function stack limit in Cranelift, but the stack-limit check is
+            // over by the time we need r10, in the case of the use of this
+            // instruction for MMU-based epoch interruption.
+            //
+            // Also def it so we can use it as the destination of the dead load
+            // rather than consuming another arbitrary reg.
+            collector.reg_fixed_def(dst, regs::r10());
+        }
+
         Inst::ReturnCallKnown { info } => {
             let ReturnCallInfo {
                 dest, uses, tmp, ..
diff --git a/cranelift/codegen/src/isa/x64/lower.isle b/cranelift/codegen/src/isa/x64/lower.isle
index 8a3c511c2699..08f258659d53 100644
--- a/cranelift/codegen/src/isa/x64/lower.isle
+++ b/cranelift/codegen/src/isa/x64/lower.isle
@@ -3582,6 +3582,18 @@
             (in_payload0 Gpr (put_in_gpr in_payload0)))
         (x64_stack_switch_basic store_context_ptr load_context_ptr in_payload0)))
 
+;;;; Rules for `dead_load_with_context` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (dead_load_with_context load_ptr context))
+      (let ((load_ptr Gpr (put_in_gpr load_ptr))
+            (context Gpr (put_in_gpr context))
+            (dst WritableGpr (temp_writable_gpr))
+            (_ Unit (emit_side_effect (SideEffectNoResult.Inst
+                  (MInst.DeadLoadWithContext dst
+                                             load_ptr
+                                             context)))))
+       (output_none)))
+
 ;;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;
 
 (rule (lower (get_frame_pointer _))
diff --git a/cranelift/codegen/src/isle_prelude.rs b/cranelift/codegen/src/isle_prelude.rs
index ea5e60745b21..a93ac2a4a6b6 100644
--- a/cranelift/codegen/src/isle_prelude.rs
+++ b/cranelift/codegen/src/isle_prelude.rs
@@ -826,6 +826,14 @@ macro_rules! isle_common_prelude_methods {
                 .expect("trusted MemFlagsData not found in DFG")
         }
 
+        #[inline]
+        fn mem_flags_aligned_read_only(&mut self) -> MemFlags {
+            self.dfg()
+                .mem_flags
+                .get(MemFlagsData::new().with_aligned().with_readonly())
+                .expect("aligned, read-only MemFlagsData not found in DFG")
+        }
+
         #[inline]
         fn mem_flags_data(&mut self, flags: MemFlags) -> Option<MemFlagsData> {
             Some(self.dfg().mem_flags[flags])
diff --git a/cranelift/codegen/src/machinst/buffer.rs b/cranelift/codegen/src/machinst/buffer.rs
index fba4ee3d81dc..9002d4685979 100644
--- a/cranelift/codegen/src/machinst/buffer.rs
+++ b/cranelift/codegen/src/machinst/buffer.rs
@@ -280,6 +280,8 @@ pub struct MachBuffer<I: VCodeInst> {
     call_sites: SmallVec<[MachCallSite; 16]>,
     /// Any patchable call site locations.
     patchable_call_sites: SmallVec<[MachPatchableCallSite; 16]>,
+    /// Any locations which trigger MMU-based interruptions.
+    mmu_interrupt_checks: SmallVec<[Range<CodeOffset>; 16]>,
     /// Any exception-handler records referred to at call sites.
     exception_handlers: SmallVec<[MachExceptionHandler; 16]>,
     /// Any source location mappings referring to this code.
@@ -371,6 +373,7 @@ impl MachBufferFinalized<Stencil> {
             traps: self.traps,
             call_sites: self.call_sites,
             patchable_call_sites: self.patchable_call_sites,
+            mmu_interrupt_checks: self.mmu_interrupt_checks,
             exception_handlers: self.exception_handlers,
             srclocs: self
                 .srclocs
@@ -408,6 +411,8 @@ pub struct MachBufferFinalized<T: CompilePhase> {
     pub(crate) call_sites: SmallVec<[MachCallSite; 16]>,
     /// Any patchable call site locations referring to this code.
     pub(crate) patchable_call_sites: SmallVec<[MachPatchableCallSite; 16]>,
+    /// Any locations which trigger MMU-based interruptions.
+    pub mmu_interrupt_checks: SmallVec<[Range<CodeOffset>; 16]>,
     /// Any exception-handler records referred to at call sites.
     pub(crate) exception_handlers: SmallVec<[FinalizedMachExceptionHandler; 16]>,
     /// Any source location mappings referring to this code.
@@ -508,6 +513,7 @@ impl<I: VCodeInst> MachBuffer<I> {
             traps: SmallVec::new(),
             call_sites: SmallVec::new(),
             patchable_call_sites: SmallVec::new(),
+            mmu_interrupt_checks: SmallVec::new(),
             exception_handlers: SmallVec::new(),
             srclocs: SmallVec::new(),
             debug_tags: vec![],
@@ -1669,6 +1675,7 @@ impl<I: VCodeInst> MachBuffer<I> {
             traps: self.traps,
             call_sites: self.call_sites,
             patchable_call_sites: self.patchable_call_sites,
+            mmu_interrupt_checks: self.mmu_interrupt_checks,
             exception_handlers: finalized_exception_handlers,
             srclocs,
             debug_tags: self.debug_tags,
@@ -1773,7 +1780,7 @@ impl<I: VCodeInst> MachBuffer<I> {
         });
     }
 
-    /// Add a patchable call record at the current offset The actual
+    /// Add a patchable call record at the current offset. The actual
     /// call is expected to have been emitted; the VCodeInst trait
     /// specifies how to NOP it out, and we carry that information to
     /// the finalized Machbuffer.
@@ -1784,6 +1791,16 @@ impl<I: VCodeInst> MachBuffer<I> {
         });
     }
 
+    /// Record that an MMU-based interruption check occurs at the current
+    /// offset. A signal handler may use these annotations to distinguish that a
+    /// segfault is actually an MMU-triggered interruption in disguise. The
+    /// DeadLoadWithContext instruction is assumed to have already been emitted.
+    /// `start` is the offset of the emitted instruction, and `end` is the
+    /// offset of the immediately following instruction.
+    pub fn add_mmu_interrupt_check(&mut self, start: CodeOffset, end: CodeOffset) {
+        self.mmu_interrupt_checks.push(start..end);
+    }
+
     /// Add an unwind record at the current offset.
     pub fn add_unwind(&mut self, unwind: UnwindInst) {
         self.unwind_info.push((self.cur_offset(), unwind));
diff --git a/cranelift/codegen/src/prelude.isle b/cranelift/codegen/src/prelude.isle
index 2b779010ac6c..c406a9e7019d 100644
--- a/cranelift/codegen/src/prelude.isle
+++ b/cranelift/codegen/src/prelude.isle
@@ -356,6 +356,12 @@
 (decl mem_flags_trusted () MemFlags)
 (extern constructor mem_flags_trusted mem_flags_trusted)
 
+(spec (mem_flags_aligned_read_only)
+      (provide (:aligned result)))
+      ;; There is no readonly field defined in MemFlags yet.
+(decl mem_flags_aligned_read_only () MemFlags)
+(extern constructor mem_flags_aligned_read_only mem_flags_aligned_read_only)
+
 ;; Resolve a MemFlags entity to its MemFlagsData.
 (decl mem_flags_data (MemFlagsData) MemFlags)
 (extern extractor mem_flags_data mem_flags_data)
diff --git a/cranelift/docs/ir.md b/cranelift/docs/ir.md
index d5e56355f2b9..b86edcacefac 100644
--- a/cranelift/docs/ir.md
+++ b/cranelift/docs/ir.md
@@ -643,7 +643,7 @@ slot on the stack for its entire live range. Since the live range of an SSA
 value can be quite large, it is sometimes beneficial to split the live range
 into smaller parts.
 
-A live range is split by creating new SSA values that are copies or the
+A live range is split by creating new SSA values that are copies of the
 original value or each other. The copies are created by inserting `copy`,
 `spill`, or `fill` instructions, depending on whether the values
 are assigned to registers or stack slots.
diff --git a/cranelift/interpreter/src/step.rs b/cranelift/interpreter/src/step.rs
index 8e4c5bd1dea7..8e7c4fb84a5f 100644
--- a/cranelift/interpreter/src/step.rs
+++ b/cranelift/interpreter/src/step.rs
@@ -1303,6 +1303,7 @@ where
         Opcode::X86Pmaddubsw => unimplemented!("X86Pmaddubsw"),
         Opcode::X86Cvtt2dq => unimplemented!("X86Cvtt2dq"),
         Opcode::StackSwitch => unimplemented!("StackSwitch"),
+        Opcode::DeadLoadWithContext => unimplemented!("DeadLoadWithContext"),
 
         Opcode::TryCall => unimplemented!("TryCall"),
         Opcode::TryCallIndirect => unimplemented!("TryCallIndirect"),
diff --git a/crates/cli-flags/src/lib.rs b/crates/cli-flags/src/lib.rs
index 9333c256cd97..877fa295fa81 100644
--- a/crates/cli-flags/src/lib.rs
+++ b/crates/cli-flags/src/lib.rs
@@ -351,6 +351,10 @@ wasmtime_option_group! {
         /// Yield when a global epoch counter changes, allowing for async
         /// operation without blocking the executor.
         pub epoch_interruption: Option<bool>,
+        /// Use MMU privileges and a special signal handler to trigger async
+        /// Yields. Should be more efficient than epoch-interruption, where
+        /// supported.
+        pub mmu_interruption: Option<bool>,
         /// Maximum stack size, in bytes, that wasm is allowed to consume before a
         /// stack overflow is reported.
         pub max_wasm_stack: Option<usize>,
@@ -1003,6 +1007,9 @@ impl CommonOptions {
         if let Some(enable) = self.wasm.epoch_interruption {
             config.epoch_interruption(enable);
         }
+        if let Some(enable) = self.wasm.mmu_interruption {
+            config.mmu_interruption(enable);
+        }
         if let Some(enable) = self.debug.address_map {
             config.generate_address_map(enable);
         }
@@ -1474,6 +1481,7 @@ impl CommonOptions {
                 wide_arithmetic: Some(features.contains(WasmFeatures::WIDE_ARITHMETIC)),
                 concurrency_support: Some(engine.get_concurrency_support()),
                 epoch_interruption: Some(engine.get_epoch_interruption()),
+                mmu_interruption: Some(engine.get_mmu_interruption()),
                 fuel: if engine.get_consume_fuel() {
                     Some(1)
                 } else {
diff --git a/crates/cranelift/src/alias_region.rs b/crates/cranelift/src/alias_region.rs
index 8e92a96360dd..6b7e8b4a5102 100644
--- a/crates/cranelift/src/alias_region.rs
+++ b/crates/cranelift/src/alias_region.rs
@@ -1232,6 +1232,24 @@ where
         )
     }
 
+    /// Load the `VMStoreContext::mmu_interrupt_page_ptr` field.
+    pub fn vmstore_context_mmu_interrupt_page_ptr(
+        &mut self,
+        cursor: &mut FuncCursor<'_>,
+        vmstore_ctx: ir::Value,
+    ) -> ir::Value {
+        self.vmstore_context_load(
+            cursor,
+            self.pointer_type,
+            ir::MemFlagsData::trusted(),
+            vmstore_ctx,
+            self.offsets
+                .get_ptr_size()
+                .vmstore_context_mmu_interrupt_page_ptr()
+                .into(),
+        )
+    }
+
     /// Get a `Load` for the `VmStoreContext::stack_limits` field.
     pub fn vmstore_context_stack_limit_load(&mut self, func: &mut ir::Function) -> Load {
         let offset = self
diff --git a/crates/cranelift/src/builder.rs b/crates/cranelift/src/builder.rs
index ca3358caea63..afbe4b8e1922 100644
--- a/crates/cranelift/src/builder.rs
+++ b/crates/cranelift/src/builder.rs
@@ -12,7 +12,7 @@ use std::fmt;
 use std::path;
 use std::sync::Arc;
 use target_lexicon::Triple;
-use wasmtime_environ::error::Result;
+use wasmtime_environ::error::{Result, bail};
 use wasmtime_environ::{CacheStore, CompilerBuilder, Setting, Tunables};
 
 struct Builder {
@@ -108,6 +108,20 @@ impl CompilerBuilder for Builder {
     }
 
     fn set_tunables(&mut self, tunables: Tunables) -> Result<()> {
+        if tunables.mmu_interruption
+            && !matches!(
+                self.inner.triple().architecture,
+                target_lexicon::Architecture::X86_64
+                    | target_lexicon::Architecture::X86_64h
+                    | target_lexicon::Architecture::Aarch64(_)
+            )
+        {
+            bail!(
+                "MMU interruption is supported only on x86_64 and aarch64, not for `{}`",
+                self.inner.triple()
+            );
+        }
+
         self.tunables = Some(tunables);
         Ok(())
     }
diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rs
index 5f3fdee1c6e0..6139d53bac18 100644
--- a/crates/cranelift/src/compiler.rs
+++ b/crates/cranelift/src/compiler.rs
@@ -41,9 +41,9 @@ use wasmtime_environ::{
     Abi, AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, CompiledFunctionBody,
     DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameStateSlotBuilder,
     FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, GetPtrSize, HostCall,
-    InliningCompiler, ModulePC, ModuleStartup, ModuleTranslation, ModuleTypesBuilder,
-    StackMapSection, StaticModuleIndex, TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables,
-    WasmFuncType, WasmValType, prelude::*,
+    InliningCompiler, MmuInterruptCheckSection, ModulePC, ModuleStartup, ModuleTranslation,
+    ModuleTypesBuilder, StackMapSection, StaticModuleIndex, TrapEncodingBuilder, TrapSentinel,
+    TripleExt, Tunables, WasmFuncType, WasmValType, prelude::*,
 };
 use wasmtime_unwinder::ExceptionTableBuilder;
 
@@ -688,6 +688,7 @@ impl wasmtime_environ::Compiler for Compiler {
         let mut stack_maps = StackMapSection::default();
         let mut exception_tables = ExceptionTableBuilder::default();
         let mut frame_tables = FrameTableBuilder::default();
+        let mut mmu_interrupt_checks = MmuInterruptCheckSection::default();
 
         let funcs = funcs
             .iter()
@@ -759,6 +760,9 @@ impl wasmtime_environ::Compiler for Compiler {
                 )?;
                 nop_units.get_or_insert_with(|| func.buffer.nop_units.clone());
             }
+            if self.tunables.mmu_interruption {
+                mmu_interrupt_checks.push(range.clone(), &func.buffer.mmu_interrupt_checks);
+            }
             builder.append_padding(self.linkopts.padding_between_functions);
 
             let info = FunctionLoc {
@@ -805,6 +809,9 @@ impl wasmtime_environ::Compiler for Compiler {
         }
         stack_maps.append_to(obj);
         traps.append_to(obj);
+        if self.tunables.mmu_interruption {
+            mmu_interrupt_checks.append_to(obj);
+        }
 
         let exception_section = obj.add_section(
             obj.segment_name(StandardSegment::Data).to_vec(),
diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs
index e791c092c2ab..309fd241a0ad 100644
--- a/crates/cranelift/src/func_environ.rs
+++ b/crates/cranelift/src/func_environ.rs
@@ -192,6 +192,10 @@ pub struct FuncEnvironment<'module_environment> {
     /// any yield.
     epoch_deadline_var: cranelift_frontend::Variable,
 
+    // A cached pointer to the MMU-interrupt page so we don't have to
+    // continually dig it out of the `VMStoreContext`
+    mmu_interrupt_page_ptr_var: cranelift_frontend::Variable,
+
     /// A cached pointer to the per-Engine epoch counter, when
     /// performing epoch-based interruption. Initialized in the
     /// function prologue. We prefer to use a variable here rather
@@ -290,6 +294,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             fuel_var: Variable::reserved_value(),
             epoch_deadline_var: Variable::reserved_value(),
             epoch_ptr_var: Variable::reserved_value(),
+            mmu_interrupt_page_ptr_var: Variable::reserved_value(),
 
             // Start with at least one fuel being consumed because even empty
             // functions should consume at least some fuel.
@@ -460,7 +465,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
-    /// Get the `*mut VMStoreContext` value for our `VMContext`.
+    /// Codegens and returns the `*mut VMStoreContext` value for our `VMContext`.
     fn get_vmstore_context_ptr(&mut self, builder: &mut FunctionBuilder) -> ir::Value {
         let vmctx = self.vmctx_val(&mut builder.cursor());
         self.alias_regions
@@ -710,6 +715,38 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         self.epoch_check_full(builder, cur_epoch_value, continuation_block);
     }
 
+    /// Codegens what needs to go at the top of a function to support
+    /// `mmu-interruption`.
+    fn mmu_interrupt_function_entry(&mut self, builder: &mut FunctionBuilder<'_>) {
+        debug_assert!(self.mmu_interrupt_page_ptr_var.is_reserved_value());
+        self.mmu_interrupt_page_ptr_var = builder.declare_var(self.pointer_type());
+
+        // Cache ptr to interrupt page in a local (and hopefully a register, at
+        // the discretion of regalloc), rather than digging it out of the
+        // `VMStoreContext` every time.
+        let vmstore_ctx = self.get_vmstore_context_ptr(builder);
+        let mmu_interrupt_page_ptr = self
+            .alias_regions
+            .vmstore_context_mmu_interrupt_page_ptr(&mut builder.cursor(), vmstore_ctx);
+        builder.def_var(self.mmu_interrupt_page_ptr_var, mmu_interrupt_page_ptr);
+
+        self.mmu_interrupt_check(mmu_interrupt_page_ptr, builder);
+    }
+
+    /// Codegens a dead load from the MMU-interrupt page, which causes a trap
+    /// if an interrupt is due.
+    fn mmu_interrupt_check(
+        &mut self,
+        mmu_interrupt_page_ptr: ir::Value,
+        builder: &mut FunctionBuilder<'_>,
+    ) {
+        let vmctx = self.vmctx_val(&mut builder.cursor());
+        let _ = builder
+            .ins()
+            .dead_load_with_context(mmu_interrupt_page_ptr, vmctx);
+    }
+
+    #[cfg(feature = "wmemcheck")]
     fn hook_malloc_exit(&mut self, builder: &mut FunctionBuilder, retvals: &[ir::Value]) {
         let check_malloc = self.builtin_functions.check_malloc(builder.func);
         let vmctx = self.vmctx_val(&mut builder.cursor());
@@ -5146,6 +5183,12 @@ impl FuncEnvironment<'_> {
             self.epoch_check(builder);
         }
 
+        // If we're using MMU interruption, provoke an interrupt if it's time.
+        if self.tunables.mmu_interruption {
+            let page_ptr = builder.use_var(self.mmu_interrupt_page_ptr_var);
+            self.mmu_interrupt_check(page_ptr, builder);
+        }
+
         Ok(())
     }
 
@@ -5214,6 +5257,10 @@ impl FuncEnvironment<'_> {
             self.epoch_function_entry(builder);
         }
 
+        if self.tunables.mmu_interruption {
+            self.mmu_interrupt_function_entry(builder);
+        }
+
         if self.compiler.wmemcheck {
             let func_name = self.current_func_name(builder);
             if func_name == Some("malloc") {
diff --git a/crates/environ/src/compile/frame_table.rs b/crates/environ/src/compile/frame_table.rs
index f3288f08f121..b2c47f87ee3f 100644
--- a/crates/environ/src/compile/frame_table.rs
+++ b/crates/environ/src/compile/frame_table.rs
@@ -330,7 +330,7 @@ impl FrameTableBuilder {
             .push(U32::new(LittleEndian, end));
     }
 
-    /// Serialize the framd-table data section, taking a closure to
+    /// Serialize the frame-table data section, taking a closure to
     /// consume slices.
     pub fn serialize<F: FnMut(&[u8])>(&mut self, mut f: F) {
         // Pad `frame_descriptor_data` to a multiple of 4 bytes so
diff --git a/crates/environ/src/compile/mmu_interrupt_checks.rs b/crates/environ/src/compile/mmu_interrupt_checks.rs
new file mode 100644
index 000000000000..aecd3728140a
--- /dev/null
+++ b/crates/environ/src/compile/mmu_interrupt_checks.rs
@@ -0,0 +1,158 @@
+//! Emission of compiled-artifact metadata describing where interrupt checks
+//! occur in the code when using MMU interruption. This lets the signal handler
+//! distinguish requested interruptions from general segfaults.
+
+use crate::obj::ELF_WASMTIME_MMU_INTERRUPT_CHECKS;
+use crate::prelude::*;
+use object::SectionKind;
+use object::write::{Object, StandardSegment};
+use std::ops::Range;
+
+/// Offset of an MMU-interrupt check (in bytes) within the text section.
+/// Specifically, this points to the load instruction that may trigger the
+/// segfault.
+///
+/// This is parallel to cranelift's CodeOffset and exists to (1) avoid making it
+/// a dependency, (2) pin it down to <= 32 bits, since the format of the
+/// custom-section we're emitting depends on that, and (3) hold documentation.
+type MmuInterruptCheckOffset = u32;
+
+/// A builder and emitter of the custom section which houses
+/// MMU-interrupt-check locations in a native binary.
+#[derive(Default)]
+pub struct MmuInterruptCheckSection {
+    /// Offset of the start of the load instruction which effects the
+    /// interruption
+    starts: Vec<u32>,
+    /// Packed bits, parallel to elements of `starts`, which tell the length of
+    /// the load instruction: 0 if 3 bytes, 1 if 4
+    ends: Vec<u8>,
+    /// The largest (and most recent, because we accept them only in order)
+    /// offset received so far for enforcing ordering. This is relative to the
+    /// start of the code (text) section so we can make sure functions are
+    /// ordered too.
+    last_offset: u32,
+}
+
+impl MmuInterruptCheckSection {
+    /// Adds an MMU-interrupt-check location to the section.
+    ///
+    /// Calls to this must be ordered by the location of `func`, and
+    /// offsets must be ordered (within each function) as well.
+    pub fn push(&mut self, func: Range<u64>, checks: &[Range<MmuInterruptCheckOffset>]) {
+        // Check that functions have been pushed in order so our section is
+        // sorted for free.
+        let func_start = u32::try_from(func.start).unwrap();
+        let func_end = u32::try_from(func.end).unwrap();
+        assert!(func_start >= self.last_offset);
+
+        // Remember each offset, ensuring they are in order.
+        for check in checks {
+            let text_section_relative = func_start + check.start;
+            assert!(text_section_relative > self.last_offset);
+            let bit_number = self.starts.len();
+            self.starts.push(text_section_relative);
+            let load_is_long = match check.len() {
+                3 => false,
+                4 => true,
+                _ => panic!(
+                    "Unexpected length of MMU-interrupt-checking load instruction: {}",
+                    check.len()
+                ),
+            };
+            set_bit(&mut self.ends, bit_number, load_is_long);
+            self.last_offset = text_section_relative;
+        }
+        self.last_offset = func_end;
+    }
+
+    /// Encodes this section into an object.
+    pub fn append_to(self, obj: &mut Object) {
+        let section = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            ELF_WASMTIME_MMU_INTERRUPT_CHECKS.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+
+        let num_checks: u32 = self.starts.len().try_into()
+            .expect("there should be few enough MMU-interrupt checks to be indexed by a u32, as the Wasm itself is only that long");
+        // Number of interrupt checks:
+        obj.append_section_data(
+            section,
+            object::bytes_of(&num_checks),
+            4, // For speed, avoid splitting across a cache line.
+        );
+        // Align to 4 so we can use from_raw_parts() when reading:
+        obj.append_section_data(section, object::bytes_of_slice(&self.starts), 4);
+        // We'll be querying this a byte at a time so don't care about alignment:
+        obj.append_section_data(section, object::bytes_of_slice(&self.ends), 1);
+    }
+}
+
+/// Returns the offset at which to resume after the given check.
+///
+/// If there is no check at that offset or the .wasmtime.mmu_interrupt_checks
+/// section is missing, return None.
+pub fn return_offset_for_mmu_interrupt_check(
+    section: &[u8],
+    check: MmuInterruptCheckOffset,
+) -> Option<MmuInterruptCheckOffset> {
+    if section.len() == 0 {
+        return None;
+    }
+
+    #[cfg(not(target_endian = "little"))]
+    panic!(
+        "return_offset_for_mmu_interrupt_check() must not be called against a non-empty section on a non-little-endian architecture until support for MMU interruption extends to them."
+    );
+
+    let (num_checks, rest) = object::from_bytes::<u32>(section)
+        .expect(".wasmtime.mmu_interrupt_checks section should be long enough to contain count");
+    let (starts, ends) = object::slice_from_bytes::<u32>(rest, *num_checks as usize)
+        .expect(".wasmtime.mmu_interrupt_checks section should be long enough to contain starts");
+
+    starts
+        .binary_search(&check)
+        .ok()
+        .map(|check_index| check + (if get_bit(ends, check_index) { 4 } else { 3 }))
+}
+
+/// Sets bit `dest_bit_number` (0-based) in `dest_slice` to `value`.
+fn set_bit(dest_slice: &mut Vec<u8>, dest_bit_number: usize, value: bool) {
+    let byte = dest_bit_number / 8;
+    if byte >= dest_slice.len() {
+        dest_slice.resize(byte + 1, 0);
+    }
+    let bit = dest_bit_number % 8;
+    if value {
+        dest_slice[byte] |= 1 << bit;
+    } else {
+        dest_slice[byte] &= !(1 << bit);
+    }
+}
+
+/// Returns bit `bit_number` (0-based) of `bytes`.
+fn get_bit(bytes: &[u8], bit_number: usize) -> bool {
+    let byte = bit_number / 8;
+    let bit = bit_number % 8;
+    bytes[byte] & (1 << bit) != 0
+}
+
+#[test]
+fn test_get_and_set_bit() {
+    let mut bits = vec![];
+    set_bit(&mut bits, 0, true); // first
+    set_bit(&mut bits, 2, true); // middle
+    set_bit(&mut bits, 18, true); // something beyond first byte
+    assert_eq!(bits, vec![5, 0, 4]);
+    assert!(get_bit(&bits, 0));
+    assert!(get_bit(&bits, 18));
+    assert!(!get_bit(&bits, 3));
+}
+
+#[test]
+fn test_set_bit_clear() {
+    let mut bits = vec![0xFF];
+    set_bit(&mut bits, 1, false);
+    assert_eq!(bits, vec![0xFD]);
+}
diff --git a/crates/environ/src/compile/mod.rs b/crates/environ/src/compile/mod.rs
index 984ba3c91715..bb0909990bc6 100644
--- a/crates/environ/src/compile/mod.rs
+++ b/crates/environ/src/compile/mod.rs
@@ -17,6 +17,7 @@ use std::sync::Arc;
 
 mod address_map;
 mod frame_table;
+mod mmu_interrupt_checks;
 mod module_artifacts;
 mod module_environ;
 mod module_types;
@@ -25,6 +26,7 @@ mod trap_encoding;
 
 pub use self::address_map::*;
 pub use self::frame_table::*;
+pub use self::mmu_interrupt_checks::*;
 pub use self::module_artifacts::*;
 pub use self::module_environ::*;
 pub use self::module_types::*;
diff --git a/crates/environ/src/obj.rs b/crates/environ/src/obj.rs
index 718c7873d908..92c4170922e9 100644
--- a/crates/environ/src/obj.rs
+++ b/crates/environ/src/obj.rs
@@ -65,6 +65,32 @@ pub const ELF_WASMTIME_STACK_MAP: &str = ".wasmtime.stackmap";
 /// the text section.
 pub const ELF_WASMTIME_TRAPS: &str = ".wasmtime.traps";
 
+/// A custom section through which we can locate instructions which
+/// check for an MMU-triggered interruption when using `mmu-interruption`.
+///
+/// The section allows for finding both the beginnings and ends of such
+/// instructions so the signal handler can identify segfault which caused by
+/// them (vs. ordinary crashes) and also find the address at which to resume
+/// afterward.
+///
+/// The format is architecture-dependent. Because the only forseen need to read
+/// it is on the platform where the binary will be executed and performance is
+/// sensitive, endianness follows whatever is native for the target. For x64,
+/// the only currently supported platform, the section comprises these data:
+/// * A u32 stating how many MMU-interruption checks are in each of the
+///   following 2 items
+/// * A sorted array of u32s which represent offsets from the beginning of the
+///   text section to the load instruction triggering the interruption
+/// * A parallel array of bits representing the length of those load
+///   instructions: 0 meaning 3 bytes, 1 meaning 4. These are the only lengths
+///   possible on x64. Resumption should happen directly after the load
+///   instruction. There is no danger of this location pointing beyond the end
+///   of the function; even if a function is empty, there's at least a return
+///   (or, in case of an infinite loop, a jmp) after its prologue.
+///
+/// The 32-bit encodings herein mean >=4gb text sections are not supported.
+pub const ELF_WASMTIME_MMU_INTERRUPT_CHECKS: &str = ".wasmtime.mmu_interrupt_checks";
+
 /// A custom binary-encoded section of the wasmtime compilation
 /// artifacts which encodes exception tables.
 ///
diff --git a/crates/environ/src/tunables.rs b/crates/environ/src/tunables.rs
index 37efb27a0cf5..e187c6cddb88 100644
--- a/crates/environ/src/tunables.rs
+++ b/crates/environ/src/tunables.rs
@@ -99,6 +99,10 @@ define_tunables! {
         /// Whether or not we use epoch-based interruption.
         pub epoch_interruption: bool,
 
+        /// Whether or not to use MMU tricks to trigger efficient asynchronous
+        /// interruption of Wasm execution via a signal handler.
+        pub mmu_interruption: bool,
+
         /// Whether or not linear memories are allowed to be reallocated after
         /// initial allocation at runtime.
         pub memory_may_move: bool,
@@ -262,6 +266,7 @@ impl Tunables {
             consume_fuel: false,
             operator_cost: OperatorCostStrategy::Default,
             epoch_interruption: false,
+            mmu_interruption: false,
             memory_may_move: true,
             guard_before_linear_memory: true,
             table_lazy_init: true,
diff --git a/crates/environ/src/vmoffsets.rs b/crates/environ/src/vmoffsets.rs
index 91ffadeaf99e..5c841321bb6a 100644
--- a/crates/environ/src/vmoffsets.rs
+++ b/crates/environ/src/vmoffsets.rs
@@ -202,11 +202,17 @@ pub trait PtrSize {
         self.vmstore_context_fuel_consumed() + 8
     }
 
+    /// Return the offset of the `mmu_interrupt_page_ptr` field of `VMStoreContext`.
+    #[inline]
+    fn vmstore_context_mmu_interrupt_page_ptr(&self) -> u8 {
+        self.vmstore_context_epoch_deadline() + 8
+    }
+
     /// Return the offset of the `execution_version` field of
     /// `VMStoreContext`
     #[inline]
     fn vmstore_context_execution_version(&self) -> u8 {
-        self.vmstore_context_epoch_deadline() + 8
+        self.vmstore_context_mmu_interrupt_page_ptr() + self.size()
     }
 
     /// Return the offset of the `stack_limit` field of `VMStoreContext`
diff --git a/crates/test-programs/src/bin/p2_cli_serve_busy_loop.rs b/crates/test-programs/src/bin/p2_cli_serve_busy_loop.rs
new file mode 100644
index 000000000000..4753621d41b1
--- /dev/null
+++ b/crates/test-programs/src/bin/p2_cli_serve_busy_loop.rs
@@ -0,0 +1,20 @@
+use test_programs::proxy;
+use test_programs::wasi::http::types::{IncomingRequest, ResponseOutparam};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(_: IncomingRequest, _outparam: ResponseOutparam) {
+        // About a second worth of busy loop. This should be plenty to test
+        // 100µs MMU interrupts with.
+        for i in 0..200_000_000u64 {
+            std::hint::black_box(i);
+        }
+        // Worker should time out before hitting this.
+        unreachable!()
+    }
+}
+
+fn main() {}
diff --git a/crates/wasi-preview1-component-adapter/src/lib.rs b/crates/wasi-preview1-component-adapter/src/lib.rs
index 7ce52c6c262c..fffcac4900cd 100644
--- a/crates/wasi-preview1-component-adapter/src/lib.rs
+++ b/crates/wasi-preview1-component-adapter/src/lib.rs
@@ -457,7 +457,7 @@ impl ImportAlloc {
 #[derive(Clone)]
 struct BumpAlloc {
     base: *mut u8,
-    len: usize,
+    len: usize, // remaining size available for allocation
 }
 
 impl BumpAlloc {
diff --git a/crates/wasmtime/Cargo.toml b/crates/wasmtime/Cargo.toml
index cc14bdaf63f5..e6bdff9f0bc2 100644
--- a/crates/wasmtime/Cargo.toml
+++ b/crates/wasmtime/Cargo.toml
@@ -370,7 +370,7 @@ wit-parser = ["dep:wit-parser", "component-model", "std"]
 # For platforms that Wasmtime does not have support for Wasmtime will disable
 # the use of virtual memory by default, for example allocating linear memories
 # with `malloc` instead. This feature can be used, for these platforms, to
-# instead use a C API defined in `wasmtime-platform.h` instead.
+# instead use a C API defined in `wasmtime-platform.h`.
 #
 # For some more information see
 # https://docs.wasmtime.dev/stability-platform-support.html#support-for-no_std
diff --git a/crates/wasmtime/build.rs b/crates/wasmtime/build.rs
index 1248e64ae50a..44f1c75dcf00 100644
--- a/crates/wasmtime/build.rs
+++ b/crates/wasmtime/build.rs
@@ -45,12 +45,18 @@ fn main() {
         && cfg!(feature = "custom-sync-primitives")
         && cfg!(feature = "runtime");
     let has_custom_fiber = !has_builtin_stackswitch && cfg!(feature = "custom-fiber");
+    let has_mmu_interruption = std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "linux"
+        && (target_arch == "x86_64" || target_arch == "aarch64")
+        && cfg!(feature = "async")
+        && cfg!(feature = "cranelift")
+        && cfg!(feature = "std");
 
     custom_cfg("has_native_signals", has_native_signals);
     custom_cfg("has_virtual_memory", has_virtual_memory);
     custom_cfg("has_custom_fiber", has_custom_fiber);
     custom_cfg("has_custom_sync", has_custom_sync);
     custom_cfg("has_host_compiler_backend", has_host_compiler_backend);
+    custom_cfg("has_mmu_interruption", has_mmu_interruption);
     custom_cfg("gc_zeal", cfg("fuzzing"));
 
     // If this OS isn't supported and no debug-builtins or if Cranelift doesn't support
diff --git a/crates/wasmtime/src/config.rs b/crates/wasmtime/src/config.rs
index cfc225bb51cd..a7ffb1f8f85c 100644
--- a/crates/wasmtime/src/config.rs
+++ b/crates/wasmtime/src/config.rs
@@ -666,7 +666,7 @@ impl Config {
     /// compiled form of the Wasm code so that it maintains a precise
     /// instruction count, frequently checking this count against the
     /// remaining fuel. If one does not need this precise count or
-    /// deterministic interruptions, and only needs a periodic
+    /// deterministic interruptions and needs only a periodic
     /// interrupt of some form, then It would be better to have a more
     /// lightweight mechanism.
     ///
@@ -692,7 +692,7 @@ impl Config {
     /// to use epoch deadlines to limit the execution time of untrusted
     /// code.
     ///
-    /// The [`Store`](crate::Store) tracks the deadline, and controls
+    /// The [`Store`](crate::Store) tracks the deadline and controls
     /// what happens when the deadline is reached during
     /// execution. Several behaviors are possible:
     ///
@@ -767,6 +767,79 @@ impl Config {
         self
     }
 
+    /// Enables MMU-based interruption, a lower-overhead alternative to
+    /// [`Config::epoch_interruption`]. It uses memory-protection faults instead
+    /// of epoch deadline comparisons to prod a running Wasm guest to yield.
+    ///
+    /// # How it works
+    ///
+    /// Cranelift emits, at each loop backedge and function prologue, a load
+    /// from a per-store "interrupt page". To trigger an interruption, the
+    /// embedder marks that page as inaccessible; the resulting SIGSEGV is
+    /// caught by Wasmtime's signal handler, which distinguishes an
+    /// interrupt-check load from an actual crash by consulting a table of check
+    /// offsets stored in the compiled artifact
+    /// (`.wasmtime.mmu_interrupt_checks`). The signal handler then causes the
+    /// active fiber to yield.
+    ///
+    /// # Compared to `epoch_interruption`
+    ///
+    /// - Faster. Whereas epoch interruption needs to compare, branch, and keep
+    ///   a deadline register coherent, MMU interruption does only a single
+    ///   (dead) load from a per-store memory page. In the no-interrupt case,
+    ///   the load completes successfully, and overhead (versus doing nothing)
+    ///   is ≈2.8% on the SpiderMonkey Sightglass benchmark, compared to 14.4%
+    ///   for epoch interruption. Benchmarking of the interruption path remains
+    ///   to be done.
+    /// - Also non-deterministic. The same guidance in
+    ///   [`Config::epoch_interruption`] about fuel vs. epochs applies here.
+    /// - Equally fine-grained. Checks for MMU interruption happen at the same
+    ///   points in the compiled Wasm as checks for epoch interruption.
+    /// - Less flexible. Unlike epochs, there is, at of yet, no configurable
+    ///   per-store interrupt behavior. When triggered, interruption always
+    ///   causes the running fiber to yield; the `Store::epoch_deadline_*`
+    ///   callbacks are not consulted.
+    ///
+    /// # Triggering an interruption
+    ///
+    /// Unlike with epoch-based interruption, the embedder must trigger an
+    /// interruption from outside the Wasm guest code. Obtain an
+    /// [`MmuInterrupter`](crate::runtime::vm::MmuInterrupter) from
+    /// [`Store::mmu_interrupter`](crate::Store::mmu_interrupter). It is `Send +
+    /// Sync` and can be handed to another thread or a timer. Then, to interrupt
+    /// the Wasm running on that store, call
+    /// [`interrupt()`](crate::MmuInterrupter::interrupt()) on your
+    /// `MmuInterrupter`. That protects the memory page, causing the Wasm to
+    /// yield at its next checkpoint. The memory page is automatically
+    /// unprotected just beforehand to ready it for next time.
+    ///
+    /// # Requirements
+    ///
+    /// - **Async.** Since MMU interruption always causes the fiber to yield,
+    ///   wasmtime must be built with the `async` feature. Configuring an engine
+    ///   with `mmu_interruption()` puts every [`Store`] derived from it into
+    ///   async mode automatically.
+    /// - **Cranelift.** Winch does not support it.
+    /// - **Linux on x86_64 or aarch64.** Cross-compilation to other targets is
+    ///   fine; the check is a no-op on hosts that cannot use it.
+    /// - **Native signals** because we depend on a signal handler.
+    /// - **Signals-based traps**, because signal-handler installation (in
+    ///   [`Engine::new()`]) is currently gated on this. It should be possible
+    ///   to remove this dependency, but the use cases are few, and threading
+    ///   the value of `signals_based_traps` into the signal handler may be
+    ///   nontrivial.
+    ///
+    /// # Errors
+    ///
+    /// These requirements get validated later, some when an [`Engine`] is
+    /// instantiated (which calls [`Config::validate`] herein) and others when
+    /// code is loaded into the engine. Nothing panics; errors are reported via
+    /// return values.
+    pub fn mmu_interruption(&mut self, enable: bool) -> &mut Self {
+        self.tunables.mmu_interruption = Some(enable);
+        self
+    }
+
     /// XXX: For internal fuzzing and debugging use only!
     #[doc(hidden)]
     pub fn gc_zeal_alloc_counter(&mut self, counter: Option<NonZeroU32>) -> Result<&mut Self> {
@@ -2727,6 +2800,22 @@ impl Config {
             );
         }
 
+        if tunables.mmu_interruption {
+            // Disabling `signals_based_traps` is not compatible with MMU
+            // interruption. If `signals_based_traps` is disabled, the signal
+            // handlers will not be installed when creating the engine.
+            //
+            // If no target is explicitly requested and the host target does
+            // not support native signals, `signals_based_traps` will be set to
+            // false above, so we can skip that check here.
+            // When a explicit target is requested, a compatibility check will
+            // be triggered when creating the engine.
+            ensure!(
+                tunables.signals_based_traps,
+                "MMU interruption requires signals-based traps"
+            );
+        }
+
         // Concurrency support is required for some component model features.
         let requires_concurrency = WasmFeatures::CM_ASYNC
             | WasmFeatures::CM_MORE_ASYNC_BUILTINS
@@ -4982,6 +5071,11 @@ impl Engine {
         self.tunables().epoch_interruption
     }
 
+    /// Returns the configured [`Config::mmu_interruption`] value.
+    pub fn get_mmu_interruption(&self) -> bool {
+        self.tunables().mmu_interruption
+    }
+
     /// Returns the configured [`Config::consume_fuel`] value.
     pub fn get_consume_fuel(&self) -> bool {
         self.tunables().consume_fuel
diff --git a/crates/wasmtime/src/engine.rs b/crates/wasmtime/src/engine.rs
index a3e1bf7faefc..4ff32c5e38d1 100644
--- a/crates/wasmtime/src/engine.rs
+++ b/crates/wasmtime/src/engine.rs
@@ -390,6 +390,30 @@ impl Engine {
         if !cfg!(has_native_signals) && self.tunables().signals_based_traps {
             return Err("signals-based-traps disabled at compile time -- cannot be enabled".into());
         }
+
+        // MMU interruption requires:
+        // - Native signals
+        // - An x86_64 or aarch64 Linux host
+        // - Signals based traps
+        // - Async support
+        if self.tunables().mmu_interruption {
+            use target_lexicon::{Architecture, OperatingSystem};
+
+            if !matches!(
+                host.architecture,
+                Architecture::X86_64 | Architecture::X86_64h | Architecture::Aarch64(_)
+            ) || host.operating_system != OperatingSystem::Linux
+            {
+                return Err(
+                    "MMU interruption is supported only on x86_64 and aarch64 linux".into(),
+                );
+            }
+
+            if !cfg!(has_native_signals) {
+                return Err("MMU interruption requires native signals".into());
+            }
+        }
+
         if !cfg!(has_virtual_memory) && self.tunables().memory_init_cow {
             return Err("virtual memory disabled at compile time -- cannot enable CoW".into());
         }
diff --git a/crates/wasmtime/src/engine/serialization.rs b/crates/wasmtime/src/engine/serialization.rs
index cc91db370f9c..12df72e164c2 100644
--- a/crates/wasmtime/src/engine/serialization.rs
+++ b/crates/wasmtime/src/engine/serialization.rs
@@ -303,6 +303,7 @@ impl Metadata<'_> {
             consume_fuel,
             ref operator_cost,
             epoch_interruption,
+            mmu_interruption,
             memory_may_move,
             guard_before_linear_memory,
             table_lazy_init,
@@ -380,6 +381,7 @@ impl Metadata<'_> {
             other.epoch_interruption,
             "epoch interruption",
         )?;
+        Self::check_bool(mmu_interruption, other.mmu_interruption, "MMU interruption")?;
         Self::check_bool(memory_may_move, other.memory_may_move, "memory may move")?;
         Self::check_bool(
             guard_before_linear_memory,
diff --git a/crates/wasmtime/src/runtime.rs b/crates/wasmtime/src/runtime.rs
index 78eba4ad6367..817c3eafced5 100644
--- a/crates/wasmtime/src/runtime.rs
+++ b/crates/wasmtime/src/runtime.rs
@@ -107,6 +107,7 @@ pub use trap::*;
 pub use types::*;
 pub use v128::V128;
 pub use values::*;
+pub use vm::MmuInterrupter;
 
 #[cfg(feature = "pooling-allocator")]
 pub use vm::{PoolConcurrencyLimitError, PoolingAllocatorMetrics};
diff --git a/crates/wasmtime/src/runtime/code_memory.rs b/crates/wasmtime/src/runtime/code_memory.rs
index 6078b5091c34..f5a12927367a 100644
--- a/crates/wasmtime/src/runtime/code_memory.rs
+++ b/crates/wasmtime/src/runtime/code_memory.rs
@@ -13,6 +13,8 @@ use object::{
     read::elf::{FileHeader as _, SectionHeader as _},
 };
 use wasmtime_environ::StaticModuleIndex;
+#[cfg(has_mmu_interruption)]
+use wasmtime_environ::return_offset_for_mmu_interrupt_check;
 use wasmtime_environ::{CompiledTrap, lookup_trap_code, obj};
 use wasmtime_unwinder::ExceptionTable;
 
@@ -38,6 +40,8 @@ pub struct CodeMemory {
     text: Range<usize>,
     unwind: Range<usize>,
     trap_data: Range<usize>,
+    #[cfg(has_mmu_interruption)]
+    mmu_interrupt_check_data: Range<usize>,
     wasm_data: Range<usize>,
     address_map_data: Range<usize>,
     stack_map_data: Range<usize>,
@@ -148,6 +152,8 @@ impl CodeMemory {
         #[cfg(feature = "debug-builtins")]
         let mut has_native_debug_info = false;
         let mut trap_data = 0..0;
+        #[cfg(has_mmu_interruption)]
+        let mut mmu_interrupt_check_data = 0..0;
         let mut exception_data = 0..0;
         let mut frame_tables_data = 0..0;
         let mut wasm_data = 0..0;
@@ -212,6 +218,12 @@ impl CodeMemory {
                 obj::ELF_WASMTIME_ADDRMAP => address_map_data = range,
                 obj::ELF_WASMTIME_STACK_MAP => stack_map_data = range,
                 obj::ELF_WASMTIME_TRAPS => trap_data = range,
+                obj::ELF_WASMTIME_MMU_INTERRUPT_CHECKS => {
+                    #[cfg(has_mmu_interruption)]
+                    {
+                        mmu_interrupt_check_data = range;
+                    }
+                }
                 obj::ELF_WASMTIME_EXCEPTIONS => exception_data = range,
                 obj::ELF_WASMTIME_FRAMES => frame_tables_data = range,
                 obj::ELF_NAME_DATA => func_name_data = range,
@@ -268,6 +280,8 @@ impl CodeMemory {
             text,
             unwind,
             trap_data,
+            #[cfg(has_mmu_interruption)]
+            mmu_interrupt_check_data,
             address_map_data,
             stack_map_data,
             exception_data,
@@ -396,6 +410,25 @@ impl CodeMemory {
         Some(&self.wasm_bytecode()[start..end])
     }
 
+    /// Returns the address at which to resume after the given MMU-interrupt
+    /// check.
+    #[cfg(has_mmu_interruption)]
+    pub fn return_address_for_mmu_interrupt_check(&self, check_offset: u32) -> Option<*const ()> {
+        // SAFETY: `self.mmu_interrupt_check_data` is a range into `self.mmap`
+        // established when the ELF was parsed in the constructor, and
+        // `self.mmap` hasn't mutated since then. `self.mmap` outlives
+        // `section`. We're quickly done with the latter and return a
+        // disembodied pointer for some also-unsafe naked asm to jmp to.
+        let section = unsafe {
+            std::slice::from_raw_parts(
+                self.mmap[self.mmu_interrupt_check_data.clone()].as_ptr(),
+                self.mmu_interrupt_check_data.len(),
+            )
+        };
+        return_offset_for_mmu_interrupt_check(section, check_offset)
+            .map(|offset| (self.text().as_ptr().addr() + offset as usize) as *const ())
+    }
+
     /// Publishes the internal ELF image to be ready for execution.
     ///
     /// This method can only be when the image is not published (its
diff --git a/crates/wasmtime/src/runtime/component/linker.rs b/crates/wasmtime/src/runtime/component/linker.rs
index b468321b2999..099dc50ca292 100644
--- a/crates/wasmtime/src/runtime/component/linker.rs
+++ b/crates/wasmtime/src/runtime/component/linker.rs
@@ -172,7 +172,7 @@ impl<T: 'static> Linker<T> {
             imported_resources: try_new::<Arc<_>>(TryPrimaryMap::new())?,
         };
 
-        // Walk over the component's list of import names and use that to lookup
+        // Walk over the component's list of import names and use that to look up
         // the definition within this linker that it corresponds to. When found
         // perform a typecheck against the component's expected type.
         let env_component = component.env_component();
diff --git a/crates/wasmtime/src/runtime/fiber.rs b/crates/wasmtime/src/runtime/fiber.rs
index 50f086f7d4c8..5f5fd136aa9e 100644
--- a/crates/wasmtime/src/runtime/fiber.rs
+++ b/crates/wasmtime/src/runtime/fiber.rs
@@ -7,6 +7,8 @@ use core::mem;
 use core::ops::Range;
 use core::pin::Pin;
 use core::ptr::{self, NonNull};
+#[cfg(has_mmu_interruption)]
+use core::sync::atomic::Ordering;
 use core::task::{Context, Poll};
 use wasmtime_fiber::{Fiber, FiberStack, Suspend};
 #[cfg(all(feature = "component-model-async", feature = "gc"))]
@@ -618,6 +620,10 @@ impl FiberResumeState {
             .unwrap_or(ptr::null_mut()..ptr::null_mut());
         let mut executor = self.executor;
         store.swap_executor(&mut executor);
+
+        #[cfg(has_mmu_interruption)]
+        store.increment_fibers();
+
         PriorFiberResumeState {
             tls,
             mpk,
@@ -667,8 +673,40 @@ impl StoreOpaque {
     ) -> Option<NonNull<Context<'static>>> {
         mem::replace(&mut self.fiber_async_state_mut().current_future_cx, ptr)
     }
+
+    /// Increments the count of fibers currently stacked up to run on this store.
+    #[cfg(has_mmu_interruption)]
+    fn increment_fibers(&mut self) {
+        // We can Relax here, since this thread is the only one that ever
+        // mutates running_fibers.
+        let num = self.fibers_on_stack.load(Ordering::Relaxed);
+
+        // There's no way wrapping should happen if stack frames are
+        // non-zero in size. You'd run out of addressible memory first.
+        debug_assert!(
+            num < usize::MAX,
+            "The fibers-on-stack count for a Store exceeded the size of a usize."
+        );
+        self.fibers_on_stack
+            .store(num.wrapping_add(1), Ordering::Relaxed);
+    }
+
+    /// Decrements the count of fibers currently stacked up to run on this store.
+    #[cfg(has_mmu_interruption)]
+    fn decrement_fibers(&mut self) {
+        let num = self.fibers_on_stack.load(Ordering::Relaxed);
+        debug_assert!(
+            num > 0,
+            "The fibers-on-stack count for a Store was about to go negative."
+        );
+        self.fibers_on_stack
+            .store(num.wrapping_sub(1), Ordering::Relaxed);
+    }
 }
 
+// Relaxed is fine: any reader must tolerate a stale answer anyway
+// since the truth can change the instant after it is read.
+
 struct PriorFiberResumeState {
     tls: crate::runtime::vm::PreviousAsyncWasmCallState,
     mpk: Option<ProtectionMask>,
@@ -698,6 +736,9 @@ impl PriorFiberResumeState {
         let mut executor = self.executor;
         store.swap_executor(&mut executor);
 
+        #[cfg(has_mmu_interruption)]
+        store.decrement_fibers();
+
         FiberResumeState {
             tls,
             mpk,
diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rs
index 78c46017b6c7..bde4015c9707 100644
--- a/crates/wasmtime/src/runtime/store.rs
+++ b/crates/wasmtime/src/runtime/store.rs
@@ -98,6 +98,8 @@ use crate::trampoline::VMHostGlobalContext;
 use crate::{BreakpointState, DebugHandler, FrameDataCache};
 use crate::{Engine, Module, Val, ValRaw, module::ModuleRegistry};
 use crate::{Global, Instance, Table};
+#[cfg(has_mmu_interruption)]
+use alloc::sync::Arc;
 use core::convert::Infallible;
 use core::fmt;
 #[cfg(any(feature = "async", feature = "gc"))]
@@ -108,6 +110,8 @@ use core::num::NonZeroU64;
 use core::ops::{Deref, DerefMut};
 use core::pin::Pin;
 use core::ptr::NonNull;
+#[cfg(has_mmu_interruption)]
+use core::sync::atomic::AtomicUsize;
 #[cfg(any(feature = "async", feature = "gc"))]
 use core::task::Poll;
 use wasmtime_environ::{DefinedGlobalIndex, DefinedTableIndex, EntityRef, TripleExt};
@@ -569,6 +573,13 @@ pub struct StoreOpaque {
     /// enabled, so the key-space is unique for each store.)
     #[cfg(feature = "debug")]
     frame_data_cache: FrameDataCache,
+
+    /// The number of fibers currently executing on this Store, including ones
+    /// further down in the call stack which, directly or indirectly, caused the
+    /// current one to run. Used for efficiency of MMU interruption, by letting
+    /// it ignore non-running Stores.
+    #[cfg(has_mmu_interruption)]
+    pub(super) fibers_on_stack: Arc<AtomicUsize>,
 }
 
 /// Self-pointer to `StoreInner<T>` from within a `StoreOpaque` which is chiefly
@@ -744,10 +755,20 @@ impl<T> Store<T> {
 
         let pkey = engine.allocator().next_available_pkey();
 
+        #[cfg(has_mmu_interruption)]
+        let vm_store_context = if engine.tunables().mmu_interruption {
+            VMStoreContext::with_interrupt_page()
+        } else {
+            VMStoreContext::default()
+        };
+
+        #[cfg(not(has_mmu_interruption))]
+        let vm_store_context = VMStoreContext::default();
+
         let inner = StoreOpaque {
             _marker: marker::PhantomPinned,
             engine: engine.clone(),
-            vm_store_context: Default::default(),
+            vm_store_context,
             #[cfg(feature = "stack-switching")]
             continuations: Vec::new(),
             instances: TryPrimaryMap::new(),
@@ -779,6 +800,8 @@ impl<T> Store<T> {
             hostcall_val_storage: Vec::new(),
             wasm_val_raw_storage: TryVec::new(),
             pkey,
+            #[cfg(has_mmu_interruption)]
+            fibers_on_stack: Arc::new(AtomicUsize::new(0)),
             executor: Executor::new(engine)?,
             #[cfg(feature = "debug")]
             breakpoints: Default::default(),
@@ -796,6 +819,13 @@ impl<T> Store<T> {
             debug_handler: None,
         })?;
 
+        // MMU interruption traps in Wasm and unwinds via a fiber, so every
+        // Store built from an Engine with this option needs async.
+        #[cfg(has_mmu_interruption)]
+        if engine.tunables().mmu_interruption {
+            inner.set_async_required(Asyncness::Yes);
+        }
+
         let store_data =
             <NonNull<ManuallyDrop<T>>>::from(&mut inner.data_no_provenance).cast::<()>();
         inner.inner.vm_store_context.store_data = store_data.into();
@@ -1172,6 +1202,20 @@ impl<T> Store<T> {
         self.inner.epoch_deadline_callback(Box::new(callback));
     }
 
+    /// Returns an [`MmuEpochInterrupter`] iff MMU-based interruption is enabled
+    /// for this store.
+    ///
+    /// The returned handle is `Send + Sync` and can be used from any thread
+    /// to trigger an epoch interruption, like
+    /// [`Engine::increment_epoch`](crate::Engine::increment_epoch) can for
+    /// deadline-based epochs.
+    #[cfg(has_mmu_interruption)]
+    pub fn mmu_interrupter(&self) -> Option<vm::MmuInterrupter> {
+        self.inner
+            .vm_store_context()
+            .mmu_interrupter(self.inner.fibers_on_stack.clone())
+    }
+
     /// Tests whether there is a pending exception.
     ///
     /// Ordinarily, a pending exception will be set on a store if and
@@ -2431,7 +2475,7 @@ at https://bytecodealliance.org/security.
 }
 
 #[cfg(any(feature = "async", feature = "gc"))]
-async fn yield_now() {
+pub(crate) async fn yield_now() {
     let mut yielded = false;
     future::poll_fn(move |cx| {
         if yielded {
@@ -2599,6 +2643,8 @@ impl Drop for StoreOpaque {
             }
 
             self.store_data.decrement_allocator_resources(allocator);
+            #[cfg(has_mmu_interruption)]
+            self.vm_store_context_mut().unmap_interrupt_page();
         }
     }
 }
diff --git a/crates/wasmtime/src/runtime/vm.rs b/crates/wasmtime/src/runtime/vm.rs
index b663b63f9b88..edab6fdb7d1b 100644
--- a/crates/wasmtime/src/runtime/vm.rs
+++ b/crates/wasmtime/src/runtime/vm.rs
@@ -124,6 +124,8 @@ pub use crate::runtime::vm::table::{Table, TableElementType};
 #[cfg(feature = "gc")]
 pub use crate::runtime::vm::throw::*;
 pub use crate::runtime::vm::traphandlers::*;
+#[cfg(has_mmu_interruption)]
+pub use crate::runtime::vm::vmcontext::MmuInterrupter;
 #[cfg(feature = "component-model")]
 pub use crate::runtime::vm::vmcontext::VMArrayCallFunction;
 #[cfg(feature = "component-model-async")]
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs b/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs
index f398ab874921..ef7f3befbdd2 100644
--- a/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs
@@ -1,10 +1,22 @@
 //! Trap handling on Unix based on POSIX signals.
 
 use crate::prelude::*;
+#[cfg(has_mmu_interruption)]
+use crate::runtime;
+#[cfg(has_mmu_interruption)]
+use crate::runtime::module::lookup_code;
+#[cfg(has_mmu_interruption)]
+use crate::runtime::vm::traphandlers::raise_preexisting_trap;
 use crate::runtime::vm::traphandlers::{TrapRegisters, TrapTest, tls};
+#[cfg(has_mmu_interruption)]
+use crate::runtime::vm::{Instance, VMContext};
+#[cfg(has_mmu_interruption)]
+use core::arch::naked_asm;
 use std::cell::RefCell;
 use std::io;
 use std::mem;
+#[cfg(has_mmu_interruption)]
+use std::ptr::NonNull;
 use std::ptr::{self, null_mut};
 use wasmtime_unwinder::Handler;
 
@@ -18,6 +30,10 @@ static mut PREV_SIGBUS: libc::sigaction = UNINIT_SIGACTION;
 static mut PREV_SIGILL: libc::sigaction = UNINIT_SIGACTION;
 static mut PREV_SIGFPE: libc::sigaction = UNINIT_SIGACTION;
 
+// From signal.h. Not yet exposed in libc. Value is valid for Linux and Mac; not
+// sure about elsewhere.
+#[cfg(has_mmu_interruption)]
+const SEGV_ACCERR: libc::c_int = 2;
 pub struct TrapHandler;
 
 impl TrapHandler {
@@ -128,6 +144,367 @@ now.
     }
 }
 
+/// Causes the active fiber to yield.
+///
+/// Consequently, this returns only after this fiber resumes, appearing to be a
+/// normal synchronous function from the standpoint of the caller.
+///
+/// `wasm_resume_pc` is the address of the instruction after the load that
+/// triggered the signal. `trampoline_fp` is a pointer to
+/// `task_switch_trampoline`'s frame, which points at the slot where it saved
+/// the Wasm caller's frame pointer. Providing these allows this to ape the behavior of
+/// the wasm-to-host trampoline so backtrace capture works in the case of fiber
+/// cancellation.
+///
+/// If this fiber gets cancelled within the duration of our yield, this function
+/// never returns, instead initiating an unwind.
+///
+/// # Safety
+///
+/// `vmctx` must be a currently-entered `VMContext`. In current use,
+/// `task_switch_trampoline` ensures the first argument register still holds the
+/// Wasm caller's vmctx and sets up the other two argument registers as well.
+#[cfg(has_mmu_interruption)]
+unsafe extern "C" fn yield_current_fiber(
+    vmctx: NonNull<VMContext>,
+    wasm_resume_pc: usize,
+    trampoline_fp: usize,
+) {
+    unsafe {
+        // is_cancelled means an error occurred and unwind info has been stored
+        // in TLS.
+        let is_cancelled = !Instance::enter_host_from_wasm(vmctx, |store, _instance| {
+            // Mirror the behavior of `block_on!`, which would panic in
+            // `assert_ready()` if the Store lacked Asyncness because
+            // `yield_now()` is always initially unready.
+            debug_assert!(
+                store.can_block(),
+                "mmu-interruption should automatically enable asyncness on all stores referencing the engine on which it's configured, but somehow asyncness was off"
+            );
+
+            let store_ctx = store.vm_store_context();
+
+            // Record Wasm-exit state just as a Cranelift-emitted wasm-to-host
+            // trampoline would so that any backtrace capture triggered
+            // while we are in the host (in particular, on the cancellation
+            // path below) sees a coherent topmost Wasm activation. Otherwise,
+            // it hits a debug assert and crashes.
+            *store_ctx.last_wasm_exit_pc.get() = wasm_resume_pc;
+            *store_ctx.last_wasm_exit_trampoline_fp.get() = trampoline_fp;
+
+            // Reset the epoch.
+            store_ctx.unprotect_interrupt_page();
+
+            // And actually switch fibers.
+            let result = store.with_blocking(|_store, cx| cx.block_on(runtime::store::yield_now()));
+
+            if result.is_ok() {
+                // Clear the exit state again so it doesn't appear stale once we
+                // resume Wasm.
+                let ctx = store.vm_store_context();
+                *ctx.last_wasm_exit_pc.get() = 0;
+                *ctx.last_wasm_exit_trampoline_fp.get() = 0;
+            }
+            // Else leave exit state in place so `record_unwind` (called via
+            // `raise_preexisting_trap` below) can capture a backtrace.
+
+            result
+        });
+        if is_cancelled {
+            // `block_on()` returned an Err, meaning this fiber has been
+            // cancelled and needs to exit. We unwind it using
+            // `raise_preexisting_trap()`, which, on native targets (the only
+            // ones MMU epochs apply to), never returns, doing a longjmp out and
+            // thus making anything in stack frames above irrelevant. Thus, it
+            // doesn't matter that we never get to restore registers in
+            // `task_switch_trampoline()` or jmp back to the signal-raising
+            // address.
+            Instance::enter_host_from_wasm(vmctx, |store, _instance| {
+                raise_preexisting_trap(store);
+            });
+        }
+    }
+}
+
+/// Switches tasks in response to a signal thrown under MMU-based epoch
+/// interruption.
+///
+/// Saves register state, makes a host call to switch tasks, restores state, and
+/// jumps back to the instruction after the one that triggered the signal. The
+/// address of that instruction has been squirreled away by the signal handler
+/// in the scratch register that `dead_load_with_context` reserves: r10 on x64,
+/// x9 on aarch64. The signal handler has also left the address of the vmctx in
+/// the first argument register (rdi on x64, x0 on aarch64), where
+/// `dead_load_with_context` pinned it.
+///
+/// # Safety
+///
+/// This is invoked only by the signal handler `trap_handler`, which fulfills
+/// the prerequisites about register contents. It is reached not by a
+/// straightforward call but by jimmying the ucontext to "resume into" this
+/// (instead of the trapping location) when the handler exits.
+///
+/// This uses about 376b of stack space (on the normal stack, not the
+/// sigaltstack) to save registers + a bit more to run `yield_current_fiber()`.
+/// In practice, this should not create uncaught stack overflows because (1)
+/// this trampoline runs only in async, (2) the default async_stack_size is
+/// 2MiB, of which only 512KiB is reserved for the Wasm stack, and (3) the fiber
+/// stack has a 4KiB guard page at the bottom, which causes
+/// `abort_stack_overflow()` to run if we do crash into it.
+///
+/// When control reaches here, we have just returned from a signal
+/// handler after rewriting PC to point to this trampoline but updating
+/// no other register state.
+///
+/// The stack has enough space for this state-saving, ensured by the
+/// stack-limit checks in Cranelift-compiled code.
+#[cfg(all(has_mmu_interruption, target_arch = "x86_64"))]
+#[unsafe(naked)]
+unsafe extern "C" fn task_switch_trampoline(_vmctx: usize) {
+    naked_asm!(
+        "
+        // Push a fake return address just to keep the stack 16b-aligned for the
+        // call, as SysV x64 demands.
+        push 0
+        // This is an ordinary frame as seen by stack-walks. We also establish
+        // rbp as our frame pointer so that we can hand it to
+        // `yield_current_fiber` as the trampoline FP: the saved wasm rbp lives
+        // at [rbp], which is exactly what
+        // `VMStoreContext::wasm_exit_fp_from_trampoline_fp` expects.
+        push rbp
+
+        // Save all GPRs except rbp/rsp (saved above and by normal stack
+        // discipline, respectively).
+        push rdx
+
+        // Now that rdx is pushed, take an intermission to put the original
+        // value of rbp into it, for use as arg 3 to yield_current_fiber().
+        lea rdx, [rsp + 8]
+
+        // And do the rest of the GPRs.
+        push rax
+        push rbx
+        push rcx
+        push rdi
+        push rsi
+        push r8
+        push r9
+        push r10
+        push r11
+        push r12
+        push r13
+        push r14
+        push r15
+
+        // N.B.: we don't save rflags; Cranelift-compiled code
+        // never assumes it is saved across instructions outside of
+        // flag-generation / flag-consumption pairs, and the only
+        // resumable traps we are interested in are not flags-related.
+
+        sub rsp, 256 // enough for all 16 XMM registers.
+        movdqu [rsp +  0 * 16], xmm0
+        movdqu [rsp +  1 * 16], xmm1
+        movdqu [rsp +  2 * 16], xmm2
+        movdqu [rsp +  3 * 16], xmm3
+        movdqu [rsp +  4 * 16], xmm4
+        movdqu [rsp +  5 * 16], xmm5
+        movdqu [rsp +  6 * 16], xmm6
+        movdqu [rsp +  7 * 16], xmm7
+        movdqu [rsp +  8 * 16], xmm8
+        movdqu [rsp +  9 * 16], xmm9
+        movdqu [rsp + 10 * 16], xmm10
+        movdqu [rsp + 11 * 16], xmm11
+        movdqu [rsp + 12 * 16], xmm12
+        movdqu [rsp + 13 * 16], xmm13
+        movdqu [rsp + 14 * 16], xmm14
+        movdqu [rsp + 15 * 16], xmm15
+
+        // vmctx is already in rdi, care of the signal handler. Get the 2nd
+        // arg ready (the 3rd already having been put in rdx above)...
+        mov rsi, r10
+        // ...and call yield_current_fiber() to do the task switch.
+        call {}
+
+        // Restore registers.
+        movdqu xmm0,  [rsp +  0 * 16]
+        movdqu xmm1,  [rsp +  1 * 16]
+        movdqu xmm2,  [rsp +  2 * 16]
+        movdqu xmm3,  [rsp +  3 * 16]
+        movdqu xmm4,  [rsp +  4 * 16]
+        movdqu xmm5,  [rsp +  5 * 16]
+        movdqu xmm6,  [rsp +  6 * 16]
+        movdqu xmm7,  [rsp +  7 * 16]
+        movdqu xmm8,  [rsp +  8 * 16]
+        movdqu xmm9,  [rsp +  9 * 16]
+        movdqu xmm10, [rsp + 10 * 16]
+        movdqu xmm11, [rsp + 11 * 16]
+        movdqu xmm12, [rsp + 12 * 16]
+        movdqu xmm13, [rsp + 13 * 16]
+        movdqu xmm14, [rsp + 14 * 16]
+        movdqu xmm15, [rsp + 15 * 16]
+        add rsp, 256
+
+        pop r15
+        pop r14
+        pop r13
+        pop r12
+        pop r11
+        pop r10
+        pop r9
+        pop r8
+        pop rsi
+        pop rdi
+        pop rcx
+        pop rbx
+        pop rax
+        pop rdx
+
+        pop rbp
+        // Pop off the fake return address.
+        add rsp, 8
+
+        // Resume right after the load instruction that triggered the signal
+        // handler.
+        jmp r10
+        ",
+        sym yield_current_fiber
+    );
+}
+
+/// The aarch64 counterpart of the x64 `task_switch_trampoline` above. See that
+/// function for the overall contract; register handling is the main difference.
+///
+/// x18 is deliberately not saved as it is not allocatable in Cranelift.
+#[cfg(all(has_mmu_interruption, target_arch = "aarch64"))]
+#[unsafe(naked)]
+unsafe extern "C" fn task_switch_trampoline(_vmctx: usize) {
+    naked_asm!(
+        "
+        // Establish an ordinary AAPCS64 frame record so stack walks can see
+        // through, and set x29 as our frame pointer so it can be handed to
+        // `yield_current_fiber` as the trampoline FP.
+        stp x29, x30, [sp, #-16]!
+        mov x29, sp
+
+        // Save the registers that an AAPCS64 call may clobber. x19-x28 and the
+        // low halves of v8-v15 are callee-saved, but we save the vector
+        // registers wholesale anyway since their upper halves are not.
+        sub sp, sp, #656
+        stp x0, x1, [sp, #0]
+        stp x2, x3, [sp, #16]
+        stp x4, x5, [sp, #32]
+        stp x6, x7, [sp, #48]
+        stp x8, x9, [sp, #64]
+        stp x10, x11, [sp, #80]
+        stp x12, x13, [sp, #96]
+        stp x14, x15, [sp, #112]
+        stp x16, x17, [sp, #128]
+
+        stp q0, q1, [sp, #144]
+        stp q2, q3, [sp, #176]
+        stp q4, q5, [sp, #208]
+        stp q6, q7, [sp, #240]
+        stp q8, q9, [sp, #272]
+        stp q10, q11, [sp, #304]
+        stp q12, q13, [sp, #336]
+        stp q14, q15, [sp, #368]
+        stp q16, q17, [sp, #400]
+        stp q18, q19, [sp, #432]
+        stp q20, q21, [sp, #464]
+        stp q22, q23, [sp, #496]
+        stp q24, q25, [sp, #528]
+        stp q26, q27, [sp, #560]
+        stp q28, q29, [sp, #592]
+        stp q30, q31, [sp, #624]
+
+        // vmctx is already in x0, care of the signal handler.
+        //
+        // The following instructions prepare:
+        // `x1` the value of `x9`, which is the scratch register with the return
+        // address.
+        // `x2` the value of `x29`, which is the frame pointer.
+        mov x1, x9
+        mov x2, x29
+        // Call yield_current_fiber() to do the task switch.
+        bl {}
+
+        // Restore registers.
+        ldp q0, q1, [sp, #144]
+        ldp q2, q3, [sp, #176]
+        ldp q4, q5, [sp, #208]
+        ldp q6, q7, [sp, #240]
+        ldp q8, q9, [sp, #272]
+        ldp q10, q11, [sp, #304]
+        ldp q12, q13, [sp, #336]
+        ldp q14, q15, [sp, #368]
+        ldp q16, q17, [sp, #400]
+        ldp q18, q19, [sp, #432]
+        ldp q20, q21, [sp, #464]
+        ldp q22, q23, [sp, #496]
+        ldp q24, q25, [sp, #528]
+        ldp q26, q27, [sp, #560]
+        ldp q28, q29, [sp, #592]
+        ldp q30, q31, [sp, #624]
+
+        ldp x0, x1, [sp, #0]
+        ldp x2, x3, [sp, #16]
+        ldp x4, x5, [sp, #32]
+        ldp x6, x7, [sp, #48]
+        ldp x8, x9, [sp, #64]
+        ldp x10, x11, [sp, #80]
+        ldp x12, x13, [sp, #96]
+        ldp x14, x15, [sp, #112]
+        ldp x16, x17, [sp, #128]
+        add sp, sp, #656
+
+        ldp x29, x30, [sp], #16
+
+        // Resume right after the load instruction that triggered the signal
+        // handler. x9 was restored above, so it again holds the return address.
+        br x9
+        ",
+        sym yield_current_fiber
+    );
+}
+
+/// Returns the program counter recorded in a signal's `ucontext`.
+#[cfg(has_mmu_interruption)]
+#[expect(
+    clippy::cast_possible_truncation,
+    reason = "has_mmu_interruption implies a 64-bit usize"
+)]
+fn ucontext_pc(ucontext: &libc::ucontext_t) -> usize {
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "x86_64")] {
+            ucontext.uc_mcontext.gregs[libc::REG_RIP as usize] as usize
+        } else if #[cfg(target_arch = "aarch64")] {
+            ucontext.uc_mcontext.pc as usize
+        }
+    }
+}
+
+/// Arranges for the `ucontext` of an MMU-interrupt segfault to resume at
+/// `task_switch_trampoline` rather than at the original `return_address`.
+///
+/// Leaves the original `return_address` in the scratch register where the
+/// trampoline can find it.
+///
+/// The vmctx is already in the first argument register, pinned there by
+/// `dead_load_with_context`, so the trampoline needs no help finding it.
+#[cfg(has_mmu_interruption)]
+fn resume_into_task_switch_trampoline(ucontext: &mut libc::ucontext_t, return_address: *const ()) {
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "x86_64")] {
+            ucontext.uc_mcontext.gregs[libc::REG_RIP as usize] =
+                task_switch_trampoline as *const () as i64;
+            ucontext.uc_mcontext.gregs[libc::REG_R10 as usize] = return_address as i64;
+        } else if #[cfg(target_arch = "aarch64")] {
+            ucontext.uc_mcontext.pc = task_switch_trampoline as *const () as u64;
+            ucontext.uc_mcontext.regs[9] = return_address as u64;
+        }
+    }
+}
+
 unsafe extern "C" fn trap_handler(
     signum: libc::c_int,
     siginfo: *mut libc::siginfo_t,
@@ -148,6 +525,34 @@ unsafe extern "C" fn trap_handler(
             None => return false,
         };
 
+        // Check for segfaults meant as cues to end an epoch.
+        #[cfg(has_mmu_interruption)]
+        // SAFETY: `si_code` field is always initialized for SIGSEGV.
+        if signum == libc::SIGSEGV && unsafe { (*siginfo).si_code } == SEGV_ACCERR {
+            // Compare it with the offsets of MMU-interrupt-check instructions
+            // as stored in the object file.
+            let ucontext = unsafe { &mut *(context as *mut libc::ucontext_t) };
+            let pc = ucontext_pc(ucontext);
+            // Now things get expensive: we call lookup_code(), which takes a global lock.
+            if let Some((code_memory, offset_within_code)) = lookup_code(pc) {
+                // Every host that `has_mmu_interruption` allows is
+                // little-endian, so we can just treat the stored
+                // little-endians as native u32s.
+                if let Some(return_address) = code_memory.return_address_for_mmu_interrupt_check(
+                    offset_within_code
+                        .try_into()
+                        .expect("MMU-interrupt-check location should fit in 32 bits"),
+                ) {
+                    // It is an interrupt check. Arrange to resume at the asm
+                    // trampoline after the signal handler exits.
+                    resume_into_task_switch_trampoline(ucontext, return_address);
+                    return true;
+                }
+            }
+            // Else it is an ordinary trap or the .wasmtime.mmu_interrupt_checks
+            // section is missing from the binary; continue on.
+        }
+
         // If we hit an exception while handling a previous trap, that's
         // quite bad, so bail out and let the system handle this
         // recursive segfault.
@@ -332,7 +737,7 @@ unsafe fn get_trap_registers(cx: *mut libc::c_void, _signum: libc::c_int) -> Tra
     }
 }
 
-/// Updates the siginfo context stored in `cx` to resume to `handler` up on
+/// Updates the siginfo context stored in `cx` to resume to `handler` upon
 /// resumption while returning from the signal handler.
 unsafe fn store_handler_in_ucontext(cx: *mut libc::c_void, handler: &Handler) {
     cfg_if::cfg_if! {
diff --git a/crates/wasmtime/src/runtime/vm/traphandlers.rs b/crates/wasmtime/src/runtime/vm/traphandlers.rs
index acbe5c356ad0..b96d8790b1db 100644
--- a/crates/wasmtime/src/runtime/vm/traphandlers.rs
+++ b/crates/wasmtime/src/runtime/vm/traphandlers.rs
@@ -76,12 +76,11 @@ fn lazy_per_thread_init() {
 /// activation on the stack, or the entry trampoline back to the the host, if
 /// the exception is uncaught.
 ///
-/// This is currently only called from the `raise` builtin of
-/// Wasmtime. This builtin is only used when the host returns back to
-/// wasm and indicates that a trap or exception should be raised. In
-/// this situation the host has already stored trap or exception
-/// information within the `CallThreadState` and this is the low-level
-/// operation to actually perform an unwind.
+/// This is called from the `raise` builtin of Wasmtime. This builtin is only
+/// used when the host returns back to wasm and indicates that a trap or
+/// exception should be raised. In this situation, the host has already stored
+/// trap or exception information within the `CallThreadState`, and this is the
+/// low-level operation to actually perform an unwind.
 ///
 /// Note that this function is used both for Pulley and for native execution.
 /// For Pulley this function will return and the interpreter will be
@@ -94,7 +93,7 @@ fn lazy_per_thread_init() {
 /// Only safe to call when wasm code is on the stack, aka `catch_traps` must
 /// have been previously called. Additionally no Rust destructors can be on the
 /// stack. They will be skipped and not executed.
-pub(super) unsafe fn raise_preexisting_trap(store: &mut dyn VMStore) {
+pub(crate) unsafe fn raise_preexisting_trap(store: &mut dyn VMStore) {
     tls::with(|info| unsafe { info.unwrap().unwind(store) })
 }
 
diff --git a/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs b/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
index 0b40ebadf05e..c44ced482328 100644
--- a/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
+++ b/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
@@ -189,7 +189,7 @@ impl Backtrace {
 
     /// Walk the current Wasm stack, calling `f` for each frame we walk.
     ///
-    /// If Wasm hit a trap, and we calling this from the trap handler, then the
+    /// If Wasm hit a trap and we are calling this from the trap handler, then the
     /// Wasm exit trampoline didn't run, and we use the provided PC and FP
     /// instead of looking them up in `VMStoreContext`.
     ///
diff --git a/crates/wasmtime/src/runtime/vm/vmcontext.rs b/crates/wasmtime/src/runtime/vm/vmcontext.rs
index ceaa88cbb383..8caa1eb587ce 100644
--- a/crates/wasmtime/src/runtime/vm/vmcontext.rs
+++ b/crates/wasmtime/src/runtime/vm/vmcontext.rs
@@ -5,9 +5,13 @@ mod vm_host_func_context;
 
 pub use self::vm_host_func_context::VMArrayCallHostFuncContext;
 use crate::prelude::*;
+#[cfg(has_mmu_interruption)]
+use crate::runtime::vm::SendSyncPtr;
 use crate::runtime::vm::{InterpreterRef, VMGcRef, VmPtr, VmSafe, f32x4, f64x2, i8x16};
 use crate::store::StoreOpaque;
 use crate::vm::stack_switching::VMStackChain;
+#[cfg(has_mmu_interruption)]
+use alloc::sync::Arc;
 use core::cell::UnsafeCell;
 use core::ffi::c_void;
 use core::fmt;
@@ -15,7 +19,12 @@ use core::marker;
 use core::mem::{self, MaybeUninit};
 use core::ops::Range;
 use core::ptr::{self, NonNull};
+#[cfg(has_mmu_interruption)]
 use core::sync::atomic::{AtomicUsize, Ordering};
+#[cfg(has_mmu_interruption)]
+use rustix::mm::{MapFlags, MprotectFlags, ProtFlags, mmap_anonymous, mprotect, munmap};
+#[cfg(has_mmu_interruption)]
+use rustix::param::page_size;
 use wasmtime_environ::{
     BuiltinFunctionIndex, DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex,
     DefinedTagIndex, NUM_COMPONENT_CONTEXT_SLOTS, VMCONTEXT_MAGIC, VMSharedTypeIndex,
@@ -1099,6 +1108,13 @@ pub struct VMStoreContext {
     /// yield if running asynchronously.
     pub epoch_deadline: UnsafeCell<u64>,
 
+    /// The page of virtual memory used to signal that it's time to switch
+    /// tasks. Compiled guest code regularly attempts a read at this address.
+    /// When it is time to switch, the host uses mprotect() to forbid reads. The
+    /// fault soon caused by guest code then lands in the signal handler, which
+    /// effects a switch and resets the page permissions.
+    mmu_interrupt_page_ptr: Option<VmPtr<c_void>>, // ptr-sized
+
     /// The "store version".
     ///
     /// This is used to test whether stack-frame handles referring to
@@ -1319,6 +1335,7 @@ impl Default for VMStoreContext {
         VMStoreContext {
             fuel_consumed: UnsafeCell::new(0),
             epoch_deadline: UnsafeCell::new(0),
+            mmu_interrupt_page_ptr: None,
             execution_version: 0,
             stack_limit: UnsafeCell::new(usize::max_value()),
             gc_heap: UnsafeCell::new(VMMemoryDefinition {
@@ -1339,6 +1356,137 @@ impl Default for VMStoreContext {
     }
 }
 
+/// Methods related to the special memory page that supports MMU interrupts
+#[cfg(has_mmu_interruption)]
+impl VMStoreContext {
+    /// Returns a new instance that has a page of memory allocated for use with
+    /// `mmu-interruption`.
+    ///
+    /// The caller is responsible for calling
+    /// [`VMStoreContext::unmap_interrupt_page()`], since this has no
+    /// destructor.
+    pub fn with_interrupt_page() -> Self {
+        let mut ret = Self::default();
+        // SAFETY: `mmap_anonymous()` is unsafe, but passing a null ptr, as we do,
+        // satisfies its safety conditions, letting the kernel select the
+        // address. The returned memory is owned by us and freed in
+        // `unmap_interrupt_page`.
+        ret.mmu_interrupt_page_ptr = unsafe {
+            let page_ptr = mmap_anonymous(
+                ptr::null_mut(), // Let the kernel pick location.
+                page_size(),
+                ProtFlags::READ,
+                // Privacy doesn't matter, as we never write to the
+                // interrupt page. However, private is the safer choice in
+                // case someone starts doing so.
+                MapFlags::PRIVATE,
+            )
+            .expect("an interrupt page should be allocable");
+            let non_null_page_ptr = NonNull::new(page_ptr)
+                .expect("if mmap returns successfully, its result should not be null");
+            Some(non_null_page_ptr.into())
+        };
+        ret
+    }
+
+    /// Iff MMU interruption is on, returns an object from which we can
+    /// perform an interrupt (that is, protect the interrupt page).
+    ///
+    /// `running` is the store's "a fiber of this store is currently resumed"
+    /// flag, maintained by `StoreOpaque`; see
+    /// [`MmuInterrupter::is_running()`].
+    pub fn mmu_interrupter(&self, fibers_on_stack: Arc<AtomicUsize>) -> Option<MmuInterrupter> {
+        if self.mmu_interrupt_page_ptr.is_some() {
+            Some(MmuInterrupter {
+                vm_store_context: crate::runtime::vm::SendSyncPtr::new(NonNull::from(self)),
+                fibers_on_stack,
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Sets the MMU access control bits to prevent read access. The public road
+    /// to this is through [`VMStoreContext::mmu_interrupter()`].
+    fn protect_interrupt_page(&self) {
+        if let Some(page_ptr) = self.mmu_interrupt_page_ptr {
+            // SAFETY: `page_ptr` originates from `with_interrupt_page()`'s
+            // `mmap_anonymous()` of `page_size()` bytes and is still mapped
+            // (freed only in `unmap_interrupt_page`, which wipes out
+            // `mmu_interrupt_page_ptr`).
+            unsafe {
+                mprotect(page_ptr.as_ptr(), page_size(), MprotectFlags::empty())
+                    .expect("any error from mprotect is a programming error")
+            }
+        } else {
+            panic!("called protect_interrupt_page though mmu-interruption was not on")
+        }
+    }
+
+    /// Sets the MMU access control bits to allow read access to the interrupt
+    /// page, effectively completing an MMU interruption cycle.
+    pub fn unprotect_interrupt_page(&self) {
+        if let Some(page_ptr) = self.mmu_interrupt_page_ptr {
+            // SAFETY: Same as `protect_interrupt_page()`
+            unsafe {
+                mprotect(page_ptr.as_ptr(), page_size(), MprotectFlags::READ)
+                    .expect("any error from mprotect is a programming error")
+            }
+        } else {
+            panic!("called unprotect_interrupt_page though mmu-interruption was not on")
+        }
+    }
+
+    /// Disposes of any allocated MMU-interrupt page. This must be called if
+    /// [`VMStoreContext::with_interrupt_page()`] was used to construct this
+    /// instance, lest we leak a page.
+    pub fn unmap_interrupt_page(&mut self) {
+        if let Some(interrupt_page) = self.mmu_interrupt_page_ptr {
+            // SAFETY: The only origin of the interrupt_page ptr is
+            // with_interrupt_page(), which panics unless it succeeds and is
+            // non-null.
+            unsafe {
+                munmap(interrupt_page.as_ptr(), page_size())
+                    .expect("should be able to unmap interrupt page");
+            }
+        }
+        self.mmu_interrupt_page_ptr = None
+    }
+}
+
+/// A thread-safe handle that can trigger an MMU interruption
+#[cfg(has_mmu_interruption)]
+#[derive(Clone)]
+pub struct MmuInterrupter {
+    vm_store_context: SendSyncPtr<VMStoreContext>,
+    fibers_on_stack: Arc<AtomicUsize>,
+}
+
+#[cfg(has_mmu_interruption)]
+impl MmuInterrupter {
+    /// Twiddles MMU access control bits such that reads from the interrupt page
+    /// will cause a segfault. This soon interrupts the running Wasm, as it will
+    /// will execute such reads at the next function or loop header.
+    pub fn interrupt(&self) {
+        // SAFETY: `MmuInterrupter` is constructed only from a `VMStoreContext`
+        // owned by a `Store`, which outlives the page pointer used here. Also,
+        // the ptr is stable for the store's lifetime, and we here perform only
+        // a thread-safe `mprotect`.
+        unsafe { self.vm_store_context.as_ref().protect_interrupt_page() }
+    }
+
+    /// Returns whether the Store this is associated with is actually running
+    /// Wasm code at the moment. If it isn't, we oughtn't bother interrupting
+    /// it, lest it interrupt itself immediately after it leaves the idle state.
+    ///
+    /// This also returns true if the Store is executing a host call that was
+    /// called from Wasm, so it's a bit of an overshoot.
+    #[cfg(has_mmu_interruption)]
+    pub fn is_running(&self) -> bool {
+        self.fibers_on_stack.load(Ordering::Relaxed) > 0
+    }
+}
+
 #[cfg(test)]
 mod test_vmstore_context {
     use super::{VMMemoryDefinition, VMStoreContext};
diff --git a/crates/winch/src/builder.rs b/crates/winch/src/builder.rs
index e91d43e45929..3efdb900e234 100644
--- a/crates/winch/src/builder.rs
+++ b/crates/winch/src/builder.rs
@@ -71,6 +71,10 @@ impl CompilerBuilder for Builder {
             bail!("Winch does not currently support guest-level debugging");
         }
 
+        if tunables.mmu_interruption {
+            bail!("Winch does not currently support MMU interruption");
+        }
+
         self.tunables = Some(tunables.clone());
         self.cranelift.set_tunables(tunables)?;
         Ok(())
diff --git a/src/commands/run.rs b/src/commands/run.rs
index 4ab21df2a626..7630b6a6a3a7 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -331,9 +331,16 @@ impl RunCommand {
     /// Creates a new `Engine` with the configuration for this command.
     pub fn new_engine(&mut self) -> Result<Engine> {
         let mut config = self.run.common.config(None)?;
-
-        if self.run.common.wasm.timeout.is_some() {
-            config.epoch_interruption(true);
+        let wasm_options = &self.run.common.wasm;
+        let no_interruption_chosen = !wasm_options.mmu_interruption.unwrap_or(false)
+            && !wasm_options.epoch_interruption.unwrap_or(false);
+        if wasm_options.timeout.is_some() {
+            // Make sure we have some kind of reasonably efficient interruption
+            // on. If the user asked for one in particular, go with that one.
+            if no_interruption_chosen {
+                // Pick epoch-interruption, as it's supported everywhere.
+                config.epoch_interruption(true);
+            }
         }
         match self.run.profile {
             Some(Profile::Native(s)) => {
@@ -341,7 +348,9 @@ impl RunCommand {
             }
             Some(Profile::Guest { .. }) => {
                 // Further configured down below as well.
-                config.epoch_interruption(true);
+                if no_interruption_chosen {
+                    config.epoch_interruption(true);
+                }
             }
             None => {}
         }
@@ -581,8 +590,16 @@ impl RunCommand {
             if let Some(timeout) = self.run.common.wasm.timeout {
                 store.set_epoch_deadline(1);
                 let engine = store.engine().clone();
+                // Store isn't Send, so we can't move it to the thread.
+                #[cfg(has_mmu_interruption)]
+                let mmu_interrupter = store.mmu_interrupter();
                 thread::spawn(move || {
                     thread::sleep(timeout);
+                    #[cfg(has_mmu_interruption)]
+                    if let Some(interrupter) = mmu_interrupter {
+                        interrupter.interrupt();
+                        return;
+                    }
                     engine.increment_epoch();
                 });
             }
diff --git a/src/commands/serve.rs b/src/commands/serve.rs
index 11257cf1414d..0a2501453c5b 100644
--- a/src/commands/serve.rs
+++ b/src/commands/serve.rs
@@ -21,6 +21,7 @@ use tokio::io::{self, AsyncWrite};
 use tokio::sync::{Notify, Semaphore};
 use wasmtime::component::{Component, GuestTaskId, Linker};
 use wasmtime::error::Context as _;
+//use wasmtime::runtime::MmuInterrupter;
 use wasmtime::{
     AsContextMut as _, Engine, Result, Store, StoreContextMut, StoreLimits, UpdateDeadline, bail,
 };
@@ -543,6 +544,12 @@ impl ServeCommand {
         Ok(())
     }
 
+    /// Returns whether MMU-based interruption is both requested and usable on this
+    /// host.
+    fn using_mmu_interruption(&self) -> bool {
+        cfg!(has_mmu_interruption) && self.run.common.wasm.mmu_interruption == Some(true)
+    }
+
     async fn serve(mut self) -> Result<()> {
         #[cfg(feature = "debug")]
         let debug_run = self.debugger_setup()?;
@@ -553,7 +560,7 @@ impl ServeCommand {
             .config(use_pooling_allocator_by_default().unwrap_or(None))?;
         config.wasm_component_model(true);
 
-        if self.run.common.wasm.timeout.is_some() {
+        if self.run.common.wasm.timeout.is_some() && !self.using_mmu_interruption() {
             config.epoch_interruption(true);
         }
 
@@ -648,9 +655,15 @@ impl ServeCommand {
 
         log::info!("Listening on {}", self.addr);
 
+        let using_mmu_timeout =
+            self.using_mmu_interruption() && self.run.common.wasm.timeout.is_some();
+        // We always use epoch interruption for profiling and debugging because
+        // MMU interruption doesn't support arbitrary callbacks.
         let epoch_interval = if let Some(Profile::Guest { interval, .. }) = self.run.profile {
             Some(interval)
-        } else if let Some(t) = self.run.common.wasm.timeout {
+        } else if let Some(t) = self.run.common.wasm.timeout
+            && !using_mmu_timeout
+        {
             Some(EPOCH_INTERRUPT_PERIOD.min(t))
         } else if debuggee_store.is_some() {
             Some(Duration::from_millis(1))
@@ -659,6 +672,20 @@ impl ServeCommand {
         };
         let _epoch_thread = epoch_interval.map(|t| EpochThread::spawn(t, engine.clone()));
 
+        // Spin up a thread to do MMU-based interrupts of worker threads in
+        // round-robin order. Hang onto the thread to keep it alive.
+        #[cfg(has_mmu_interruption)]
+        let (interrupter_registry, _interrupter_thread) = if using_mmu_timeout {
+            let registry = Arc::new(MmuInterrupterRegistry::default());
+            let thread = MmuInterruptThread::spawn(
+                mmu_interrupt_period().min(self.run.common.wasm.timeout.unwrap_or(Duration::MAX)),
+                registry.clone(),
+            );
+            (Some(registry), Some(thread))
+        } else {
+            (None, None)
+        };
+
         let max_instance_reuse_count = self.max_instance_reuse_count.unwrap_or_else(|| {
             if let ProxyPre::P3(_) = &instance {
                 DEFAULT_WASIP3_MAX_INSTANCE_REUSE_COUNT
@@ -699,6 +726,8 @@ impl ServeCommand {
             instance,
             next_instance_id: AtomicU64::default(),
             next_request_id: AtomicU64::default(),
+            #[cfg(has_mmu_interruption)]
+            interrupter_registry,
             // Give one shutdown guard to this handler which will track the
             // full lifetime of any instances spawned.
             _shutdown_guard: Box::new(shutdown.clone().increment()),
@@ -813,6 +842,10 @@ struct HostWorkerState {
     max_instance_reuse_count: usize,
     max_instance_concurrent_reuse_count: usize,
     request_timeout: Duration,
+    /// Registry from which this store's MMU interrupter must be removed before
+    /// the store is dropped. `None` when MMU interruption is not in use.
+    #[cfg(has_mmu_interruption)]
+    interrupter_registry: Option<Arc<MmuInterrupterRegistry>>,
 }
 
 impl WorkerState for HostWorkerState {
@@ -844,6 +877,14 @@ impl WorkerState for HostWorkerState {
     }
 
     fn drop(&self, mut store: Store<Self::StoreData>, result: Result<(), wasmtime::Error>) {
+        // Unregister the store's MMU interrupter before dropping the store. The
+        // interrupter holds a raw pointer into the store's `VMStoreContext` and
+        // must not remain reachable.
+        #[cfg(has_mmu_interruption)]
+        if let Some(registry) = &self.interrupter_registry {
+            registry.unregister(self.instance_id);
+        }
+
         if let Err(error) = result {
             eprintln!("worker failed: {error:?}");
         }
@@ -866,6 +907,10 @@ struct HostHandlerState {
     next_instance_id: AtomicU64,
     next_request_id: AtomicU64,
     sem_requests: Semaphore,
+    /// Registry of live stores' MMU interrupters shared with the background
+    /// interrupter thread. `None` when MMU interruption is not used.
+    #[cfg(has_mmu_interruption)]
+    interrupter_registry: Option<Arc<MmuInterrupterRegistry>>,
     _shutdown_guard: Box<dyn std::any::Any + Send + Sync>,
 }
 
@@ -889,7 +934,38 @@ impl HandlerState for HostHandlerState {
         let mut store = self
             .cmd
             .new_store(self.component.engine(), Some(instance_id))?;
-        let proxy = self.instantiate_into(&mut store).await?;
+
+        // Register this store's MMU interrupter so the `MmuInterruptThread` can
+        // do its work. It is normally unregistered in `HostWorkerState::drop()` before
+        // the store is dropped. We register it before instantiate_into(), lest
+        // the Wasm's initializer run on unreasonably long.
+        #[cfg(has_mmu_interruption)]
+        if let Some(registry) = &self.interrupter_registry {
+            if let Some(interrupter) = store.mmu_interrupter() {
+                let interrupter_again = interrupter.clone();
+                registry.register(
+                    instance_id,
+                    Box::new(move || interrupter.interrupt()),
+                    Box::new(move || interrupter_again.is_running()),
+                );
+            }
+        }
+
+        // If something goes wrong instantiating the pre-instance into the
+        // store, we won't ever construct a HostWorkerState whose drop() is
+        // responsible for calling unregister(). So unregister it here before
+        // bailing out. Critically, we avoid leaving a raw pointer to a freed
+        // `VMStoreContext` in the registry.
+        let proxy = match self.instantiate_into(&mut store).await {
+            Ok(proxy) => proxy,
+            Err(e) => {
+                #[cfg(has_mmu_interruption)]
+                if let Some(registry) = &self.interrupter_registry {
+                    registry.unregister(instance_id);
+                }
+                return Err(e);
+            }
+        };
 
         Ok(Instance {
             store,
@@ -905,6 +981,8 @@ impl HandlerState for HostHandlerState {
                 max_instance_concurrent_reuse_count: self.max_instance_concurrent_reuse_count,
                 instance_id,
                 request_timeout: self.cmd.run.common.wasm.timeout.unwrap_or(Duration::MAX),
+                #[cfg(has_mmu_interruption)]
+                interrupter_registry: self.interrupter_registry.clone(),
             },
         })
     }
@@ -960,10 +1038,39 @@ impl GracefulShutdown {
     }
 }
 
-/// When executing with a timeout enabled, this is how frequently epoch
-/// interrupts will be executed to check for timeouts. If guest profiling
-/// is enabled, the guest epoch period will be used.
-const EPOCH_INTERRUPT_PERIOD: Duration = Duration::from_millis(50);
+/// When executing with a timeout enabled, this is how frequently epoch or (at
+/// floor) MMU interrupts will be executed to check for timeouts. If guest
+/// profiling is enabled, the guest epoch period will be used.
+const EPOCH_INTERRUPT_PERIOD: Duration = Duration::from_millis(12);
+
+/// The target per-store interrupt period, i.e. how often we aim to interrupt
+/// each *running* store.
+///
+/// Normally [`EPOCH_INTERRUPT_PERIOD`], but overridable in milliseconds via
+/// `WASMTIME_MMU_INTERRUPT_PERIOD_MS` so the period can be swept while
+/// benchmarking without a rebuild. Note that batching only engages when this
+/// drops below `running_stores * MIN_INTERRUPT_SLEEP`; above that, the period
+/// is reachable by ticking faster and each tick interrupts one store.
+#[cfg(has_mmu_interruption)]
+fn mmu_interrupt_period() -> Duration {
+    match std::env::var("WASMTIME_MMU_INTERRUPT_PERIOD_MS") {
+        Ok(value) => match value.parse::<f64>() {
+            Ok(ms) if ms > 0.0 => {
+                let period = Duration::from_secs_f64(ms / 1000.0);
+                log::info!("MMU interrupt period overridden to {period:?}");
+                period
+            }
+            _ => {
+                log::warn!(
+                    "ignoring un-parseable WASMTIME_MMU_INTERRUPT_PERIOD_MS={value:?}; \
+                     using {EPOCH_INTERRUPT_PERIOD:?}"
+                );
+                EPOCH_INTERRUPT_PERIOD
+            }
+        },
+        Err(_) => EPOCH_INTERRUPT_PERIOD,
+    }
+}
 
 struct EpochThread {
     shutdown: Arc<AtomicBool>,
@@ -997,6 +1104,176 @@ impl Drop for EpochThread {
     }
 }
 
+/// A registry of MMU interrupters belonging to the stores of in-progress
+/// requests.
+#[cfg(has_mmu_interruption)]
+#[derive(Default)]
+struct MmuInterrupterRegistry {
+    inner: Mutex<MmuInterrupterRegistryInner>,
+}
+
+#[cfg(has_mmu_interruption)]
+#[derive(Default)]
+struct MmuInterrupterRegistryInner {
+    entries: Vec<MmuInterrupterEntry>,
+    /// Index of the `entries` element at which the next round of interruption
+    /// will begin.
+    next: usize,
+}
+
+#[cfg(has_mmu_interruption)]
+struct MmuInterrupterEntry {
+    instance_id: u64,
+    interrupt: Box<dyn Fn() + Send + Sync>,
+    /// Whether a fiber of this store is currently resumed, i.e. whether it
+    /// could possibly be running guest code right now.
+    ///
+    /// TODO (This and `interrupt` would more naturally be a single
+    /// `wasmtime::runtime::vm::MmuInterrupter`, but that type is not nameable
+    /// from outside the `wasmtime` crate.)
+    is_running: Box<dyn Fn() -> bool + Send + Sync>,
+}
+
+#[cfg(has_mmu_interruption)]
+impl MmuInterrupterRegistry {
+    fn lock(&self) -> std::sync::MutexGuard<'_, MmuInterrupterRegistryInner> {
+        self.inner.lock().unwrap()
+    }
+
+    /// Registers a store's interrupter by its `instance_id`.
+    fn register(
+        &self,
+        instance_id: u64,
+        interrupt: Box<dyn Fn() + Send + Sync>,
+        is_running: Box<dyn Fn() -> bool + Send + Sync>,
+    ) {
+        let mut inner = self.lock();
+        inner.entries.push(MmuInterrupterEntry {
+            instance_id,
+            interrupt,
+            is_running,
+        });
+    }
+
+    /// Removes a store's interrupter. This must be called before the store is
+    /// dropped.
+    fn unregister(&self, instance_id: u64) {
+        let mut inner = self.lock();
+        if let Some(pos) = inner
+            .entries
+            .iter()
+            .position(|e| e.instance_id == instance_id)
+        {
+            inner.entries.remove(pos);
+            // Slide `next` left to make up for the hole we just poked.
+            if inner.next > pos {
+                inner.next -= 1;
+            }
+        }
+    }
+
+    /// Interrupts the next store in round-robin order, returning the number of
+    /// stores currently running Wasm code.
+    ///
+    /// We skip stores that aren't currently running. Interrupting them would be
+    /// counterproductive, as the interruption would take effect very soon after
+    /// they swap back in, rubbing them of their timeslice.
+    fn interrupt_next(&self) -> usize {
+        // It's vital to hold this lock while interrupt() runs. Otherwise,
+        // unregister() could be called before or during, and interrupt() could
+        // mprotect a page that has been munmap()'d.
+        let mut inner = self.lock();
+        let len = inner.entries.len();
+        if len == 0 {
+            inner.next = 0;
+            return 0;
+        }
+        if inner.next >= len {
+            inner.next = 0;
+        }
+
+        let mut running = 0;
+        let mut interrupted_i: Option<usize> = None;
+        let (head, tail) = inner.entries.split_at(inner.next);
+        let head_enum = head.iter().enumerate();
+        let tail_enum = tail.iter().enumerate().map(|(i, e)| (i + inner.next, e));
+        for (i, entry) in tail_enum.chain(head_enum) {
+            if (entry.is_running)() {
+                running += 1;
+                if interrupted_i.is_none() {
+                    (entry.interrupt)();
+                    interrupted_i = Some(i);
+                }
+            }
+        }
+        inner.next = match interrupted_i {
+            Some(index) => index + 1,
+            // If nothing was found running, still advance so we don't just wait
+            // around for this entry to start, pouncing on it as soon as it
+            // does.
+            None => inner.next + 1,
+        };
+        running
+    }
+}
+
+/// A background thread that triggers MMU interrupts, in round-robin order,
+/// across the live, *running* stores registered in an [`MmuInterrupterRegistry`].
+///
+/// The cadence is adaptive: with `N` live stores and one interrupt per tick,
+/// ticking every `period / N` interrupts every store about once per timeout
+/// window, comparable to how epoch interruption behaves. That interval is
+/// clamped to a 0.5ms floor so heavy concurrency doesn't turn this into a busy
+/// loop.
+#[cfg(has_mmu_interruption)]
+struct MmuInterruptThread {
+    shutdown: Arc<AtomicBool>,
+    handle: Option<std::thread::JoinHandle<()>>,
+}
+
+#[cfg(has_mmu_interruption)]
+impl MmuInterruptThread {
+    /// Spins off a thread to periodically interrupt each running worker in a
+    /// passed-in registry. Each is interrupted about once per `period`. There's
+    /// a little bit of slop because we update our running count only after each
+    /// round of interruption.
+    fn spawn(period: Duration, registry: Arc<MmuInterrupterRegistry>) -> Self {
+        let shutdown = Arc::new(AtomicBool::new(false));
+        let handle = {
+            let shutdown = Arc::clone(&shutdown);
+            std::thread::spawn(move || {
+                let mut running: usize = 0;
+                while !shutdown.load(Ordering::Relaxed) {
+                    // Even if nothing is running now (`running` = 0), be there to
+                    // interrupt within `period` in case something starts up.
+                    let period_between_workers =
+                        period / u32::try_from(running.max(1)).unwrap_or(u32::MAX);
+
+                    // sleep() can't sleep much shorter than 169µs. Introduce
+                    // batching or something if we need better.
+                    std::thread::sleep(period_between_workers);
+                    running = registry.interrupt_next();
+                }
+            })
+        };
+
+        MmuInterruptThread {
+            shutdown,
+            handle: Some(handle),
+        }
+    }
+}
+
+#[cfg(has_mmu_interruption)]
+impl Drop for MmuInterruptThread {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            self.shutdown.store(true, Ordering::Relaxed);
+            handle.join().unwrap();
+        }
+    }
+}
+
 type WriteProfile = Box<dyn FnOnce(StoreContextMut<Host>) + Send>;
 
 fn setup_epoch_handler(
@@ -1015,8 +1292,14 @@ fn setup_epoch_handler(
         }
     }
 
-    // Profiling disabled but there's a global request timeout
-    if cmd.run.common.wasm.timeout.is_some() || cmd.run.common.debug.debugger.is_some() {
+    // Profiling is disabled, but there's a global request timeout. When MMU
+    // interruption is handling that timeout, it yields the fiber on its own.
+    // Set up epoch interruption for cases which require other kinds of
+    // on-interrupt behavior.
+    let mmu_timeout = cmd.using_mmu_interruption() && cmd.run.common.wasm.timeout.is_some();
+    if (cmd.run.common.wasm.timeout.is_some() && !mmu_timeout)
+        || cmd.run.common.debug.debugger.is_some()
+    {
         store.epoch_deadline_async_yield_and_update(1);
         store.set_epoch_deadline(1);
     }
diff --git a/tests/all/cli_tests.rs b/tests/all/cli_tests.rs
index ea54c4b3ee41..037ff7b858f6 100644
--- a/tests/all/cli_tests.rs
+++ b/tests/all/cli_tests.rs
@@ -144,6 +144,63 @@ fn run_wasmtime_simple_wat() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn run_wasmtime_mmu_interruption_requires_signals_based_traps() -> Result<()> {
+    let wasm = build_wasm("tests/all/cli_tests/empty-module.wat")?;
+    let output = run_wasmtime_for_output(
+        &[
+            "run",
+            "-Ccache=n",
+            "-Wmmu-interruption=y",
+            "-Osignals-based-traps=n",
+            wasm.path().to_str().unwrap(),
+        ],
+        None,
+    )?;
+    assert!(
+        !output.status.success(),
+        "expected wasmtime to fail; stdout: {}, stderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("requires signals-based traps"),
+        "unexpected stderr: {stderr}"
+    );
+    Ok(())
+}
+
+#[test]
+#[cfg(not(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    target_os = "linux"
+)))]
+fn run_wasmtime_mmu_interruption_unsupported_host() -> Result<()> {
+    let wasm = build_wasm("tests/all/cli_tests/empty-module.wat")?;
+    let output = run_wasmtime_for_output(
+        &[
+            "run",
+            "-Ccache=n",
+            "-Wmmu-interruption=y",
+            wasm.path().to_str().unwrap(),
+        ],
+        None,
+    )?;
+    assert!(
+        !output.status.success(),
+        "expected wasmtime to fail; stdout: {}, stderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("supported only on x86_64 and aarch64"),
+        "unexpected stderr: {stderr}"
+    );
+    Ok(())
+}
+
 // Running a wat that traps.
 #[test]
 fn run_wasmtime_unreachable_wat() -> Result<()> {
@@ -2719,6 +2776,30 @@ start a print 1234
         .await
     }
 
+    // Shows that MMU interruption interrupts busy loops during `wasmtime serve`
+    // and thus allows them to time out promptly. (Timeout is actuated by
+    // wasi-http in response to what it gets back from
+    // `HostWorkerExpiration::poll()`.)
+    //
+    // MMU interruption is available on only certain hosts. However, we define
+    // it unconditionally so `foreach_cli!`'s assertion below is satisfied:
+    // every `p2_cli_*` Wasm program has a corresponding test.
+    #[tokio::test]
+    async fn p2_cli_serve_busy_loop() -> Result<()> {
+        #[cfg(has_mmu_interruption)]
+        cli_serve_sleep(
+            P2_CLI_SERVE_BUSY_LOOP_COMPONENT,
+            CONNECTION_COUNT_MANY,
+            REQUESTS_PER_CONNECTION_MANY,
+            |cmd| {
+                cmd.arg("-Scli");
+                cmd.arg("-Wmmu-interruption=y");
+            },
+        )
+        .await?;
+        Ok(())
+    }
+
     async fn cli_serve_sleep(
         component: &str,
         connection_count: usize,
diff --git a/tests/all/main.rs b/tests/all/main.rs
index fde88f83edae..c0094becbe5e 100644
--- a/tests/all/main.rs
+++ b/tests/all/main.rs
@@ -39,6 +39,7 @@ mod linker;
 mod memory;
 mod memory_creator;
 mod missing_async;
+mod mmu_interruption;
 mod module;
 mod module_serialize;
 mod name;
diff --git a/tests/all/mmu_interruption.rs b/tests/all/mmu_interruption.rs
new file mode 100644
index 000000000000..38cfd46075fd
--- /dev/null
+++ b/tests/all/mmu_interruption.rs
@@ -0,0 +1,331 @@
+#![cfg(not(miri))]
+
+use object::{LittleEndian, Object, ObjectSection, U32};
+use std::future::Future;
+use std::pin::Pin;
+use std::ptr::null;
+use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+use wasmtime::{Config, Engine, Module, Result};
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    target_os = "linux"
+))]
+use wasmtime::{Instance, Store};
+use wasmtime_environ::obj::ELF_WASMTIME_MMU_INTERRUPT_CHECKS;
+use wasmtime_test_macros::wasmtime_test;
+
+// Parses the MMU-interrupt-check section out of a precompiled module,
+// returning the check offsets and the packed bits giving each check's load
+// length.
+fn mmu_interrupt_checks(elf_bytes: &[u8]) -> (Vec<u32>, Vec<u8>) {
+    let elf = object::read::elf::ElfFile64::<object::Endianness>::parse(elf_bytes)
+        .expect("ELF should be parseable");
+    let section = elf
+        .section_by_name(ELF_WASMTIME_MMU_INTERRUPT_CHECKS)
+        .expect(&format!(
+            "{ELF_WASMTIME_MMU_INTERRUPT_CHECKS} section should be present"
+        ));
+    let data = section.data().unwrap();
+
+    let (count_raw, rest) = object::from_bytes::<U32<LittleEndian>>(data).expect(
+        ".wasmtime.mmu_interrupt_checks section should be long enough to contain a count of MMU-interrupt checks",
+    );
+    let count = count_raw.get(LittleEndian) as usize;
+    let (starts_raw, rest) = object::slice_from_bytes::<U32<LittleEndian>>(rest, count)
+        .expect(".wasmtime.mmu_interrupt_checks section should be long enough to contain a location for each MMU-interrupt check");
+    let starts: Vec<u32> = starts_raw.iter().map(|b| b.get(LittleEndian)).collect();
+    let (length_bits, _rest) = object::slice_from_bytes::<u8>(rest, count.div_ceil(8))
+        .expect(".wasmtime.mmu_interrupt_checks section should be long enough to contain a length bit for each MMU-interrupt check");
+
+    (starts, length_bits.to_vec())
+}
+
+// A function with an infinite loop contains two MMU-interrupt checks, one in
+// the function prologue and another at the loop backedge. If you change this
+// wat, change it in mmu-interruption-compile-loop{,-aarch64}.wat, too.
+const LOOPING_MODULE: &str = r#"(module
+             (memory 0)
+             (func (loop (br 0)))
+           )"#;
+
+// Asserts that each MMU-interrupt-check offset encoded into the binary points
+// to the byte after its corresponding dead load.
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn mmu_interrupt_check_offsets(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.target("x86_64").unwrap();
+    let engine = Engine::new(config).unwrap();
+
+    let elf_bytes = engine.precompile_module(LOOPING_MODULE.as_bytes()).unwrap();
+    let (starts, length_bits) = mmu_interrupt_checks(&elf_bytes);
+
+    // The emitted machine code is nailed down by the
+    // mmu-interruption-compile-loop.wat disas test. As long as that keeps
+    // passing, these values remain valid.
+    assert_eq!(
+        starts,
+        vec![12, 15],
+        "There should be 2 MMU-interrupt checks (function prologue & loop backedge). The offset of the prologue's dead load should be 12, and that of the loop's backedge should be 15."
+    );
+    assert_eq!(
+        length_bits,
+        vec![0],
+        "Neither check's load instruction uses R12 or RSP as its source, so all length bits should be 0."
+    );
+    Ok(())
+}
+
+// The aarch64 counterpart of `mmu_interrupt_check_offsets`.
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn mmu_interrupt_check_offsets_aarch64(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.target("aarch64").unwrap();
+    let engine = Engine::new(config).unwrap();
+
+    let elf_bytes = engine.precompile_module(LOOPING_MODULE.as_bytes()).unwrap();
+    let (starts, length_bits) = mmu_interrupt_checks(&elf_bytes);
+
+    // The emitted machine code is nailed down by the
+    // mmu-interruption-compile-loop-aarch64.wat disas test. As long as that
+    // keeps passing, these values remain valid.
+    assert_eq!(
+        starts,
+        vec![20, 24],
+        "There should be 2 MMU-interrupt checks (function prologue & loop backedge). The offset of the prologue's dead load should be 20, and that of the loop's backedge should be 24."
+    );
+    assert_eq!(
+        length_bits,
+        vec![0b11],
+        "Every aarch64 instruction is 4 bytes wide, so both checks' length bits should be 1."
+    );
+    Ok(())
+}
+
+// Runs two Wasm functions, interleaved, with MMU interruption enabled and
+// interruptions triggered. Shows that the functions return happily after
+// interruption. Loops several times to test multiple interrupts switching
+// between Wasm modules in a single `Store`.
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    target_os = "linux"
+))]
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+async fn mmu_interruption_signal_handler_trapping_and_switching(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    let engine = Engine::new(config).unwrap();
+
+    let module_one = Module::new(
+        &engine,
+        r#"(module
+             (memory 0)
+             (func (export "one") (result i32)
+                i32.const 1
+             )
+           )"#,
+    )
+    .unwrap();
+    let module_two = Module::new(
+        &engine,
+        r#"(module
+             (memory 0)
+             (func (export "two") (result i32)
+                i32.const 2
+             )
+           )"#,
+    )
+    .unwrap();
+
+    let mut store = Store::new(&engine, ());
+    store.epoch_deadline_trap();
+    let interrupter = store.mmu_interrupter().unwrap();
+
+    let instance_one = Instance::new_async(&mut store, &module_one, &[])
+        .await
+        .unwrap();
+    let instance_two = Instance::new_async(&mut store, &module_two, &[])
+        .await
+        .unwrap();
+    let func_one = instance_one
+        .get_typed_func::<(), i32>(&mut store, "one")
+        .unwrap();
+    let func_two = instance_two
+        .get_typed_func::<(), i32>(&mut store, "two")
+        .unwrap();
+
+    for _ in 0..5 {
+        // Trap as soon as the first MMU-interrupt check is encountered, in the
+        // function prologue. Recall that MMU interruption doesn't operate based
+        // on a numeric deadline but on an external entity protecting the memory
+        // page, typically on a timer.
+        interrupter.interrupt();
+        assert_eq!(func_one.call_async(&mut store, ()).await.unwrap(), 1);
+        interrupter.interrupt();
+        assert_eq!(func_two.call_async(&mut store, ()).await.unwrap(), 2);
+    }
+    Ok(())
+}
+
+// Runs a Wasm function to an MMU-interrupt check point, lets it yield, then
+// drops the future driving it. This exercises the cancellation path of
+// `yield_current_fiber()`, which should unwind the stack cleanly.
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    target_os = "linux"
+))]
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn mmu_interruption_cancellation_during_yield(config: &mut Config) -> Result<()> {
+    // Returns a no-op waker that lets nothing re-poll our future after it
+    // yields the first time. This keeps the fiber parked inside the yield until
+    // we explicitly drop its future.
+    fn null_waker() -> Waker {
+        const VTABLE: RawWakerVTable = RawWakerVTable::new(|_| RAW, |_| {}, |_| {}, |_| {});
+        const RAW: RawWaker = RawWaker::new(null(), &VTABLE);
+        unsafe { Waker::from_raw(RAW) }
+    }
+
+    /// Polls a future continually until it is complete, returning its result.
+    fn busy_poll_until_complete<F: Future>(mut future: F) -> F::Output {
+        let waker = null_waker();
+        let mut ctx = Context::from_waker(&waker);
+        // SAFETY: `future` lives until function returns, and we never move it.
+        let mut future = unsafe { Pin::new_unchecked(&mut future) };
+        loop {
+            if let Poll::Ready(r) = future.as_mut().poll(&mut ctx) {
+                return r;
+            }
+        }
+    }
+
+    config.mmu_interruption(true);
+    let engine = Engine::new(config).unwrap();
+    let module = Module::new(
+        &engine,
+        r#"(module
+             (memory 0)
+             (func (export "loop") (loop (br 0)))
+           )"#,
+    )
+    .unwrap();
+
+    let mut store = Store::new(&engine, ());
+    store.epoch_deadline_trap();
+    store.mmu_interrupter().unwrap().interrupt();
+
+    let instance = busy_poll_until_complete(Instance::new_async(&mut store, &module, &[])).unwrap();
+    let func = instance
+        .get_typed_func::<(), ()>(&mut store, "loop")
+        .unwrap();
+
+    let waker = null_waker();
+    let mut ctx = Context::from_waker(&waker);
+
+    // Pin future so we're allowed to poll it.
+    let mut future = Box::pin(func.call_async(&mut store, ()));
+
+    // Poll once to run into the MMU-interrupt check.
+    match future.as_mut().poll(&mut ctx) {
+        // When `yield_current_fiber()` switches fibers, the old fiber's
+        // `Pending` should percolate up via `block_on()`.
+        Poll::Pending => {}
+        Poll::Ready(r) => panic!(
+            "the fiber should have suspended itself, returning Pending, but it returned Ready({r:?}) instead"
+        ),
+    }
+
+    // Drop the suspended future. This triggers `FiberFuture::Drop` →
+    // `StoreFiber::dispose()`, which gets cranky that we're dropping a fiber
+    // that isn't done and resumes the fiber with an `Err`. This triggers the
+    // `yield_current_fiber` path we're interested in: stack unwinding.
+    drop(future);
+
+    // If the unwinding went wrong, the above drop would have spun forever (in a
+    // release build) or hit the `debug_assert!(result.is_ok())` (in debug) in
+    // `StoreFiber::dispose()`. Thus, getting here means success.
+    Ok(())
+}
+
+// For aot compilation, signals based traps are required.
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn requires_signals_based_traps(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.signals_based_traps(false);
+    let err = Engine::new(config).expect_err("engine creation should fail");
+    assert_eq!(
+        err.to_string(),
+        "MMU interruption requires signals-based traps",
+    );
+    Ok(())
+}
+
+// With Cranelift only the x64 and aarch64 backends are supported.
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn requires_supported_target(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.target("riscv64").unwrap();
+    config.signals_based_traps(true);
+    let err = Engine::new(config).expect_err("engine creation should fail");
+    assert_eq!(
+        err.to_string(),
+        "MMU interruption is supported only on x86_64 and aarch64, not for `riscv64-unknown-unknown-elf`",
+    );
+    Ok(())
+}
+
+// The Winch backend does not support this feature.
+#[wasmtime_test(strategies(only(Winch)))]
+fn rejected_by_winch(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    let err = Engine::new(config).expect_err("engine creation should fail");
+    assert_eq!(
+        err.to_string(),
+        "Winch does not currently support MMU interruption",
+    );
+    Ok(())
+}
+
+// Pulley does not support this feature, since it does not support signals
+// based traps.
+#[wasmtime_test(strategies(only(CraneliftPulley)))]
+fn rejected_by_pulley(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    let err = Engine::new(config).expect_err("engine creation should fail");
+    assert!(
+        err.to_string().contains("MMU interruption"),
+        "unexpected error: {err}"
+    );
+    Ok(())
+}
+
+// AOT compilation succeeds with the right flags set.
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn precompile_succeeds_for_valid_config_on_any_host(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.target("x86_64-unknown-linux-gnu").unwrap();
+    config.signals_based_traps(true);
+    let engine = Engine::new(config).unwrap();
+    engine
+        .precompile_module(r#"(module (memory 0) (func))"#.as_bytes())
+        .expect("precompilation should succeed regardless of host");
+    Ok(())
+}
+
+#[cfg(not(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    target_os = "linux"
+)))]
+#[wasmtime_test(strategies(only(CraneliftNative)))]
+fn compile_and_run_fails_on_unsupported_host(config: &mut Config) -> Result<()> {
+    config.mmu_interruption(true);
+    config.signals_based_traps(true);
+    let err = match Engine::new(config) {
+        Err(err) => err,
+        Ok(engine) => Module::new(&engine, "(module)")
+            .expect_err("compile-and-run should fail on an unsupported host"),
+    };
+    let err = format!("{err:?}");
+    assert!(
+        err.contains("supported only on x86_64 and aarch64"),
+        "unexpected error: {err}"
+    );
+    Ok(())
+}
diff --git a/tests/disas/aarch64-entry-trampoline.wat b/tests/disas/aarch64-entry-trampoline.wat
index a38bd560b256..7dcdfb4a583f 100644
--- a/tests/disas/aarch64-entry-trampoline.wat
+++ b/tests/disas/aarch64-entry-trampoline.wat
@@ -20,11 +20,11 @@
 ;;       mov     x3, x1
 ;;       mov     x12, x29
 ;;       ldr     x15, [x0, #8]
-;;       str     x12, [x15, #0x48]
+;;       str     x12, [x15, #0x50]
 ;;       mov     x13, sp
-;;       str     x13, [x15, #0x40]
+;;       str     x13, [x15, #0x48]
 ;;       adr     x14, #0xa0
-;;       str     x14, [x15, #0x50]
+;;       str     x14, [x15, #0x58]
 ;;       mov     x2, x0
 ;;       stur    x15, [sp]
 ;;       bl      #0
@@ -45,7 +45,7 @@
 ;;       ret
 ;;   a0: mov     x0, #1
 ;;   a4: ldur    x15, [sp]
-;;   a8: str     x0, [x15, #0x88]
+;;   a8: str     x0, [x15, #0x90]
 ;;   ac: mov     w0, #0
 ;;   b0: add     sp, sp, #0x10
 ;;   b4: ldp     d8, d9, [sp], #0x10
diff --git a/tests/disas/alias-region-globals.wat b/tests/disas/alias-region-globals.wat
index 9d5b7d4fb933..8092b0e6f127 100644
--- a/tests/disas/alias-region-globals.wat
+++ b/tests/disas/alias-region-globals.wat
@@ -16,13 +16,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1476395008 "VMGlobalImport+0x0"
 ;;     region3 = 402653184 "PublicGlobal"
 ;;     region4 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/alias-region-memories.wat b/tests/disas/alias-region-memories.wat
index 406af6ea83cf..22f7177d5ae2 100644
--- a/tests/disas/alias-region-memories.wat
+++ b/tests/disas/alias-region-memories.wat
@@ -16,7 +16,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1275068416 "VMMemoryImport+0x0"
 ;;     region3 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region4 = 603979784 "VMMemoryDefinition+0x8"
@@ -24,7 +24,7 @@
 ;;     region6 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/alias-region-tables.wat b/tests/disas/alias-region-tables.wat
index 0e29ba737ef5..8df2b6126748 100644
--- a/tests/disas/alias-region-tables.wat
+++ b/tests/disas/alias-region-tables.wat
@@ -17,7 +17,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1342177280 "VMTableImport+0x0"
 ;;     region3 = 671088640 "VMTableDefinition+0x0"
 ;;     region4 = 671088648 "VMTableDefinition+0x8"
@@ -30,7 +30,7 @@
 ;;     region11 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/arith.wat b/tests/disas/arith.wat
index dc3930d8eac3..41695a35f44d 100644
--- a/tests/disas/arith.wat
+++ b/tests/disas/arith.wat
@@ -16,10 +16,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/array-call-trampoline.wat b/tests/disas/array-call-trampoline.wat
index c8e6fef5999a..74eb505f70ea 100644
--- a/tests/disas/array-call-trampoline.wat
+++ b/tests/disas/array-call-trampoline.wat
@@ -11,10 +11,10 @@
 ;; function u268435456:0(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 2013265920 "HostValRaw+0x0"
 ;;     region1 = 8 "VMContext+0x8"
-;;     region2 = 67108936 "VMStoreContext+0x48"
-;;     region3 = 67108928 "VMStoreContext+0x40"
-;;     region4 = 67108944 "VMStoreContext+0x50"
-;;     region5 = 67109000 "VMStoreContext+0x88"
+;;     region2 = 67108944 "VMStoreContext+0x50"
+;;     region3 = 67108936 "VMStoreContext+0x48"
+;;     region4 = 67108952 "VMStoreContext+0x58"
+;;     region5 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64, i32, i64) -> i32, i64 tail
 ;;     fn0 = colocated u0:0 sig0
 ;;
@@ -26,11 +26,11 @@
 ;;     v5 = load.i64 notrap little region0 v2+16
 ;;     v7 = get_frame_pointer.i64 
 ;;     v6 = load.i64 notrap aligned readonly can_move region1 v0+8
-;;     store notrap aligned region2 v7, v6+72
+;;     store notrap aligned region2 v7, v6+80
 ;;     v8 = get_stack_pointer.i64 
-;;     store notrap aligned region3 v8, v6+64
+;;     store notrap aligned region3 v8, v6+72
 ;;     v9 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region4 v9, v6+80
+;;     store notrap aligned region4 v9, v6+88
 ;;     try_call fn0(v0, v1, v4, v5), sig0, block2(ret0, ret1), [ default: block3 ]
 ;;
 ;; block2(v10: i32, v11: i64):
@@ -41,7 +41,7 @@
 ;;
 ;; block3:
 ;;     v13 = iconst.i64 1
-;;     store notrap aligned region5 v13, v6+136  ; v13 = 1
+;;     store notrap aligned region5 v13, v6+144  ; v13 = 1
 ;;     v14 = iconst.i8 0
 ;;     return v14  ; v14 = 0
 ;; }
diff --git a/tests/disas/array-copy-anyref.wat b/tests/disas/array-copy-anyref.wat
index d744058b5f28..35c326bc70ec 100644
--- a/tests/disas/array-copy-anyref.wat
+++ b/tests/disas/array-copy-anyref.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
 ;; @002b                               trapz v2, user16
 ;; @002b                               v8 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+32
+;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+40
 ;; @002b                               v7 = uextend.i64 v2
 ;; @002b                               v10 = iadd v9, v7
 ;; @002b                               v11 = iconst.i64 16
@@ -45,7 +45,7 @@
 ;; @002b                               v38 = uextend.i64 v37
 ;; @002b                               v44 = icmp ugt v43, v38
 ;; @002b                               trapnz v44, user17
-;; @002b                               v63 = load.i64 notrap aligned region3 v8+40
+;; @002b                               v63 = load.i64 notrap aligned region3 v8+48
 ;; @002b                               v25 = iconst.i64 20
 ;; @002b                               v26 = iadd v10, v25  ; v25 = 20
 ;;                                     v111 = iconst.i64 2
diff --git a/tests/disas/array-copy-i64.wat b/tests/disas/array-copy-i64.wat
index 961a841ddf49..086772e377f3 100644
--- a/tests/disas/array-copy-i64.wat
+++ b/tests/disas/array-copy-i64.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -25,7 +25,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
 ;; @002b                               trapz v2, user16
 ;; @002b                               v8 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+32
+;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+40
 ;; @002b                               v7 = uextend.i64 v2
 ;; @002b                               v10 = iadd v9, v7
 ;; @002b                               v11 = iconst.i64 16
@@ -47,7 +47,7 @@
 ;; @002b                               v38 = uextend.i64 v37
 ;; @002b                               v44 = icmp ugt v43, v38
 ;; @002b                               trapnz v44, user17
-;; @002b                               v63 = load.i64 notrap aligned region3 v8+40
+;; @002b                               v63 = load.i64 notrap aligned region3 v8+48
 ;; @002b                               v25 = iconst.i64 24
 ;; @002b                               v26 = iadd v10, v25  ; v25 = 24
 ;;                                     v76 = iconst.i64 3
diff --git a/tests/disas/array-copy-i8.wat b/tests/disas/array-copy-i8.wat
index f63c6d9d8026..e8cec239a7c3 100644
--- a/tests/disas/array-copy-i8.wat
+++ b/tests/disas/array-copy-i8.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -25,7 +25,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
 ;; @002b                               trapz v2, user16
 ;; @002b                               v8 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+32
+;; @002b                               v9 = load.i64 notrap aligned readonly can_move region2 v8+40
 ;; @002b                               v7 = uextend.i64 v2
 ;; @002b                               v10 = iadd v9, v7
 ;; @002b                               v11 = iconst.i64 16
@@ -47,7 +47,7 @@
 ;; @002b                               v38 = uextend.i64 v37
 ;; @002b                               v44 = icmp ugt v43, v38
 ;; @002b                               trapnz v44, user17
-;; @002b                               v63 = load.i64 notrap aligned region3 v8+40
+;; @002b                               v63 = load.i64 notrap aligned region3 v8+48
 ;; @002b                               v25 = iconst.i64 20
 ;; @002b                               v26 = iadd v10, v25  ; v25 = 20
 ;; @002b                               v30 = iadd v26, v15
diff --git a/tests/disas/array-copy-inline.wat b/tests/disas/array-copy-inline.wat
index cd74ca2fd46d..5db6164b760e 100644
--- a/tests/disas/array-copy-inline.wat
+++ b/tests/disas/array-copy-inline.wat
@@ -17,19 +17,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @002a                               trapz v2, user16
 ;; @002a                               v8 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v9 = load.i64 notrap aligned readonly can_move region2 v8+32
+;; @002a                               v9 = load.i64 notrap aligned readonly can_move region2 v8+40
 ;; @002a                               v7 = uextend.i64 v2
 ;; @002a                               v10 = iadd v9, v7
 ;; @002a                               v11 = iconst.i64 16
@@ -51,7 +51,7 @@
 ;; @002a                               v38 = uextend.i64 v37
 ;; @002a                               v44 = icmp ugt v43, v38
 ;; @002a                               trapnz v44, user17
-;; @002a                               v63 = load.i64 notrap aligned region3 v8+40
+;; @002a                               v63 = load.i64 notrap aligned region3 v8+48
 ;; @002a                               v25 = iconst.i64 20
 ;; @002a                               v26 = iadd v10, v25  ; v25 = 20
 ;;                                     v85 = iconst.i64 2
diff --git a/tests/disas/array-fill-anyref.wat b/tests/disas/array-fill-anyref.wat
index 7fea96be825b..802bc245879c 100644
--- a/tests/disas/array-fill-anyref.wat
+++ b/tests/disas/array-fill-anyref.wat
@@ -19,19 +19,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @0030                               trapz v2, user16
 ;; @0030                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0030                               v6 = uextend.i64 v2
 ;; @0030                               v9 = iadd v8, v6
 ;; @0030                               v10 = iconst.i64 16
@@ -43,7 +43,7 @@
 ;; @0030                               v13 = uextend.i64 v12
 ;; @0030                               v19 = icmp ugt v18, v13
 ;; @0030                               trapnz v19, user17
-;; @0030                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0030                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0030                               v24 = iconst.i64 20
 ;; @0030                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -76,19 +76,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003e                               trapz v2, user16
 ;; @003e                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003e                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003e                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003e                               v6 = uextend.i64 v2
 ;; @003e                               v9 = iadd v8, v6
 ;; @003e                               v10 = iconst.i64 16
@@ -100,7 +100,7 @@
 ;; @003e                               v13 = uextend.i64 v12
 ;; @003e                               v19 = icmp ugt v18, v13
 ;; @003e                               trapnz v19, user17
-;; @003e                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003e                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003e                               v24 = iconst.i64 20
 ;; @003e                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -135,19 +135,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @004e                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @004e                               v10 = uextend.i64 v2
 ;; @004e                               v13 = iadd v12, v10
 ;; @004e                               v14 = iconst.i64 16
@@ -159,7 +159,7 @@
 ;; @004e                               v17 = uextend.i64 v16
 ;; @004e                               v23 = icmp ugt v22, v17
 ;; @004e                               trapnz v23, user17
-;; @004e                               v40 = load.i64 notrap aligned region3 v11+40
+;; @004e                               v40 = load.i64 notrap aligned region3 v11+48
 ;; @004e                               v28 = iconst.i64 20
 ;; @004e                               v29 = iadd v13, v28  ; v28 = 20
 ;;                                     v59 = iconst.i64 2
diff --git a/tests/disas/array-fill-externref.wat b/tests/disas/array-fill-externref.wat
index a634f7dd560c..d2b9a792cede 100644
--- a/tests/disas/array-fill-externref.wat
+++ b/tests/disas/array-fill-externref.wat
@@ -15,19 +15,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @002f                               trapz v2, user16
 ;; @002f                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @002f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @002f                               v6 = uextend.i64 v2
 ;; @002f                               v9 = iadd v8, v6
 ;; @002f                               v10 = iconst.i64 16
@@ -39,7 +39,7 @@
 ;; @002f                               v13 = uextend.i64 v12
 ;; @002f                               v19 = icmp ugt v18, v13
 ;; @002f                               trapnz v19, user17
-;; @002f                               v36 = load.i64 notrap aligned region3 v7+40
+;; @002f                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @002f                               v24 = iconst.i64 20
 ;; @002f                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -72,19 +72,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003d                               trapz v2, user16
 ;; @003d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003d                               v6 = uextend.i64 v2
 ;; @003d                               v9 = iadd v8, v6
 ;; @003d                               v10 = iconst.i64 16
@@ -96,7 +96,7 @@
 ;; @003d                               v13 = uextend.i64 v12
 ;; @003d                               v19 = icmp ugt v18, v13
 ;; @003d                               trapnz v19, user17
-;; @003d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003d                               v24 = iconst.i64 20
 ;; @003d                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
diff --git a/tests/disas/array-fill-f32.wat b/tests/disas/array-fill-f32.wat
index 34d23ff59b36..7a3192368c74 100644
--- a/tests/disas/array-fill-f32.wat
+++ b/tests/disas/array-fill-f32.wat
@@ -19,19 +19,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, f32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: f32, v5: i32):
 ;; @0030                               trapz v2, user16
 ;; @0030                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0030                               v6 = uextend.i64 v2
 ;; @0030                               v9 = iadd v8, v6
 ;; @0030                               v10 = iconst.i64 16
@@ -43,7 +43,7 @@
 ;; @0030                               v13 = uextend.i64 v12
 ;; @0030                               v19 = icmp ugt v18, v13
 ;; @0030                               trapnz v19, user17
-;; @0030                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0030                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0030                               v24 = iconst.i64 20
 ;; @0030                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -76,13 +76,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -90,7 +90,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0041                               trapz v2, user16
 ;; @0041                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0041                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0041                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0041                               v6 = uextend.i64 v2
 ;; @0041                               v9 = iadd v8, v6
 ;; @0041                               v10 = iconst.i64 16
@@ -102,7 +102,7 @@
 ;; @0041                               v13 = uextend.i64 v12
 ;; @0041                               v19 = icmp ugt v18, v13
 ;; @0041                               trapnz v19, user17
-;; @0041                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0041                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0041                               v24 = iconst.i64 20
 ;; @0041                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v43 = iconst.i64 2
@@ -123,19 +123,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0052                               trapz v2, user16
 ;; @0052                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0052                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0052                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0052                               v6 = uextend.i64 v2
 ;; @0052                               v9 = iadd v8, v6
 ;; @0052                               v10 = iconst.i64 16
@@ -147,7 +147,7 @@
 ;; @0052                               v13 = uextend.i64 v12
 ;; @0052                               v19 = icmp ugt v18, v13
 ;; @0052                               trapnz v19, user17
-;; @0052                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0052                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0052                               v24 = iconst.i64 20
 ;; @0052                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
diff --git a/tests/disas/array-fill-f64.wat b/tests/disas/array-fill-f64.wat
index 3bca39c79826..de2a6a1d8fa2 100644
--- a/tests/disas/array-fill-f64.wat
+++ b/tests/disas/array-fill-f64.wat
@@ -19,19 +19,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, f64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: f64, v5: i32):
 ;; @0030                               trapz v2, user16
 ;; @0030                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0030                               v6 = uextend.i64 v2
 ;; @0030                               v9 = iadd v8, v6
 ;; @0030                               v10 = iconst.i64 16
@@ -43,7 +43,7 @@
 ;; @0030                               v13 = uextend.i64 v12
 ;; @0030                               v19 = icmp ugt v18, v13
 ;; @0030                               trapnz v19, user17
-;; @0030                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0030                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0030                               v24 = iconst.i64 24
 ;; @0030                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v49 = iconst.i64 3
@@ -76,13 +76,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -90,7 +90,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0045                               trapz v2, user16
 ;; @0045                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0045                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0045                               v6 = uextend.i64 v2
 ;; @0045                               v9 = iadd v8, v6
 ;; @0045                               v10 = iconst.i64 16
@@ -102,7 +102,7 @@
 ;; @0045                               v13 = uextend.i64 v12
 ;; @0045                               v19 = icmp ugt v18, v13
 ;; @0045                               trapnz v19, user17
-;; @0045                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0045                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0045                               v24 = iconst.i64 24
 ;; @0045                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v43 = iconst.i64 3
@@ -123,19 +123,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @005a                               trapz v2, user16
 ;; @005a                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @005a                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @005a                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @005a                               v6 = uextend.i64 v2
 ;; @005a                               v9 = iadd v8, v6
 ;; @005a                               v10 = iconst.i64 16
@@ -147,7 +147,7 @@
 ;; @005a                               v13 = uextend.i64 v12
 ;; @005a                               v19 = icmp ugt v18, v13
 ;; @005a                               trapnz v19, user17
-;; @005a                               v36 = load.i64 notrap aligned region3 v7+40
+;; @005a                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @005a                               v24 = iconst.i64 24
 ;; @005a                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v49 = iconst.i64 3
diff --git a/tests/disas/array-fill-funcref.wat b/tests/disas/array-fill-funcref.wat
index 49fc34cf7864..b7f7be30adee 100644
--- a/tests/disas/array-fill-funcref.wat
+++ b/tests/disas/array-fill-funcref.wat
@@ -22,13 +22,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:25 sig0
 ;;     stack_limit = gv2
@@ -36,7 +36,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):
 ;; @003b                               trapz v2, user16
 ;; @003b                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003b                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003b                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003b                               v6 = uextend.i64 v2
 ;; @003b                               v9 = iadd v8, v6
 ;; @003b                               v10 = iconst.i64 16
@@ -48,7 +48,7 @@
 ;; @003b                               v13 = uextend.i64 v12
 ;; @003b                               v19 = icmp ugt v18, v13
 ;; @003b                               trapnz v19, user17
-;; @003b                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003b                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003b                               v24 = iconst.i64 20
 ;; @003b                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v51 = iconst.i64 2
@@ -83,13 +83,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:25 sig0
 ;;     stack_limit = gv2
@@ -97,7 +97,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0049                               trapz v2, user16
 ;; @0049                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0049                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0049                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0049                               v6 = uextend.i64 v2
 ;; @0049                               v9 = iadd v8, v6
 ;; @0049                               v10 = iconst.i64 16
@@ -109,7 +109,7 @@
 ;; @0049                               v13 = uextend.i64 v12
 ;; @0049                               v19 = icmp ugt v18, v13
 ;; @0049                               trapnz v19, user17
-;; @0049                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0049                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0049                               v24 = iconst.i64 20
 ;; @0049                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v50 = iconst.i64 2
@@ -145,14 +145,14 @@
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     region5 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:6 sig0
@@ -167,7 +167,7 @@
 ;;                                     v55 = load.i32 notrap aligned region5 v56
 ;; @0057                               trapz v55, user16
 ;; @0057                               v8 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0057                               v9 = load.i64 notrap aligned readonly can_move region2 v8+32
+;; @0057                               v9 = load.i64 notrap aligned readonly can_move region2 v8+40
 ;; @0057                               v7 = uextend.i64 v55
 ;; @0057                               v10 = iadd v9, v7
 ;; @0057                               v11 = iconst.i64 16
@@ -179,7 +179,7 @@
 ;; @0057                               v14 = uextend.i64 v13
 ;; @0057                               v20 = icmp ugt v19, v14
 ;; @0057                               trapnz v20, user17
-;; @0057                               v37 = load.i64 notrap aligned region3 v8+40
+;; @0057                               v37 = load.i64 notrap aligned region3 v8+48
 ;; @0057                               v25 = iconst.i64 20
 ;; @0057                               v26 = iadd v10, v25  ; v25 = 20
 ;;                                     v59 = iconst.i64 2
@@ -214,10 +214,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/array-fill-i16.wat b/tests/disas/array-fill-i16.wat
index 145c04ad6c59..2f91f226e951 100644
--- a/tests/disas/array-fill-i16.wat
+++ b/tests/disas/array-fill-i16.wat
@@ -23,19 +23,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @0031                               trapz v2, user16
 ;; @0031                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0031                               v6 = uextend.i64 v2
 ;; @0031                               v9 = iadd v8, v6
 ;; @0031                               v10 = iconst.i64 16
@@ -47,7 +47,7 @@
 ;; @0031                               v13 = uextend.i64 v12
 ;; @0031                               v19 = icmp ugt v18, v13
 ;; @0031                               trapnz v19, user17
-;; @0031                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0031                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0031                               v24 = iconst.i64 20
 ;; @0031                               v25 = iadd v9, v24  ; v24 = 20
 ;; @0031                               v16 = iconst.i64 1
@@ -80,13 +80,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -94,7 +94,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003f                               v6 = uextend.i64 v2
 ;; @003f                               v9 = iadd v8, v6
 ;; @003f                               v10 = iconst.i64 16
@@ -106,7 +106,7 @@
 ;; @003f                               v13 = uextend.i64 v12
 ;; @003f                               v19 = icmp ugt v18, v13
 ;; @003f                               trapnz v19, user17
-;; @003f                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003f                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003f                               v24 = iconst.i64 20
 ;; @003f                               v25 = iadd v9, v24  ; v24 = 20
 ;; @003f                               v16 = iconst.i64 1
@@ -127,13 +127,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -141,7 +141,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @004d                               trapz v2, user16
 ;; @004d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @004d                               v6 = uextend.i64 v2
 ;; @004d                               v9 = iadd v8, v6
 ;; @004d                               v10 = iconst.i64 16
@@ -153,7 +153,7 @@
 ;; @004d                               v13 = uextend.i64 v12
 ;; @004d                               v19 = icmp ugt v18, v13
 ;; @004d                               trapnz v19, user17
-;; @004d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @004d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @004d                               v24 = iconst.i64 20
 ;; @004d                               v25 = iadd v9, v24  ; v24 = 20
 ;; @004d                               v16 = iconst.i64 1
@@ -174,19 +174,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @005d                               trapz v2, user16
 ;; @005d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @005d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @005d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @005d                               v6 = uextend.i64 v2
 ;; @005d                               v9 = iadd v8, v6
 ;; @005d                               v10 = iconst.i64 16
@@ -198,7 +198,7 @@
 ;; @005d                               v13 = uextend.i64 v12
 ;; @005d                               v19 = icmp ugt v18, v13
 ;; @005d                               trapnz v19, user17
-;; @005d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @005d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @005d                               v24 = iconst.i64 20
 ;; @005d                               v25 = iadd v9, v24  ; v24 = 20
 ;; @005d                               v16 = iconst.i64 1
diff --git a/tests/disas/array-fill-i31ref.wat b/tests/disas/array-fill-i31ref.wat
index 5473f6b81deb..2a1f7254bf46 100644
--- a/tests/disas/array-fill-i31ref.wat
+++ b/tests/disas/array-fill-i31ref.wat
@@ -19,19 +19,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @0030                               trapz v2, user16
 ;; @0030                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0030                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0030                               v6 = uextend.i64 v2
 ;; @0030                               v9 = iadd v8, v6
 ;; @0030                               v10 = iconst.i64 16
@@ -43,7 +43,7 @@
 ;; @0030                               v13 = uextend.i64 v12
 ;; @0030                               v19 = icmp ugt v18, v13
 ;; @0030                               trapnz v19, user17
-;; @0030                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0030                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0030                               v24 = iconst.i64 20
 ;; @0030                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -76,19 +76,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003e                               trapz v2, user16
 ;; @003e                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003e                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003e                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003e                               v6 = uextend.i64 v2
 ;; @003e                               v9 = iadd v8, v6
 ;; @003e                               v10 = iconst.i64 16
@@ -100,7 +100,7 @@
 ;; @003e                               v13 = uextend.i64 v12
 ;; @003e                               v19 = icmp ugt v18, v13
 ;; @003e                               trapnz v19, user17
-;; @003e                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003e                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003e                               v24 = iconst.i64 20
 ;; @003e                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -135,19 +135,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @004e                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @004e                               v10 = uextend.i64 v2
 ;; @004e                               v13 = iadd v12, v10
 ;; @004e                               v14 = iconst.i64 16
@@ -159,7 +159,7 @@
 ;; @004e                               v17 = uextend.i64 v16
 ;; @004e                               v23 = icmp ugt v22, v17
 ;; @004e                               trapnz v23, user17
-;; @004e                               v40 = load.i64 notrap aligned region3 v11+40
+;; @004e                               v40 = load.i64 notrap aligned region3 v11+48
 ;; @004e                               v28 = iconst.i64 20
 ;; @004e                               v29 = iadd v13, v28  ; v28 = 20
 ;;                                     v59 = iconst.i64 2
diff --git a/tests/disas/array-fill-i32.wat b/tests/disas/array-fill-i32.wat
index e001e1180f8b..75f5f22e31d7 100644
--- a/tests/disas/array-fill-i32.wat
+++ b/tests/disas/array-fill-i32.wat
@@ -23,19 +23,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @0031                               trapz v2, user16
 ;; @0031                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0031                               v6 = uextend.i64 v2
 ;; @0031                               v9 = iadd v8, v6
 ;; @0031                               v10 = iconst.i64 16
@@ -47,7 +47,7 @@
 ;; @0031                               v13 = uextend.i64 v12
 ;; @0031                               v19 = icmp ugt v18, v13
 ;; @0031                               trapnz v19, user17
-;; @0031                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0031                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0031                               v24 = iconst.i64 20
 ;; @0031                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
@@ -80,13 +80,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -94,7 +94,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003f                               v6 = uextend.i64 v2
 ;; @003f                               v9 = iadd v8, v6
 ;; @003f                               v10 = iconst.i64 16
@@ -106,7 +106,7 @@
 ;; @003f                               v13 = uextend.i64 v12
 ;; @003f                               v19 = icmp ugt v18, v13
 ;; @003f                               trapnz v19, user17
-;; @003f                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003f                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003f                               v24 = iconst.i64 20
 ;; @003f                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v43 = iconst.i64 2
@@ -127,13 +127,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -141,7 +141,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @004d                               trapz v2, user16
 ;; @004d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @004d                               v6 = uextend.i64 v2
 ;; @004d                               v9 = iadd v8, v6
 ;; @004d                               v10 = iconst.i64 16
@@ -153,7 +153,7 @@
 ;; @004d                               v13 = uextend.i64 v12
 ;; @004d                               v19 = icmp ugt v18, v13
 ;; @004d                               trapnz v19, user17
-;; @004d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @004d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @004d                               v24 = iconst.i64 20
 ;; @004d                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v43 = iconst.i64 2
@@ -174,19 +174,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @005d                               trapz v2, user16
 ;; @005d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @005d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @005d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @005d                               v6 = uextend.i64 v2
 ;; @005d                               v9 = iadd v8, v6
 ;; @005d                               v10 = iconst.i64 16
@@ -198,7 +198,7 @@
 ;; @005d                               v13 = uextend.i64 v12
 ;; @005d                               v19 = icmp ugt v18, v13
 ;; @005d                               trapnz v19, user17
-;; @005d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @005d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @005d                               v24 = iconst.i64 20
 ;; @005d                               v25 = iadd v9, v24  ; v24 = 20
 ;;                                     v49 = iconst.i64 2
diff --git a/tests/disas/array-fill-i64.wat b/tests/disas/array-fill-i64.wat
index 001bd55c886d..6ab22a765dee 100644
--- a/tests/disas/array-fill-i64.wat
+++ b/tests/disas/array-fill-i64.wat
@@ -23,19 +23,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):
 ;; @0031                               trapz v2, user16
 ;; @0031                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0031                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0031                               v6 = uextend.i64 v2
 ;; @0031                               v9 = iadd v8, v6
 ;; @0031                               v10 = iconst.i64 16
@@ -47,7 +47,7 @@
 ;; @0031                               v13 = uextend.i64 v12
 ;; @0031                               v19 = icmp ugt v18, v13
 ;; @0031                               trapnz v19, user17
-;; @0031                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0031                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0031                               v24 = iconst.i64 24
 ;; @0031                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v49 = iconst.i64 3
@@ -80,13 +80,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -94,7 +94,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @003f                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @003f                               v6 = uextend.i64 v2
 ;; @003f                               v9 = iadd v8, v6
 ;; @003f                               v10 = iconst.i64 16
@@ -106,7 +106,7 @@
 ;; @003f                               v13 = uextend.i64 v12
 ;; @003f                               v19 = icmp ugt v18, v13
 ;; @003f                               trapnz v19, user17
-;; @003f                               v36 = load.i64 notrap aligned region3 v7+40
+;; @003f                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @003f                               v24 = iconst.i64 24
 ;; @003f                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v42 = iconst.i64 3
@@ -127,13 +127,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -141,7 +141,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @004d                               trapz v2, user16
 ;; @004d                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @004d                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @004d                               v6 = uextend.i64 v2
 ;; @004d                               v9 = iadd v8, v6
 ;; @004d                               v10 = iconst.i64 16
@@ -153,7 +153,7 @@
 ;; @004d                               v13 = uextend.i64 v12
 ;; @004d                               v19 = icmp ugt v18, v13
 ;; @004d                               trapnz v19, user17
-;; @004d                               v36 = load.i64 notrap aligned region3 v7+40
+;; @004d                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @004d                               v24 = iconst.i64 24
 ;; @004d                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v43 = iconst.i64 3
@@ -174,19 +174,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @005b                               trapz v2, user16
 ;; @005b                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @005b                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @005b                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @005b                               v6 = uextend.i64 v2
 ;; @005b                               v9 = iadd v8, v6
 ;; @005b                               v10 = iconst.i64 16
@@ -198,7 +198,7 @@
 ;; @005b                               v13 = uextend.i64 v12
 ;; @005b                               v19 = icmp ugt v18, v13
 ;; @005b                               trapnz v19, user17
-;; @005b                               v36 = load.i64 notrap aligned region3 v7+40
+;; @005b                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @005b                               v24 = iconst.i64 24
 ;; @005b                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v49 = iconst.i64 3
diff --git a/tests/disas/basic-wat-test.wat b/tests/disas/basic-wat-test.wat
index 55ba224a6e59..3d9d761225e0 100644
--- a/tests/disas/basic-wat-test.wat
+++ b/tests/disas/basic-wat-test.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/block-params-br_if-single-pred.wat b/tests/disas/block-params-br_if-single-pred.wat
index 878407abb12d..c82b82b2e5c0 100644
--- a/tests/disas/block-params-br_if-single-pred.wat
+++ b/tests/disas/block-params-br_if-single-pred.wat
@@ -22,12 +22,12 @@
 )
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32) tail
 ;;     stack_limit = gv2
diff --git a/tests/disas/block-params-if-else-same-values.wat b/tests/disas/block-params-if-else-same-values.wat
index 52d4fe6c1c26..7bb1bda6811d 100644
--- a/tests/disas/block-params-if-else-same-values.wat
+++ b/tests/disas/block-params-if-else-same-values.wat
@@ -22,12 +22,12 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/block-params-loop-single-iteration.wat b/tests/disas/block-params-loop-single-iteration.wat
index e6b86da63e5b..0f3faa95bc99 100644
--- a/tests/disas/block-params-loop-single-iteration.wat
+++ b/tests/disas/block-params-loop-single-iteration.wat
@@ -15,10 +15,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/bounds-check.wat b/tests/disas/bounds-check.wat
index 8271ac7954af..05a2ec503a9d 100644
--- a/tests/disas/bounds-check.wat
+++ b/tests/disas/bounds-check.wat
@@ -26,13 +26,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/br_table.wat b/tests/disas/br_table.wat
index 2d89f7766267..71f6ff2f92b8 100644
--- a/tests/disas/br_table.wat
+++ b/tests/disas/br_table.wat
@@ -33,10 +33,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -71,10 +71,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -109,10 +109,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -135,10 +135,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/branch-hinting-disabled.wat b/tests/disas/branch-hinting-disabled.wat
index 21aefdd2c047..30ab1aabf064 100644
--- a/tests/disas/branch-hinting-disabled.wat
+++ b/tests/disas/branch-hinting-disabled.wat
@@ -29,10 +29,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -55,10 +55,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/branch-hinting.wat b/tests/disas/branch-hinting.wat
index 8d9fa1350476..b20ceda48248 100644
--- a/tests/disas/branch-hinting.wat
+++ b/tests/disas/branch-hinting.wat
@@ -74,10 +74,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -97,10 +97,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -120,10 +120,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -146,10 +146,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -172,11 +172,11 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/byteswap.wat b/tests/disas/byteswap.wat
index 9decd0d06758..850b566e6055 100644
--- a/tests/disas/byteswap.wat
+++ b/tests/disas/byteswap.wat
@@ -73,10 +73,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -89,10 +89,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/call-indirect-with-gc.wat b/tests/disas/call-indirect-with-gc.wat
index 3476592e857a..0f93841357f6 100644
--- a/tests/disas/call-indirect-with-gc.wat
+++ b/tests/disas/call-indirect-with-gc.wat
@@ -11,7 +11,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
@@ -22,7 +22,7 @@
 ;;     region9 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/call-indirect-without-gc.wat b/tests/disas/call-indirect-without-gc.wat
index aa0a2c649441..b0bf34568f46 100644
--- a/tests/disas/call-indirect-without-gc.wat
+++ b/tests/disas/call-indirect-without-gc.wat
@@ -11,7 +11,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
@@ -22,7 +22,7 @@
 ;;     region9 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/call-indirect.wat b/tests/disas/call-indirect.wat
index f78277c08053..96d4d049f34e 100644
--- a/tests/disas/call-indirect.wat
+++ b/tests/disas/call-indirect.wat
@@ -9,7 +9,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
@@ -20,7 +20,7 @@
 ;;     region9 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/call-simd.wat b/tests/disas/call-simd.wat
index 8e1ad2a39a30..f9dbc15bb124 100644
--- a/tests/disas/call-simd.wat
+++ b/tests/disas/call-simd.wat
@@ -17,10 +17,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail
 ;;     fn0 = colocated u0:1 sig0
 ;;     const0 = 0x00000004000000030000000200000001
@@ -38,10 +38,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16, v3: i8x16):
diff --git a/tests/disas/call.wat b/tests/disas/call.wat
index 195074f8db56..6746c99ad7a8 100644
--- a/tests/disas/call.wat
+++ b/tests/disas/call.wat
@@ -13,10 +13,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     fn0 = colocated u0:1 sig0
 ;;     stack_limit = gv2
@@ -33,10 +33,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/component-may-leave-without-signals-based-traps.wat b/tests/disas/component-may-leave-without-signals-based-traps.wat
index d9834361eaea..597101ccfc57 100644
--- a/tests/disas/component-may-leave-without-signals-based-traps.wat
+++ b/tests/disas/component-may-leave-without-signals-based-traps.wat
@@ -20,10 +20,10 @@
 ;;       movq    %rbp, %rcx
 ;;       movq    8(%rsi), %rax
 ;;       movq    %rsi, %rbx
-;;       movq    %rcx, 0x30(%rax)
+;;       movq    %rcx, 0x38(%rax)
 ;;       movq    %rbp, %rcx
 ;;       movq    8(%rcx), %rcx
-;;       movq    %rcx, 0x38(%rax)
+;;       movq    %rcx, 0x40(%rax)
 ;;       movl    0x20(%rdi), %eax
 ;;       testl   %eax, %eax
 ;;       je      0x13b
diff --git a/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat b/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat
index c05d9b66d215..3c1094670e9b 100644
--- a/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat
+++ b/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat
@@ -49,13 +49,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
-;;     region3 = 67108968 "VMStoreContext+0x68"
+;;     region3 = 67108976 "VMStoreContext+0x70"
 ;;     region4 = 1946157056 "UnsafeIntrinsicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i64, i64, i64) -> i32 tail
 ;;     sig2 = (i64 vmctx, i64, i64, i64, i64, i32) tail
@@ -71,7 +71,7 @@
 ;; @01b0                               v13 = bor v11, v12
 ;; @01b0                               trapnz v13, heap_oob
 ;; @01aa                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @01aa                               v7 = load.i64 notrap aligned readonly can_move region3 v6+104
+;; @01aa                               v7 = load.i64 notrap aligned readonly can_move region3 v6+112
 ;; @01b0                               v14 = iadd v7, v2
 ;; @01b0                               v15 = load.i32 notrap aligned region4 v14
 ;; @01bf                               v23, v24 = uadd_overflow v2, v9  ; v9 = 4
diff --git a/tests/disas/component-model/checked-intrinsics-inlined.wat b/tests/disas/component-model/checked-intrinsics-inlined.wat
index b2ab799df26e..9b8303bc3653 100644
--- a/tests/disas/component-model/checked-intrinsics-inlined.wat
+++ b/tests/disas/component-model/checked-intrinsics-inlined.wat
@@ -50,13 +50,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
-;;     region3 = 67108968 "VMStoreContext+0x68"
+;;     region3 = 67108976 "VMStoreContext+0x70"
 ;;     region4 = 1946157056 "UnsafeIntrinsicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i64, i64, i64) -> i32 tail
 ;;     sig2 = (i64 vmctx, i64, i64, i64, i64, i32) tail
@@ -72,7 +72,7 @@
 ;; @01b0                               v13 = bor v11, v12
 ;; @01b0                               v15 = iconst.i64 0
 ;; @01aa                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @01aa                               v7 = load.i64 notrap aligned readonly can_move region3 v6+104
+;; @01aa                               v7 = load.i64 notrap aligned readonly can_move region3 v6+112
 ;; @01b0                               v14 = iadd v7, v2
 ;; @01b0                               v16 = select_spectre_guard v13, v15, v14  ; v15 = 0
 ;; @01b0                               trapz v16, heap_oob
diff --git a/tests/disas/component-model/context-intrinsics.wat b/tests/disas/component-model/context-intrinsics.wat
index 9a226ad353e0..f58bee0d720e 100644
--- a/tests/disas/component-model/context-intrinsics.wat
+++ b/tests/disas/component-model/context-intrinsics.wat
@@ -39,7 +39,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %rsi
-;;       movl    0x80(%rsi), %eax
+;;       movl    0x88(%rsi), %eax
 ;;       movq    %rbp, %rsp
 ;;       popq    %rbp
 ;;       retq
@@ -48,7 +48,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %rsi
-;;       movl    0x84(%rsi), %eax
+;;       movl    0x8c(%rsi), %eax
 ;;       movq    %rbp, %rsp
 ;;       popq    %rbp
 ;;       retq
@@ -57,7 +57,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %rsi
-;;       movl    %edx, 0x80(%rsi)
+;;       movl    %edx, 0x88(%rsi)
 ;;       movq    %rbp, %rsp
 ;;       popq    %rbp
 ;;       retq
@@ -66,7 +66,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %rsi
-;;       movl    %edx, 0x84(%rsi)
+;;       movl    %edx, 0x8c(%rsi)
 ;;       movq    %rbp, %rsp
 ;;       popq    %rbp
 ;;       retq
diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.wat
index b35c023e9c39..616a2a0bc686 100644
--- a/tests/disas/component-model/direct-adapter-calls-inlining.wat
+++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat
@@ -56,20 +56,20 @@
 
 ;; function u1:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1476395008 "VMGlobalImport+0x0"
 ;;     region4 = 402653184 "PublicGlobal"
 ;;     region5 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     gv6 = vmctx
 ;;     gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8
-;;     gv8 = load.i64 notrap aligned region1 gv7+24
+;;     gv8 = load.i64 notrap aligned region1 gv7+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32) tail
 ;;     sig2 = (i64 vmctx, i64, i32) -> i32 tail
diff --git a/tests/disas/component-model/direct-adapter-calls-x64.wat b/tests/disas/component-model/direct-adapter-calls-x64.wat
index 27552042cfcf..49668fcfbdb0 100644
--- a/tests/disas/component-model/direct-adapter-calls-x64.wat
+++ b/tests/disas/component-model/direct-adapter-calls-x64.wat
@@ -67,7 +67,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x10, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x4f
@@ -84,7 +84,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x60, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x140
diff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.wat
index ba03b6411780..a2fcec5d2b8b 100644
--- a/tests/disas/component-model/direct-adapter-calls.wat
+++ b/tests/disas/component-model/direct-adapter-calls.wat
@@ -59,10 +59,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -76,11 +76,11 @@
 ;;
 ;; function u1:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     fn0 = colocated u2:0 sig0
 ;;     stack_limit = gv2
@@ -97,14 +97,14 @@
 ;;
 ;; function u2:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1476395008 "VMGlobalImport+0x0"
 ;;     region3 = 402653184 "PublicGlobal"
 ;;     region4 = 1207959576 "VMFunctionImport+0x18"
 ;;     region5 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) tail
 ;;     sig1 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     fn0 = colocated u0:0 sig1
diff --git a/tests/disas/component-model/exported-module-makes-adapters-indirect.wat b/tests/disas/component-model/exported-module-makes-adapters-indirect.wat
index 6bc331932a32..785c93f2ff99 100644
--- a/tests/disas/component-model/exported-module-makes-adapters-indirect.wat
+++ b/tests/disas/component-model/exported-module-makes-adapters-indirect.wat
@@ -60,12 +60,12 @@
 
 ;; function u1:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat b/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat
index 9bdd461592fd..957e4348dc86 100644
--- a/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat
+++ b/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat
@@ -44,13 +44,13 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
-;;     region3 = 67108968 "VMStoreContext+0x68"
+;;     region3 = 67108976 "VMStoreContext+0x70"
 ;;     region4 = 1946157056 "UnsafeIntrinsicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i64) -> i32 tail
 ;;     sig2 = (i64 vmctx, i64, i64, i32) tail
@@ -61,7 +61,7 @@
 ;;
 ;;                                 block0(v0: i64, v1: i64):
 ;; @0153                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0153                               v5 = load.i64 notrap aligned readonly can_move region3 v4+104
+;; @0153                               v5 = load.i64 notrap aligned readonly can_move region3 v4+112
 ;; @0155                               v7 = load.i8 notrap aligned region4 v5
 ;;                                     v18 = iconst.i8 1
 ;;                                     v19 = iadd v7, v18  ; v18 = 1
diff --git a/tests/disas/component-model/inlining-bug.wat b/tests/disas/component-model/inlining-bug.wat
index d68cb6d69eb2..957fa3808513 100644
--- a/tests/disas/component-model/inlining-bug.wat
+++ b/tests/disas/component-model/inlining-bug.wat
@@ -36,17 +36,17 @@
 
 ;; function u2:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     gv6 = vmctx
 ;;     gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8
-;;     gv8 = load.i64 notrap aligned region1 gv7+24
+;;     gv8 = load.i64 notrap aligned region1 gv7+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64) -> i32 tail
 ;;     sig2 = (i64 vmctx, i64) tail
diff --git a/tests/disas/component-model/inlining-fuzz-bug.wat b/tests/disas/component-model/inlining-fuzz-bug.wat
index 421601857118..c21f3adef7ab 100644
--- a/tests/disas/component-model/inlining-fuzz-bug.wat
+++ b/tests/disas/component-model/inlining-fuzz-bug.wat
@@ -39,20 +39,20 @@
 
 ;; function u2:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     gv6 = vmctx
 ;;     gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8
-;;     gv8 = load.i64 notrap aligned region1 gv7+24
+;;     gv8 = load.i64 notrap aligned region1 gv7+32
 ;;     gv9 = vmctx
 ;;     gv10 = load.i64 notrap aligned readonly can_move region0 gv9+8
-;;     gv11 = load.i64 notrap aligned region1 gv10+24
+;;     gv11 = load.i64 notrap aligned region1 gv10+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64) -> i32 tail
 ;;     fn0 = colocated u1:0 sig0
diff --git a/tests/disas/component-model/issue-11458.wat b/tests/disas/component-model/issue-11458.wat
index a238d86e88a5..a7336fb1e0b9 100644
--- a/tests/disas/component-model/issue-11458.wat
+++ b/tests/disas/component-model/issue-11458.wat
@@ -21,14 +21,14 @@
 
 ;; function u1:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     fn0 = colocated u0:0 sig0
diff --git a/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat b/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat
index 8a18e93ae2f5..5f3255e287f8 100644
--- a/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat
+++ b/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat
@@ -66,12 +66,12 @@
 
 ;; function u1:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/component-model/sync-adapter-calls.wat b/tests/disas/component-model/sync-adapter-calls.wat
index 520331c4dc64..c171bdfca0e5 100644
--- a/tests/disas/component-model/sync-adapter-calls.wat
+++ b/tests/disas/component-model/sync-adapter-calls.wat
@@ -52,10 +52,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -70,29 +70,29 @@
 ;; function u1:0(i64 vmctx, i64) -> i32 tail {
 ;;     ss0 = explicit_slot 32, align = 8
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1476395008 "VMGlobalImport+0x0"
 ;;     region4 = 402653184 "PublicGlobal"
-;;     region5 = 67109000 "VMStoreContext+0x88"
+;;     region5 = 67109008 "VMStoreContext+0x90"
 ;;     region6 = 1006632960 "VMDeferredThread+0x0"
 ;;     region7 = 1006632968 "VMDeferredThread+0x8"
 ;;     region8 = 1006632972 "VMDeferredThread+0xc"
 ;;     region9 = 1006632976 "VMDeferredThread+0x10"
-;;     region10 = 67108992 "VMStoreContext+0x80"
+;;     region10 = 67109000 "VMStoreContext+0x88"
 ;;     region11 = 1006632980 "VMDeferredThread+0x14"
-;;     region12 = 67108996 "VMStoreContext+0x84"
+;;     region12 = 67109004 "VMStoreContext+0x8c"
 ;;     region13 = 1006632984 "VMDeferredThread+0x18"
 ;;     region14 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     gv6 = vmctx
 ;;     gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8
-;;     gv8 = load.i64 notrap aligned region1 gv7+24
+;;     gv8 = load.i64 notrap aligned region1 gv7+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32) tail
 ;;     sig2 = (i64 vmctx, i64, i32, i32, i32) tail
@@ -132,7 +132,7 @@
 ;;                                     v8 = iconst.i32 0
 ;;                                     store notrap aligned region4 v8, v11  ; v8 = 0
 ;;                                     v20 = load.i64 notrap aligned readonly can_move region0 v3+8
-;;                                     v21 = load.i64 notrap aligned region5 v20+136
+;;                                     v21 = load.i64 notrap aligned region5 v20+144
 ;;                                     v19 = stack_addr.i64 ss0
 ;;                                     store notrap aligned region6 v21, v19
 ;;                                     v15 = iconst.i32 2
@@ -140,13 +140,13 @@
 ;;                                     store notrap aligned region8 v8, v19+12  ; v8 = 0
 ;;                                     v17 = iconst.i32 1
 ;;                                     store notrap aligned region9 v17, v19+16  ; v17 = 1
-;;                                     v22 = load.i32 notrap aligned region10 v20+128
+;;                                     v22 = load.i32 notrap aligned region10 v20+136
 ;;                                     store notrap aligned region11 v22, v19+20
-;;                                     store notrap aligned region10 v8, v20+128  ; v8 = 0
-;;                                     v24 = load.i32 notrap aligned region12 v20+132
+;;                                     store notrap aligned region10 v8, v20+136  ; v8 = 0
+;;                                     v24 = load.i32 notrap aligned region12 v20+140
 ;;                                     store notrap aligned region13 v24, v19+24
-;;                                     store notrap aligned region12 v8, v20+132  ; v8 = 0
-;;                                     store notrap aligned region5 v19, v20+136
+;;                                     store notrap aligned region12 v8, v20+140  ; v8 = 0
+;;                                     store notrap aligned region5 v19, v20+144
 ;;                                     v26 = load.i64 notrap aligned readonly can_move region3 v3+176
 ;;                                     v27 = load.i32 notrap aligned region4 v26
 ;;                                     store notrap aligned region4 v8, v26  ; v8 = 0
@@ -163,9 +163,9 @@
 ;;                                     jump block13
 ;;
 ;;                                 block13:
-;;                                     store.i64 notrap aligned region5 v21, v20+136
-;;                                     store.i32 notrap aligned region10 v22, v20+128
-;;                                     store.i32 notrap aligned region12 v24, v20+132
+;;                                     store.i64 notrap aligned region5 v21, v20+144
+;;                                     store.i32 notrap aligned region10 v22, v20+136
+;;                                     store.i32 notrap aligned region12 v24, v20+140
 ;;                                     jump block15
 ;;
 ;;                                 block15:
@@ -202,26 +202,26 @@
 ;; function u2:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 32, align = 8
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1476395008 "VMGlobalImport+0x0"
 ;;     region3 = 402653184 "PublicGlobal"
 ;;     region4 = 1207959576 "VMFunctionImport+0x18"
 ;;     region5 = 1207959560 "VMFunctionImport+0x8"
-;;     region6 = 67109000 "VMStoreContext+0x88"
+;;     region6 = 67109008 "VMStoreContext+0x90"
 ;;     region7 = 1006632960 "VMDeferredThread+0x0"
 ;;     region8 = 1006632968 "VMDeferredThread+0x8"
 ;;     region9 = 1006632972 "VMDeferredThread+0xc"
 ;;     region10 = 1006632976 "VMDeferredThread+0x10"
-;;     region11 = 67108992 "VMStoreContext+0x80"
+;;     region11 = 67109000 "VMStoreContext+0x88"
 ;;     region12 = 1006632980 "VMDeferredThread+0x14"
-;;     region13 = 67108996 "VMStoreContext+0x84"
+;;     region13 = 67109004 "VMStoreContext+0x8c"
 ;;     region14 = 1006632984 "VMDeferredThread+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     sig0 = (i64 vmctx, i64, i32) tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32, i32) tail
 ;;     sig2 = (i64 vmctx, i64, i32) -> i32 tail
@@ -255,7 +255,7 @@
 ;; @00c9                               v3 = iconst.i32 0
 ;; @00e8                               store notrap aligned region3 v3, v11  ; v3 = 0
 ;; @00f0                               v20 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @00f0                               v21 = load.i64 notrap aligned region6 v20+136
+;; @00f0                               v21 = load.i64 notrap aligned region6 v20+144
 ;; @00f0                               v19 = stack_addr.i64 ss0
 ;; @00f0                               store notrap aligned region7 v21, v19
 ;; @00ea                               v15 = iconst.i32 2
@@ -263,13 +263,13 @@
 ;; @00f0                               store notrap aligned region9 v3, v19+12  ; v3 = 0
 ;; @00ee                               v17 = iconst.i32 1
 ;; @00f0                               store notrap aligned region10 v17, v19+16  ; v17 = 1
-;; @00f0                               v22 = load.i32 notrap aligned region11 v20+128
+;; @00f0                               v22 = load.i32 notrap aligned region11 v20+136
 ;; @00f0                               store notrap aligned region12 v22, v19+20
-;; @00f0                               store notrap aligned region11 v3, v20+128  ; v3 = 0
-;; @00f0                               v24 = load.i32 notrap aligned region13 v20+132
+;; @00f0                               store notrap aligned region11 v3, v20+136  ; v3 = 0
+;; @00f0                               v24 = load.i32 notrap aligned region13 v20+140
 ;; @00f0                               store notrap aligned region14 v24, v19+24
-;; @00f0                               store notrap aligned region13 v3, v20+132  ; v3 = 0
-;; @00f0                               store notrap aligned region6 v19, v20+136
+;; @00f0                               store notrap aligned region13 v3, v20+140  ; v3 = 0
+;; @00f0                               store notrap aligned region6 v19, v20+144
 ;; @00f2                               v26 = load.i64 notrap aligned readonly can_move region2 v0+176
 ;; @00f2                               v27 = load.i32 notrap aligned region3 v26
 ;; @00f8                               store notrap aligned region3 v3, v26  ; v3 = 0
@@ -286,9 +286,9 @@
 ;; @0104                               jump block11
 ;;
 ;;                                 block11:
-;; @0104                               store.i64 notrap aligned region6 v21, v20+136
-;; @0104                               store.i32 notrap aligned region11 v22, v20+128
-;; @0104                               store.i32 notrap aligned region13 v24, v20+132
+;; @0104                               store.i64 notrap aligned region6 v21, v20+144
+;; @0104                               store.i32 notrap aligned region11 v22, v20+136
+;; @0104                               store.i32 notrap aligned region13 v24, v20+140
 ;; @0104                               jump block13
 ;;
 ;;                                 block13:
diff --git a/tests/disas/component-model/unsafe-intrinsics-used.wat b/tests/disas/component-model/unsafe-intrinsics-used.wat
index 6958bd08d35b..8a0f471540b2 100644
--- a/tests/disas/component-model/unsafe-intrinsics-used.wat
+++ b/tests/disas/component-model/unsafe-intrinsics-used.wat
@@ -36,11 +36,11 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108968 "VMStoreContext+0x68"
+;;     region1 = 67108976 "VMStoreContext+0x70"
 ;;
 ;; block0(v0: i64, v1: i64):
 ;;     v2 = load.i64 notrap aligned readonly can_move region0 v1+8
-;;     v3 = load.i64 notrap aligned readonly can_move region1 v2+104
+;;     v3 = load.i64 notrap aligned readonly can_move region1 v2+112
 ;;     return v3
 ;; }
 ;;
diff --git a/tests/disas/conditional-traps.wat b/tests/disas/conditional-traps.wat
index 7d80d8df06f2..76622dac0db1 100644
--- a/tests/disas/conditional-traps.wat
+++ b/tests/disas/conditional-traps.wat
@@ -23,10 +23,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -42,10 +42,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/dead-code.wat b/tests/disas/dead-code.wat
index f34c462ff1b5..4b4707e18900 100644
--- a/tests/disas/dead-code.wat
+++ b/tests/disas/dead-code.wat
@@ -23,10 +23,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -50,10 +50,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -65,10 +65,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -80,10 +80,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/debug-exceptions.wat b/tests/disas/debug-exceptions.wat
index d6343a619bc8..2d0c5275b04e 100644
--- a/tests/disas/debug-exceptions.wat
+++ b/tests/disas/debug-exceptions.wat
@@ -27,7 +27,7 @@
 ;;       stp     d8, d9, [sp, #-0x10]!
 ;;       sub     sp, sp, #0x20
 ;;       ldr     x0, [x2, #8]
-;;       ldr     x1, [x0, #0x18]
+;;       ldr     x1, [x0, #0x20]
 ;;       stur    x0, [sp, #0x18]
 ;;       mov     x0, sp
 ;;       cmp     x0, x1
@@ -74,7 +74,7 @@
 ;;       str     w4, [x1]
 ;;       mov     w6, #2
 ;;       movk    w6, #0x400, lsl #16
-;;       ldr     x5, [x0, #0x20]
+;;       ldr     x5, [x0, #0x28]
 ;;       add     x1, x5, w3, uxtw
 ;;       str     w6, [x5, w3, uxtw]
 ;;       ldur    x0, [sp, #0x10]
@@ -103,10 +103,10 @@
 ;;       tst     w1, #0xff
 ;;       b.ne    #0x208
 ;;  128: ldur    x2, [sp, #0x18]
-;;       ldr     x1, [x2, #0x28]
+;;       ldr     x1, [x2, #0x30]
 ;;       cmp     x15, x1
 ;;       b.hi    #0x1f0
-;;  138: ldr     x1, [x2, #0x20]
+;;  138: ldr     x1, [x2, #0x28]
 ;;       add     x1, x1, #0x18
 ;;       ldr     w0, [x1, w0, uxtw]
 ;;       stur    w0, [sp, #8]
@@ -149,7 +149,7 @@
 ;;  1bc: ldur    x2, [sp, #0x10]
 ;;  1c0: bl      #0x3fc
 ;;  1c4: ldur    x0, [sp, #0x18]
-;;  1c8: ldr     x3, [x0, #0x20]
+;;  1c8: ldr     x3, [x0, #0x28]
 ;;  1cc: add     x1, x3, w2, uxtw
 ;;  1d0: mov     x3, x2
 ;;  1d4: b       #0xec
diff --git a/tests/disas/debug.wat b/tests/disas/debug.wat
index 74f254de13cd..d53f2dcfb316 100644
--- a/tests/disas/debug.wat
+++ b/tests/disas/debug.wat
@@ -16,7 +16,7 @@
 ;;       movl    %edx, 8(%rsp)
 ;;       movl    %ecx, 0xc(%rsp)
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       movq    %rsp, %rax
 ;;       cmpq    %r11, %rax
 ;;       jb      0x62
@@ -65,11 +65,11 @@
 ;;       movq    %rdx, (%rsp)
 ;;       movq    %rbp, %r9
 ;;       movq    8(%rdi), %r10
-;;       movq    %r9, 0x48(%r10)
+;;       movq    %r9, 0x50(%r10)
 ;;       movq    %rsp, %r9
-;;       movq    %r9, 0x40(%r10)
+;;       movq    %r9, 0x48(%r10)
 ;;       leaq    0x3e(%rip), %r9
-;;       movq    %r9, 0x50(%r10)
+;;       movq    %r9, 0x58(%r10)
 ;;       movq    %r8, %rdx
 ;;       movq    %r10, 8(%rsp)
 ;;       callq   0
@@ -88,7 +88,7 @@
 ;;       popq    %rbp
 ;;       retq
 ;;   f8: movq    8(%rsp), %r10
-;;   fd: movq    $1, 0x88(%r10)
+;;   fd: movq    $1, 0x90(%r10)
 ;;  108: xorl    %eax, %eax
 ;;  10a: movq    0x10(%rsp), %rbx
 ;;  10f: movq    0x18(%rsp), %r12
@@ -109,10 +109,10 @@
 ;;       movq    %rdx, %r8
 ;;       movq    %rbp, %rdx
 ;;       movq    8(%rsi), %r15
-;;       movq    %rdx, 0x30(%r15)
+;;       movq    %rdx, 0x38(%r15)
 ;;       movq    %rbp, %rax
 ;;       movq    8(%rax), %rax
-;;       movq    %rax, 0x38(%r15)
+;;       movq    %rax, 0x40(%r15)
 ;;       leaq    (%rsp), %rdx
 ;;       movq    %r8, %rax
 ;;       movl    %eax, (%rsp)
@@ -121,7 +121,7 @@
 ;;       movl    $2, %ecx
 ;;       movq    %rsi, %rbx
 ;;       callq   *%rax
-;;       addq    $1, 0x10(%r15)
+;;       addq    $1, 0x18(%r15)
 ;;       testb   %al, %al
 ;;       je      0x196
 ;;  180: movl    (%rsp), %eax
@@ -142,10 +142,10 @@
 ;;       movq    %rsp, %rbp
 ;;       movq    %rbp, %r10
 ;;       movq    8(%rdi), %r9
-;;       movq    %r10, 0x30(%r9)
+;;       movq    %r10, 0x38(%r9)
 ;;       movq    %rbp, %r10
 ;;       movq    8(%r10), %r11
-;;       movq    %r11, 0x38(%r9)
+;;       movq    %r11, 0x40(%r9)
 ;;       movq    0x10(%rdi), %r11
 ;;       movq    0x140(%r11), %r11
 ;;       movzbq  %sil, %rsi
@@ -159,10 +159,10 @@
 ;;       movq    %rsp, %rbp
 ;;       movq    %rbp, %r9
 ;;       movq    8(%rdi), %r8
-;;       movq    %r9, 0x30(%r8)
+;;       movq    %r9, 0x38(%r8)
 ;;       movq    %rbp, %r9
 ;;       movq    8(%r9), %r9
-;;       movq    %r9, 0x38(%r8)
+;;       movq    %r9, 0x40(%r8)
 ;;       movq    0x10(%rdi), %r9
 ;;       movq    0x148(%r9), %r9
 ;;       callq   *%r9
@@ -203,10 +203,10 @@
 ;;       movdqu  %xmm15, 0x150(%rsp)
 ;;       movq    %rbp, %r10
 ;;       movq    8(%rdi), %r9
-;;       movq    %r10, 0x30(%r9)
+;;       movq    %r10, 0x38(%r9)
 ;;       movq    %rbp, %r10
 ;;       movq    8(%r10), %r11
-;;       movq    %r11, 0x38(%r9)
+;;       movq    %r11, 0x40(%r9)
 ;;       movq    0x10(%rdi), %r12
 ;;       movq    %rdi, %r13
 ;;       movq    0x170(%r12), %r11
diff --git a/tests/disas/duplicate-function-types.wat b/tests/disas/duplicate-function-types.wat
index 0220ec36d532..11d298d7f80f 100644
--- a/tests/disas/duplicate-function-types.wat
+++ b/tests/disas/duplicate-function-types.wat
@@ -18,7 +18,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1342177280 "VMTableImport+0x0"
 ;;     region3 = 671088640 "VMTableDefinition+0x0"
 ;;     region4 = 671088648 "VMTableDefinition+0x8"
@@ -30,7 +30,7 @@
 ;;     region10 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/duplicate-loads-dynamic-memory.wat b/tests/disas/duplicate-loads-dynamic-memory.wat
index 9568c1083054..1ebef3a20ed3 100644
--- a/tests/disas/duplicate-loads-dynamic-memory.wat
+++ b/tests/disas/duplicate-loads-dynamic-memory.wat
@@ -24,13 +24,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -50,13 +50,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/duplicate-loads-static-memory.wat b/tests/disas/duplicate-loads-static-memory.wat
index 31f33e362444..5410708ecede 100644
--- a/tests/disas/duplicate-loads-static-memory.wat
+++ b/tests/disas/duplicate-loads-static-memory.wat
@@ -19,13 +19,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -41,13 +41,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
index c4f45135ed8b..25806a59399a 100644
--- a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
+++ b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
@@ -37,13 +37,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32, i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -72,13 +72,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
diff --git a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
index eb58885e29be..d7cc6dc57b25 100644
--- a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
+++ b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
@@ -33,13 +33,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32, i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -70,13 +70,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
diff --git a/tests/disas/elem-segment.wat b/tests/disas/elem-segment.wat
index 84782387e202..a364c63eba32 100644
--- a/tests/disas/elem-segment.wat
+++ b/tests/disas/elem-segment.wat
@@ -12,10 +12,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -25,11 +25,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -38,7 +38,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/epoch-interruption-x86.wat b/tests/disas/epoch-interruption-x86.wat
index 0b8d75b564fd..ffde1a940269 100644
--- a/tests/disas/epoch-interruption-x86.wat
+++ b/tests/disas/epoch-interruption-x86.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x30, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x82
diff --git a/tests/disas/epoch-interruption.wat b/tests/disas/epoch-interruption.wat
index 96b40467616c..75601ad1452a 100644
--- a/tests/disas/epoch-interruption.wat
+++ b/tests/disas/epoch-interruption.wat
@@ -6,13 +6,13 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 24 "VMContext+0x18"
 ;;     region3 = 1744830464 "EpochCounter+0x0"
 ;;     region4 = 67108872 "VMStoreContext+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i64 tail
 ;;     fn0 = colocated u805306368:13 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/exceptions.wat b/tests/disas/exceptions.wat
index a544f5701bcd..54bfea25fab2 100644
--- a/tests/disas/exceptions.wat
+++ b/tests/disas/exceptions.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x50, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0xec
@@ -45,7 +45,7 @@
 ;;   5f: leal    0x30(%rsi), %eax
 ;;       movl    %eax, (%rdx)
 ;;       movq    8(%rbx), %rax
-;;       movq    0x20(%rax), %rdi
+;;       movq    0x28(%rax), %rdi
 ;;       leaq    (%rdi, %rcx), %rdx
 ;;       movl    $0x4000002, (%rdi, %rcx)
 ;;       movq    0x28(%rbx), %rax
@@ -73,7 +73,7 @@
 ;;       callq   0x398
 ;;       movq    8(%rbx), %rcx
 ;;       movl    %eax, %edx
-;;       addq    0x20(%rcx), %rdx
+;;       addq    0x28(%rcx), %rdx
 ;;       movq    %rax, %rsi
 ;;       movq    %r14, %rdi
 ;;       jmp     0x8e
@@ -84,7 +84,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x50, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x195
@@ -106,7 +106,7 @@
 ;;  156: movq    %rax, %rdx
 ;;       movq    (%rsp), %rsi
 ;;       movq    8(%rsi), %rax
-;;       movq    0x20(%rax), %rcx
+;;       movq    0x28(%rax), %rcx
 ;;       movq    %rdx, %rax
 ;;       movl    %eax, %edx
 ;;       movl    0x18(%rcx, %rdx), %eax
diff --git a/tests/disas/f32-load.wat b/tests/disas/f32-load.wat
index 086297030721..49b90bd012fb 100644
--- a/tests/disas/f32-load.wat
+++ b/tests/disas/f32-load.wat
@@ -8,13 +8,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/f32-store.wat b/tests/disas/f32-store.wat
index 6fa50556825d..62ccd20ee39f 100644
--- a/tests/disas/f32-store.wat
+++ b/tests/disas/f32-store.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, f32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
diff --git a/tests/disas/f64-load.wat b/tests/disas/f64-load.wat
index 22d66bc94b18..70dcdab20cd0 100644
--- a/tests/disas/f64-load.wat
+++ b/tests/disas/f64-load.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> f64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/f64-store.wat b/tests/disas/f64-store.wat
index 95fae42d5edb..be9f8134f9f1 100644
--- a/tests/disas/f64-store.wat
+++ b/tests/disas/f64-store.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, f64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f64):
diff --git a/tests/disas/fac-multi-value.wat b/tests/disas/fac-multi-value.wat
index 1940dd553fd3..8859cf33ac7c 100644
--- a/tests/disas/fac-multi-value.wat
+++ b/tests/disas/fac-multi-value.wat
@@ -22,10 +22,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
@@ -37,10 +37,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
@@ -52,10 +52,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i64) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail
 ;;     sig1 = (i64 vmctx, i64, i64) -> i64, i64 tail
 ;;     fn0 = colocated u0:1 sig0
diff --git a/tests/disas/fibonacci.wat b/tests/disas/fibonacci.wat
index 26d230b8d0e4..985bb97f3025 100644
--- a/tests/disas/fibonacci.wat
+++ b/tests/disas/fibonacci.wat
@@ -25,13 +25,13 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/fixed-size-memory.wat b/tests/disas/fixed-size-memory.wat
index b3f59e57d3fc..5be2eb7e9c57 100644
--- a/tests/disas/fixed-size-memory.wat
+++ b/tests/disas/fixed-size-memory.wat
@@ -22,13 +22,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/foo.wat b/tests/disas/foo.wat
index 0ed3d5468413..a91f1162d568 100644
--- a/tests/disas/foo.wat
+++ b/tests/disas/foo.wat
@@ -16,7 +16,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
@@ -31,7 +31,7 @@
 ;;     region13 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/gc/array-copy-with-fuel.wat b/tests/disas/gc/array-copy-with-fuel.wat
index aeab1b17ebd3..cc769c7e9a7e 100644
--- a/tests/disas/gc/array-copy-with-fuel.wat
+++ b/tests/disas/gc/array-copy-with-fuel.wat
@@ -13,16 +13,16 @@
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     ss1 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 67108864 "VMStoreContext+0x0"
-;;     region3 = 67108896 "VMStoreContext+0x20"
-;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108912 "VMStoreContext+0x30"
 ;;     region5 = 536870912 "GcHeap"
 ;;     region6 = 1543503872 "Stack(ss0)"
 ;;     region7 = 1543503873 "Stack(ss1)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i8 tail
 ;;     fn0 = colocated u805306368:12 sig0
 ;;     stack_limit = gv2
@@ -50,7 +50,7 @@
 ;;                                 block3(v89: i64):
 ;;                                     v180 = load.i32 notrap aligned region6 v181
 ;; @002b                               trapz v180, user16
-;; @002b                               v24 = load.i64 notrap aligned readonly can_move region3 v7+32
+;; @002b                               v24 = load.i64 notrap aligned readonly can_move region3 v7+40
 ;; @002b                               v22 = uextend.i64 v180
 ;; @002b                               v25 = iadd v24, v22
 ;; @002b                               v26 = iconst.i64 16
@@ -73,7 +73,7 @@
 ;; @002b                               v53 = uextend.i64 v52
 ;; @002b                               v59 = icmp ugt v58, v53
 ;; @002b                               trapnz v59, user17
-;; @002b                               v78 = load.i64 notrap aligned region4 v7+40
+;; @002b                               v78 = load.i64 notrap aligned region4 v7+48
 ;; @002b                               v40 = iconst.i64 20
 ;; @002b                               v41 = iadd v25, v40  ; v40 = 20
 ;;                                     v184 = iconst.i64 2
diff --git a/tests/disas/gc/array-fill-i8.wat b/tests/disas/gc/array-fill-i8.wat
index 2a562fc09427..d8977ab9c4b4 100644
--- a/tests/disas/gc/array-fill-i8.wat
+++ b/tests/disas/gc/array-fill-i8.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -25,7 +25,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @0027                               trapz v2, user16
 ;; @0027                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0027                               v6 = uextend.i64 v2
 ;; @0027                               v9 = iadd v8, v6
 ;; @0027                               v10 = iconst.i64 16
@@ -37,7 +37,7 @@
 ;; @0027                               v13 = uextend.i64 v12
 ;; @0027                               v19 = icmp ugt v18, v13
 ;; @0027                               trapnz v19, user17
-;; @0027                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0027                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0027                               v24 = iconst.i64 20
 ;; @0027                               v25 = iadd v9, v24  ; v24 = 20
 ;; @0027                               v29 = iadd v25, v14
diff --git a/tests/disas/gc/array-init-data.wat b/tests/disas/gc/array-init-data.wat
index 9ac20336221e..dcc1f7e4b8da 100644
--- a/tests/disas/gc/array-init-data.wat
+++ b/tests/disas/gc/array-init-data.wat
@@ -15,15 +15,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     region5 = 56 "VMContext+0x38"
 ;;     region6 = 48 "VMContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -31,7 +31,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @002a                               trapz v2, user16
 ;; @002a                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @002a                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @002a                               v6 = uextend.i64 v2
 ;; @002a                               v9 = iadd v8, v6
 ;; @002a                               v10 = iconst.i64 16
@@ -50,7 +50,7 @@
 ;; @002a                               v37 = icmp ugt v36, v31
 ;; @002a                               trapnz v37, heap_oob
 ;; @002a                               v38 = load.i64 notrap aligned region6 v0+48
-;; @002a                               v49 = load.i64 notrap aligned region3 v7+40
+;; @002a                               v49 = load.i64 notrap aligned region3 v7+48
 ;; @002a                               v24 = iconst.i64 20
 ;; @002a                               v25 = iadd v9, v24  ; v24 = 20
 ;; @002a                               v29 = iadd v25, v14
diff --git a/tests/disas/gc/array-new-data.wat b/tests/disas/gc/array-new-data.wat
index 3da18b18d8d7..52bb8b222837 100644
--- a/tests/disas/gc/array-new-data.wat
+++ b/tests/disas/gc/array-new-data.wat
@@ -78,7 +78,7 @@
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 56 "VMContext+0x38"
 ;;     region3 = 48 "VMContext+0x30"
 ;;     region4 = 32 "VMContext+0x20"
@@ -86,13 +86,13 @@
 ;;     region6 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region7 = 40 "VMContext+0x28"
 ;;     region8 = 1677721600 "TypeIdsArray+0x0"
-;;     region9 = 67108896 "VMStoreContext+0x20"
+;;     region9 = 67108904 "VMStoreContext+0x28"
 ;;     region10 = 536870912 "GcHeap"
-;;     region11 = 67108904 "VMStoreContext+0x28"
+;;     region11 = 67108912 "VMStoreContext+0x30"
 ;;     region12 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -136,7 +136,7 @@
 ;; @0025                               store notrap aligned region5 v127, v23
 ;;                                     v141 = iconst.i32 -1476395002
 ;;                                     v142 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v143 = load.i64 notrap aligned readonly can_move region9 v142+32
+;;                                     v143 = load.i64 notrap aligned readonly can_move region9 v142+40
 ;; @0025                               v48 = iadd v143, v31
 ;; @0025                               store user2 region10 v141, v48  ; v141 = -1476395002
 ;;                                     v144 = load.i64 notrap aligned readonly can_move region7 v0+40
@@ -153,7 +153,7 @@
 ;; @0025                               v38 = iconst.i32 16
 ;; @0025                               v39 = call fn0(v0, v35, v37, v22, v38)  ; v35 = -1476395002, v38 = 16
 ;; @0025                               v40 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v41 = load.i64 notrap aligned readonly can_move region9 v40+32
+;; @0025                               v41 = load.i64 notrap aligned readonly can_move region9 v40+40
 ;; @0025                               v42 = uextend.i64 v39
 ;; @0025                               v43 = iadd v41, v42
 ;; @0025                               jump block4(v39, v43)
@@ -166,7 +166,7 @@
 ;; @0025                               store.i32 user2 region10 v3, v55
 ;; @0025                               trapz v52, user16
 ;;                                     v147 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v148 = load.i64 notrap aligned readonly can_move region9 v147+32
+;;                                     v148 = load.i64 notrap aligned readonly can_move region9 v147+40
 ;; @0025                               v57 = uextend.i64 v52
 ;; @0025                               v60 = iadd v148, v57
 ;; @0025                               v62 = iadd v60, v54  ; v54 = 16
@@ -179,7 +179,7 @@
 ;; @0025                               v88 = icmp.i64 ugt v10, v82
 ;; @0025                               trapnz v88, heap_oob
 ;; @0025                               v89 = load.i64 notrap aligned region3 v0+48
-;; @0025                               v100 = load.i64 notrap aligned region11 v147+40
+;; @0025                               v100 = load.i64 notrap aligned region11 v147+48
 ;; @0025                               v75 = iconst.i64 20
 ;; @0025                               v76 = iadd v60, v75  ; v75 = 20
 ;; @0025                               v102 = uadd_overflow_trap v76, v7, user2
diff --git a/tests/disas/gc/array-new-default-anyref.wat b/tests/disas/gc/array-new-default-anyref.wat
index 4daa0f087b41..082dbb84404c 100644
--- a/tests/disas/gc/array-new-default-anyref.wat
+++ b/tests/disas/gc/array-new-default-anyref.wat
@@ -11,18 +11,18 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -61,7 +61,7 @@
 ;; @001f                               store notrap aligned region3 v110, v11
 ;;                                     v126 = iconst.i32 -1476394994
 ;;                                     v127 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+32
+;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+40
 ;; @001f                               v36 = iadd v128, v19
 ;; @001f                               store user2 region8 v126, v36  ; v126 = -1476394994
 ;;                                     v129 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -78,7 +78,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476394994, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -89,7 +89,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+32
+;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v133, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -97,7 +97,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v132+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v132+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v88, user2
diff --git a/tests/disas/gc/array-new-default-exnref.wat b/tests/disas/gc/array-new-default-exnref.wat
index baeed321b8ca..15b0b87fb6b1 100644
--- a/tests/disas/gc/array-new-default-exnref.wat
+++ b/tests/disas/gc/array-new-default-exnref.wat
@@ -11,18 +11,18 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -61,7 +61,7 @@
 ;; @001f                               store notrap aligned region3 v110, v11
 ;;                                     v126 = iconst.i32 -1476394994
 ;;                                     v127 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+32
+;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+40
 ;; @001f                               v36 = iadd v128, v19
 ;; @001f                               store user2 region8 v126, v36  ; v126 = -1476394994
 ;;                                     v129 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -78,7 +78,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476394994, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -89,7 +89,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+32
+;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v133, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -97,7 +97,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v132+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v132+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v88, user2
diff --git a/tests/disas/gc/array-new-default-externref.wat b/tests/disas/gc/array-new-default-externref.wat
index 78db3263ea42..9111f8fc2481 100644
--- a/tests/disas/gc/array-new-default-externref.wat
+++ b/tests/disas/gc/array-new-default-externref.wat
@@ -11,18 +11,18 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -61,7 +61,7 @@
 ;; @001f                               store notrap aligned region3 v110, v11
 ;;                                     v126 = iconst.i32 -1476394994
 ;;                                     v127 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+32
+;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+40
 ;; @001f                               v36 = iadd v128, v19
 ;; @001f                               store user2 region8 v126, v36  ; v126 = -1476394994
 ;;                                     v129 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -78,7 +78,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476394994, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -89,7 +89,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+32
+;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v133, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -97,7 +97,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v132+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v132+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v88, user2
diff --git a/tests/disas/gc/array-new-default-f32.wat b/tests/disas/gc/array-new-default-f32.wat
index 0bb1fa00a05a..ee5bcc2f7b3a 100644
--- a/tests/disas/gc/array-new-default-f32.wat
+++ b/tests/disas/gc/array-new-default-f32.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -65,7 +65,7 @@
 ;; @001f                               store notrap aligned region3 v113, v11
 ;;                                     v129 = iconst.i32 -1476395002
 ;;                                     v130 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+32
+;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+40
 ;; @001f                               v36 = iadd v131, v19
 ;; @001f                               store user2 region8 v129, v36  ; v129 = -1476395002
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -82,7 +82,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -95,7 +95,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v135 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+32
+;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v136, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -103,7 +103,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v135+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v135+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v91, user2
diff --git a/tests/disas/gc/array-new-default-f64.wat b/tests/disas/gc/array-new-default-f64.wat
index 472da45f2867..3ed8772ec852 100644
--- a/tests/disas/gc/array-new-default-f64.wat
+++ b/tests/disas/gc/array-new-default-f64.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -65,7 +65,7 @@
 ;; @001f                               store notrap aligned region3 v113, v11
 ;;                                     v129 = iconst.i32 -1476395002
 ;;                                     v130 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+32
+;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+40
 ;; @001f                               v36 = iadd v131, v19
 ;; @001f                               store user2 region8 v129, v36  ; v129 = -1476395002
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -82,7 +82,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -95,7 +95,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v135 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+32
+;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v136, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -103,7 +103,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v135+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v135+48
 ;; @001f                               v64 = iconst.i64 24
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 24
 ;; @001f                               v78 = uadd_overflow_trap v65, v91, user2
diff --git a/tests/disas/gc/array-new-default-funcref.wat b/tests/disas/gc/array-new-default-funcref.wat
index b5e2f4aea84f..7b5700a2036a 100644
--- a/tests/disas/gc/array-new-default-funcref.wat
+++ b/tests/disas/gc/array-new-default-funcref.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -65,7 +65,7 @@
 ;; @001f                               store notrap aligned region3 v121, v11
 ;;                                     v136 = iconst.i32 -1476395002
 ;;                                     v137 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v138 = load.i64 notrap aligned readonly can_move region7 v137+32
+;;                                     v138 = load.i64 notrap aligned readonly can_move region7 v137+40
 ;; @001f                               v36 = iadd v138, v19
 ;; @001f                               store user2 region8 v136, v36  ; v136 = -1476395002
 ;;                                     v139 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -82,7 +82,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -95,7 +95,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v142 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v143 = load.i64 notrap aligned readonly can_move region7 v142+32
+;;                                     v143 = load.i64 notrap aligned readonly can_move region7 v142+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v143, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -103,7 +103,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v142+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v142+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v99, user2
diff --git a/tests/disas/gc/array-new-default-i16.wat b/tests/disas/gc/array-new-default-i16.wat
index a966b5d624e6..ffb714b258ca 100644
--- a/tests/disas/gc/array-new-default-i16.wat
+++ b/tests/disas/gc/array-new-default-i16.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -64,7 +64,7 @@
 ;; @001f                               store notrap aligned region3 v118, v11
 ;;                                     v139 = iconst.i32 -1476395002
 ;;                                     v140 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v141 = load.i64 notrap aligned readonly can_move region7 v140+32
+;;                                     v141 = load.i64 notrap aligned readonly can_move region7 v140+40
 ;; @001f                               v36 = iadd v141, v19
 ;; @001f                               store user2 region8 v139, v36  ; v139 = -1476395002
 ;;                                     v142 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -81,7 +81,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -94,7 +94,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v145 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v146 = load.i64 notrap aligned readonly can_move region7 v145+32
+;;                                     v146 = load.i64 notrap aligned readonly can_move region7 v145+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v146, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -102,7 +102,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v145+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v145+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v92, user2
diff --git a/tests/disas/gc/array-new-default-i32.wat b/tests/disas/gc/array-new-default-i32.wat
index 25ecce075555..cdbe9245eef5 100644
--- a/tests/disas/gc/array-new-default-i32.wat
+++ b/tests/disas/gc/array-new-default-i32.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -65,7 +65,7 @@
 ;; @001f                               store notrap aligned region3 v113, v11
 ;;                                     v129 = iconst.i32 -1476395002
 ;;                                     v130 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+32
+;;                                     v131 = load.i64 notrap aligned readonly can_move region7 v130+40
 ;; @001f                               v36 = iadd v131, v19
 ;; @001f                               store user2 region8 v129, v36  ; v129 = -1476395002
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -82,7 +82,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -95,7 +95,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v135 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+32
+;;                                     v136 = load.i64 notrap aligned readonly can_move region7 v135+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v136, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -103,7 +103,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v135+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v135+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v91, user2
diff --git a/tests/disas/gc/array-new-default-i64.wat b/tests/disas/gc/array-new-default-i64.wat
index 65b9b9114187..32461d65fc3d 100644
--- a/tests/disas/gc/array-new-default-i64.wat
+++ b/tests/disas/gc/array-new-default-i64.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -65,7 +65,7 @@
 ;; @001f                               store notrap aligned region3 v113, v11
 ;;                                     v128 = iconst.i32 -1476395002
 ;;                                     v129 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v130 = load.i64 notrap aligned readonly can_move region7 v129+32
+;;                                     v130 = load.i64 notrap aligned readonly can_move region7 v129+40
 ;; @001f                               v36 = iadd v130, v19
 ;; @001f                               store user2 region8 v128, v36  ; v128 = -1476395002
 ;;                                     v131 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -82,7 +82,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -95,7 +95,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v134 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v135 = load.i64 notrap aligned readonly can_move region7 v134+32
+;;                                     v135 = load.i64 notrap aligned readonly can_move region7 v134+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v135, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -103,7 +103,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v134+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v134+48
 ;; @001f                               v64 = iconst.i64 24
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 24
 ;; @001f                               v78 = uadd_overflow_trap v65, v91, user2
diff --git a/tests/disas/gc/array-new-default-i8.wat b/tests/disas/gc/array-new-default-i8.wat
index 45f840d560d0..2e6719341ba1 100644
--- a/tests/disas/gc/array-new-default-i8.wat
+++ b/tests/disas/gc/array-new-default-i8.wat
@@ -12,19 +12,19 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -61,7 +61,7 @@
 ;; @001f                               store notrap aligned region3 v103, v11
 ;;                                     v117 = iconst.i32 -1476395002
 ;;                                     v118 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v119 = load.i64 notrap aligned readonly can_move region7 v118+32
+;;                                     v119 = load.i64 notrap aligned readonly can_move region7 v118+40
 ;; @001f                               v36 = iadd v119, v19
 ;; @001f                               store user2 region8 v117, v36  ; v117 = -1476395002
 ;;                                     v120 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -78,7 +78,7 @@
 ;; @001f                               v26 = iconst.i32 16
 ;; @001f                               v27 = call fn0(v0, v23, v25, v10, v26)  ; v23 = -1476395002, v26 = 16
 ;; @001f                               v28 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+32
+;; @001f                               v29 = load.i64 notrap aligned readonly can_move region7 v28+40
 ;; @001f                               v30 = uextend.i64 v27
 ;; @001f                               v31 = iadd v29, v30
 ;; @001f                               jump block4(v27, v31)
@@ -91,7 +91,7 @@
 ;; @001f                               store.i32 user2 region8 v2, v43
 ;; @001f                               trapz v40, user16
 ;;                                     v123 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v124 = load.i64 notrap aligned readonly can_move region7 v123+32
+;;                                     v124 = load.i64 notrap aligned readonly can_move region7 v123+40
 ;; @001f                               v46 = uextend.i64 v40
 ;; @001f                               v49 = iadd v124, v46
 ;; @001f                               v51 = iadd v49, v42  ; v42 = 16
@@ -99,7 +99,7 @@
 ;; @001f                               v53 = uextend.i64 v52
 ;; @001f                               v59 = icmp.i64 ugt v4, v53
 ;; @001f                               trapnz v59, user17
-;; @001f                               v76 = load.i64 notrap aligned region9 v123+40
+;; @001f                               v76 = load.i64 notrap aligned region9 v123+48
 ;; @001f                               v64 = iconst.i64 20
 ;; @001f                               v65 = iadd v49, v64  ; v64 = 20
 ;; @001f                               v78 = uadd_overflow_trap v65, v4, user2
diff --git a/tests/disas/gc/call-indirect-final-type.wat b/tests/disas/gc/call-indirect-final-type.wat
index 55449f05f049..58e286ecabe8 100644
--- a/tests/disas/gc/call-indirect-final-type.wat
+++ b/tests/disas/gc/call-indirect-final-type.wat
@@ -17,7 +17,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
@@ -28,7 +28,7 @@
 ;;     region9 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
@@ -72,7 +72,7 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
@@ -83,7 +83,7 @@
 ;;     region9 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/gc/copying/array-fill.wat b/tests/disas/gc/copying/array-fill.wat
index 33b7e608b489..7e266fe445d1 100644
--- a/tests/disas/gc/copying/array-fill.wat
+++ b/tests/disas/gc/copying/array-fill.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):
 ;; @0027                               trapz v2, user16
 ;; @0027                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0027                               v6 = uextend.i64 v2
 ;; @0027                               v9 = iadd v8, v6
 ;; @0027                               v10 = iconst.i64 16
@@ -34,7 +34,7 @@
 ;; @0027                               v13 = uextend.i64 v12
 ;; @0027                               v19 = icmp ugt v18, v13
 ;; @0027                               trapnz v19, user17
-;; @0027                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0027                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0027                               v24 = iconst.i64 24
 ;; @0027                               v25 = iadd v9, v24  ; v24 = 24
 ;;                                     v49 = iconst.i64 3
diff --git a/tests/disas/gc/copying/array-get-s.wat b/tests/disas/gc/copying/array-get-s.wat
index 51ace936d0f6..57376afaa40c 100644
--- a/tests/disas/gc/copying/array-get-s.wat
+++ b/tests/disas/gc/copying/array-get-s.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 16
diff --git a/tests/disas/gc/copying/array-get-u.wat b/tests/disas/gc/copying/array-get-u.wat
index 8c2383805262..ecaed679c75b 100644
--- a/tests/disas/gc/copying/array-get-u.wat
+++ b/tests/disas/gc/copying/array-get-u.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 16
diff --git a/tests/disas/gc/copying/array-get.wat b/tests/disas/gc/copying/array-get.wat
index b41b3fc7b125..1b3698f2898a 100644
--- a/tests/disas/gc/copying/array-get.wat
+++ b/tests/disas/gc/copying/array-get.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 16
diff --git a/tests/disas/gc/copying/array-len.wat b/tests/disas/gc/copying/array-len.wat
index e7b2f2b85417..cbd300aad42b 100644
--- a/tests/disas/gc/copying/array-len.wat
+++ b/tests/disas/gc/copying/array-len.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @001f                               trapz v2, user16
 ;; @001f                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @001f                               v3 = uextend.i64 v2
 ;; @001f                               v6 = iadd v5, v3
 ;; @001f                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat
index c5f20774d01e..dede95e8dcef 100644
--- a/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat
+++ b/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat
@@ -13,21 +13,21 @@
 ;;     ss1 = explicit_slot 4, align = 4
 ;;     ss2 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     region11 = 1543503873 "Stack(ss1)"
 ;;     region12 = 1543503874 "Stack(ss2)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -55,7 +55,7 @@
 ;; @0025                               store notrap aligned region3 v165, v14
 ;;                                     v254 = iconst.i32 -1476394994
 ;;                                     v255 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v256 = load.i64 notrap aligned readonly can_move region7 v255+32
+;;                                     v256 = load.i64 notrap aligned readonly can_move region7 v255+40
 ;; @0025                               v39 = iadd v256, v22
 ;; @0025                               store user2 region8 v254, v39  ; v254 = -1476394994
 ;;                                     v257 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -73,7 +73,7 @@
 ;; @0025                               v29 = iconst.i32 16
 ;; @0025                               v30 = call fn0(v0, v26, v28, v151, v29), stack_map=[i32 @ ss2+0, i32 @ ss1+0, i32 @ ss0+0]  ; v26 = -1476394994, v151 = 32, v29 = 16
 ;; @0025                               v31 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v32 = load.i64 notrap aligned readonly can_move region7 v31+32
+;; @0025                               v32 = load.i64 notrap aligned readonly can_move region7 v31+40
 ;; @0025                               v33 = uextend.i64 v30
 ;; @0025                               v34 = iadd v32, v33
 ;; @0025                               jump block4(v30, v34)
@@ -85,7 +85,7 @@
 ;; @0025                               store user2 region8 v5, v46  ; v5 = 3
 ;; @0025                               trapz v43, user16
 ;;                                     v260 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v261 = load.i64 notrap aligned readonly can_move region7 v260+32
+;;                                     v261 = load.i64 notrap aligned readonly can_move region7 v260+40
 ;; @0025                               v48 = uextend.i64 v43
 ;; @0025                               v51 = iadd v261, v48
 ;; @0025                               v53 = iadd v51, v45  ; v45 = 16
diff --git a/tests/disas/gc/copying/array-new-fixed.wat b/tests/disas/gc/copying/array-new-fixed.wat
index 59c33d89e77f..533066808f49 100644
--- a/tests/disas/gc/copying/array-new-fixed.wat
+++ b/tests/disas/gc/copying/array-new-fixed.wat
@@ -10,18 +10,18 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -43,7 +43,7 @@
 ;; @0025                               store notrap aligned region3 v155, v14
 ;;                                     v242 = iconst.i32 -1476395002
 ;;                                     v243 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v244 = load.i64 notrap aligned readonly can_move region7 v243+32
+;;                                     v244 = load.i64 notrap aligned readonly can_move region7 v243+40
 ;; @0025                               v39 = iadd v244, v22
 ;; @0025                               store user2 region8 v242, v39  ; v242 = -1476395002
 ;;                                     v245 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -61,7 +61,7 @@
 ;; @0025                               v29 = iconst.i32 16
 ;; @0025                               v30 = call fn0(v0, v26, v28, v140, v29)  ; v26 = -1476395002, v140 = 48, v29 = 16
 ;; @0025                               v31 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v32 = load.i64 notrap aligned readonly can_move region7 v31+32
+;; @0025                               v32 = load.i64 notrap aligned readonly can_move region7 v31+40
 ;; @0025                               v33 = uextend.i64 v30
 ;; @0025                               v34 = iadd v32, v33
 ;; @0025                               jump block4(v30, v34)
@@ -73,7 +73,7 @@
 ;; @0025                               store user2 region8 v5, v46  ; v5 = 3
 ;; @0025                               trapz v43, user16
 ;;                                     v248 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v249 = load.i64 notrap aligned readonly can_move region7 v248+32
+;;                                     v249 = load.i64 notrap aligned readonly can_move region7 v248+40
 ;; @0025                               v48 = uextend.i64 v43
 ;; @0025                               v51 = iadd v249, v48
 ;; @0025                               v53 = iadd v51, v45  ; v45 = 16
diff --git a/tests/disas/gc/copying/array-new.wat b/tests/disas/gc/copying/array-new.wat
index ab880a95bff6..a7d5b3e8bb90 100644
--- a/tests/disas/gc/copying/array-new.wat
+++ b/tests/disas/gc/copying/array-new.wat
@@ -10,18 +10,18 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
-;;     region9 = 67108904 "VMStoreContext+0x28"
+;;     region9 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -60,7 +60,7 @@
 ;; @0022                               store notrap aligned region3 v110, v12
 ;;                                     v126 = iconst.i32 -1476395002
 ;;                                     v127 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+32
+;;                                     v128 = load.i64 notrap aligned readonly can_move region7 v127+40
 ;; @0022                               v37 = iadd v128, v20
 ;; @0022                               store user2 region8 v126, v37  ; v126 = -1476395002
 ;;                                     v129 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -77,7 +77,7 @@
 ;; @0022                               v27 = iconst.i32 16
 ;; @0022                               v28 = call fn0(v0, v24, v26, v11, v27)  ; v24 = -1476395002, v27 = 16
 ;; @0022                               v29 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v30 = load.i64 notrap aligned readonly can_move region7 v29+32
+;; @0022                               v30 = load.i64 notrap aligned readonly can_move region7 v29+40
 ;; @0022                               v31 = uextend.i64 v28
 ;; @0022                               v32 = iadd v30, v31
 ;; @0022                               jump block4(v28, v32)
@@ -88,7 +88,7 @@
 ;; @0022                               store.i32 user2 region8 v3, v44
 ;; @0022                               trapz v41, user16
 ;;                                     v132 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+32
+;;                                     v133 = load.i64 notrap aligned readonly can_move region7 v132+40
 ;; @0022                               v46 = uextend.i64 v41
 ;; @0022                               v49 = iadd v133, v46
 ;; @0022                               v51 = iadd v49, v43  ; v43 = 16
@@ -96,7 +96,7 @@
 ;; @0022                               v53 = uextend.i64 v52
 ;; @0022                               v59 = icmp.i64 ugt v5, v53
 ;; @0022                               trapnz v59, user17
-;; @0022                               v76 = load.i64 notrap aligned region9 v132+40
+;; @0022                               v76 = load.i64 notrap aligned region9 v132+48
 ;; @0022                               v64 = iconst.i64 24
 ;; @0022                               v65 = iadd v49, v64  ; v64 = 24
 ;; @0022                               v78 = uadd_overflow_trap v65, v88, user2
diff --git a/tests/disas/gc/copying/array-set.wat b/tests/disas/gc/copying/array-set.wat
index 67c4db384ccf..20368384ad25 100644
--- a/tests/disas/gc/copying/array-set.wat
+++ b/tests/disas/gc/copying/array-set.wat
@@ -10,19 +10,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 16
diff --git a/tests/disas/gc/copying/br-on-cast-fail.wat b/tests/disas/gc/copying/br-on-cast-fail.wat
index 149f58556728..ba00dd53713a 100644
--- a/tests/disas/gc/copying/br-on-cast-fail.wat
+++ b/tests/disas/gc/copying/br-on-cast-fail.wat
@@ -17,17 +17,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -44,7 +44,7 @@
 ;;
 ;;                                 block4:
 ;; @002e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002e                               v12 = uextend.i64 v2
 ;; @002e                               v15 = iadd v14, v12
 ;; @002e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/copying/br-on-cast.wat b/tests/disas/gc/copying/br-on-cast.wat
index 955d88c83985..cb2810a94ec3 100644
--- a/tests/disas/gc/copying/br-on-cast.wat
+++ b/tests/disas/gc/copying/br-on-cast.wat
@@ -17,17 +17,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -44,7 +44,7 @@
 ;;
 ;;                                 block4:
 ;; @002f                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002f                               v12 = uextend.i64 v2
 ;; @002f                               v15 = iadd v14, v12
 ;; @002f                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/copying/call-indirect-and-subtyping.wat b/tests/disas/gc/copying/call-indirect-and-subtyping.wat
index ba991cdd1f74..7b43154a685d 100644
--- a/tests/disas/gc/copying/call-indirect-and-subtyping.wat
+++ b/tests/disas/gc/copying/call-indirect-and-subtyping.wat
@@ -17,7 +17,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -27,7 +27,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     sig2 = (i64 vmctx, i32, i32) -> i32 tail
diff --git a/tests/disas/gc/copying/externref-globals.wat b/tests/disas/gc/copying/externref-globals.wat
index 491f4f7836e8..cc358103376e 100644
--- a/tests/disas/gc/copying/externref-globals.wat
+++ b/tests/disas/gc/copying/externref-globals.wat
@@ -12,11 +12,11 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -31,11 +31,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-get.wat b/tests/disas/gc/copying/funcref-in-gc-heap-get.wat
index d2afc6407274..099cffab94f9 100644
--- a/tests/disas/gc/copying/funcref-in-gc-heap-get.wat
+++ b/tests/disas/gc/copying/funcref-in-gc-heap-get.wat
@@ -10,13 +10,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:26 sig0
 ;;     stack_limit = gv2
@@ -24,7 +24,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0020                               trapz v2, user16
 ;; @0020                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0020                               v3 = uextend.i64 v2
 ;; @0020                               v6 = iadd v5, v3
 ;; @0020                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-new.wat b/tests/disas/gc/copying/funcref-in-gc-heap-new.wat
index 95345ad6a2a1..c8d78d1dc9a7 100644
--- a/tests/disas/gc/copying/funcref-in-gc-heap-new.wat
+++ b/tests/disas/gc/copying/funcref-in-gc-heap-new.wat
@@ -11,18 +11,18 @@
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
 ;;     region9 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -46,7 +46,7 @@
 ;; @0020                               store notrap aligned region3 v56, v4
 ;;                                     v59 = iconst.i32 -1342177278
 ;;                                     v60 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v61 = load.i64 notrap aligned readonly can_move region7 v60+32
+;;                                     v61 = load.i64 notrap aligned readonly can_move region7 v60+40
 ;; @0020                               v29 = iadd v61, v12
 ;; @0020                               store user2 region8 v59, v29  ; v59 = -1342177278
 ;;                                     v62 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -64,7 +64,7 @@
 ;; @0020                               v19 = iconst.i32 16
 ;; @0020                               v20 = call fn0(v0, v16, v18, v3, v19)  ; v16 = -1342177278, v3 = 32, v19 = 16
 ;; @0020                               v21 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v22 = load.i64 notrap aligned readonly can_move region7 v21+32
+;; @0020                               v22 = load.i64 notrap aligned readonly can_move region7 v21+40
 ;; @0020                               v23 = uextend.i64 v20
 ;; @0020                               v24 = iadd v22, v23
 ;; @0020                               jump block4(v20, v24)
diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-set.wat b/tests/disas/gc/copying/funcref-in-gc-heap-set.wat
index 992ae6ce4738..da1cc3035434 100644
--- a/tests/disas/gc/copying/funcref-in-gc-heap-set.wat
+++ b/tests/disas/gc/copying/funcref-in-gc-heap-set.wat
@@ -10,13 +10,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:25 sig0
 ;;     stack_limit = gv2
@@ -26,7 +26,7 @@
 ;; @0022                               v10 = call fn0(v0, v3)
 ;; @0022                               v11 = ireduce.i32 v10
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 16
diff --git a/tests/disas/gc/copying/i31ref-globals.wat b/tests/disas/gc/copying/i31ref-globals.wat
index 1a5425e60955..2812d17cffb8 100644
--- a/tests/disas/gc/copying/i31ref-globals.wat
+++ b/tests/disas/gc/copying/i31ref-globals.wat
@@ -12,11 +12,11 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -31,11 +31,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/multiple-array-get.wat b/tests/disas/gc/copying/multiple-array-get.wat
index a8fac30a249c..cb5be8a03b4f 100644
--- a/tests/disas/gc/copying/multiple-array-get.wat
+++ b/tests/disas/gc/copying/multiple-array-get.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 16
diff --git a/tests/disas/gc/copying/multiple-struct-get.wat b/tests/disas/gc/copying/multiple-struct-get.wat
index 2e8ea0ae760b..555ab813f6a9 100644
--- a/tests/disas/gc/copying/multiple-struct-get.wat
+++ b/tests/disas/gc/copying/multiple-struct-get.wat
@@ -12,19 +12,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0023                               trapz v2, user16
 ;; @0023                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0023                               v3 = uextend.i64 v2
 ;; @0023                               v6 = iadd v5, v3
 ;; @0023                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/copying/ref-cast.wat b/tests/disas/gc/copying/ref-cast.wat
index c5b1ccd899b8..fe23b833d537 100644
--- a/tests/disas/gc/copying/ref-cast.wat
+++ b/tests/disas/gc/copying/ref-cast.wat
@@ -9,15 +9,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -33,7 +33,7 @@
 ;;
 ;;                                 block3:
 ;; @001e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001e                               v12 = uextend.i64 v2
 ;; @001e                               v15 = iadd v14, v12
 ;; @001e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/copying/ref-is-null.wat b/tests/disas/gc/copying/ref-is-null.wat
index 433930e51185..a81cb5fdab30 100644
--- a/tests/disas/gc/copying/ref-is-null.wat
+++ b/tests/disas/gc/copying/ref-is-null.wat
@@ -11,10 +11,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -29,10 +29,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/ref-test-any.wat b/tests/disas/gc/copying/ref-test-any.wat
index f162813c6532..bb768c3de0a6 100644
--- a/tests/disas/gc/copying/ref-test-any.wat
+++ b/tests/disas/gc/copying/ref-test-any.wat
@@ -11,10 +11,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -29,10 +29,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/ref-test-array.wat b/tests/disas/gc/copying/ref-test-array.wat
index 005d4304d9b1..9168f2c31ba5 100644
--- a/tests/disas/gc/copying/ref-test-array.wat
+++ b/tests/disas/gc/copying/ref-test-array.wat
@@ -8,13 +8,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,7 +30,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/copying/ref-test-concrete-func-type.wat b/tests/disas/gc/copying/ref-test-concrete-func-type.wat
index 61288a4aae54..629b6da3ffa2 100644
--- a/tests/disas/gc/copying/ref-test-concrete-func-type.wat
+++ b/tests/disas/gc/copying/ref-test-concrete-func-type.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
 ;;     region4 = 1610612752 "VMFuncRef+0x10"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/gc/copying/ref-test-concrete-type.wat b/tests/disas/gc/copying/ref-test-concrete-type.wat
index ae712ec9839d..449bd0b2a195 100644
--- a/tests/disas/gc/copying/ref-test-concrete-type.wat
+++ b/tests/disas/gc/copying/ref-test-concrete-type.wat
@@ -9,15 +9,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -33,7 +33,7 @@
 ;;
 ;;                                 block3:
 ;; @001d                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001d                               v12 = uextend.i64 v2
 ;; @001d                               v15 = iadd v14, v12
 ;; @001d                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/copying/ref-test-eq.wat b/tests/disas/gc/copying/ref-test-eq.wat
index c98de5880a8f..6b36e4bfd008 100644
--- a/tests/disas/gc/copying/ref-test-eq.wat
+++ b/tests/disas/gc/copying/ref-test-eq.wat
@@ -8,13 +8,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -29,7 +29,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/copying/ref-test-i31.wat b/tests/disas/gc/copying/ref-test-i31.wat
index 5a90cace2877..6e897707bba4 100644
--- a/tests/disas/gc/copying/ref-test-i31.wat
+++ b/tests/disas/gc/copying/ref-test-i31.wat
@@ -8,10 +8,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/ref-test-none.wat b/tests/disas/gc/copying/ref-test-none.wat
index af5be3dfb0da..81ee67112929 100644
--- a/tests/disas/gc/copying/ref-test-none.wat
+++ b/tests/disas/gc/copying/ref-test-none.wat
@@ -11,10 +11,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -27,10 +27,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/copying/ref-test-struct.wat b/tests/disas/gc/copying/ref-test-struct.wat
index 49b9c5378a5d..e6ee41a07ce8 100644
--- a/tests/disas/gc/copying/ref-test-struct.wat
+++ b/tests/disas/gc/copying/ref-test-struct.wat
@@ -8,13 +8,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,7 +30,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/copying/struct-get.wat b/tests/disas/gc/copying/struct-get.wat
index b09ef1bac248..2261ca045fd6 100644
--- a/tests/disas/gc/copying/struct-get.wat
+++ b/tests/disas/gc/copying/struct-get.wat
@@ -24,19 +24,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0033                               trapz v2, user16
 ;; @0033                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0033                               v3 = uextend.i64 v2
 ;; @0033                               v6 = iadd v5, v3
 ;; @0033                               v7 = iconst.i64 16
@@ -50,19 +50,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @003c                               trapz v2, user16
 ;; @003c                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @003c                               v3 = uextend.i64 v2
 ;; @003c                               v6 = iadd v5, v3
 ;; @003c                               v7 = iconst.i64 20
@@ -77,19 +77,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0045                               trapz v2, user16
 ;; @0045                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0045                               v3 = uextend.i64 v2
 ;; @0045                               v6 = iadd v5, v3
 ;; @0045                               v7 = iconst.i64 20
@@ -104,19 +104,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @004e                               v3 = uextend.i64 v2
 ;; @004e                               v6 = iadd v5, v3
 ;; @004e                               v7 = iconst.i64 24
diff --git a/tests/disas/gc/copying/struct-new-default.wat b/tests/disas/gc/copying/struct-new-default.wat
index 4345e54f18e7..568c54188304 100644
--- a/tests/disas/gc/copying/struct-new-default.wat
+++ b/tests/disas/gc/copying/struct-new-default.wat
@@ -12,17 +12,17 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -44,7 +44,7 @@
 ;; @0021                               store notrap aligned region3 v57, v6
 ;;                                     v60 = iconst.i32 -1342177246
 ;;                                     v61 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v62 = load.i64 notrap aligned readonly can_move region7 v61+32
+;;                                     v62 = load.i64 notrap aligned readonly can_move region7 v61+40
 ;; @0021                               v31 = iadd v62, v14
 ;; @0021                               store user2 region8 v60, v31  ; v60 = -1342177246
 ;;                                     v63 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -62,7 +62,7 @@
 ;; @0021                               v21 = iconst.i32 16
 ;; @0021                               v22 = call fn0(v0, v18, v20, v5, v21)  ; v18 = -1342177246, v5 = 32, v21 = 16
 ;; @0021                               v23 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0021                               v24 = load.i64 notrap aligned readonly can_move region7 v23+32
+;; @0021                               v24 = load.i64 notrap aligned readonly can_move region7 v23+40
 ;; @0021                               v25 = uextend.i64 v22
 ;; @0021                               v26 = iadd v24, v25
 ;; @0021                               jump block4(v22, v26)
diff --git a/tests/disas/gc/copying/struct-new.wat b/tests/disas/gc/copying/struct-new.wat
index 5d3c5033635d..0835cf2c9267 100644
--- a/tests/disas/gc/copying/struct-new.wat
+++ b/tests/disas/gc/copying/struct-new.wat
@@ -13,18 +13,18 @@
 ;; function u0:0(i64 vmctx, i64, f32, i32, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
 ;;     region9 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -48,7 +48,7 @@
 ;; @002a                               store notrap aligned region3 v60, v6
 ;;                                     v63 = iconst.i32 -1342177246
 ;;                                     v64 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+32
+;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+40
 ;; @002a                               v31 = iadd v65, v14
 ;; @002a                               store user2 region8 v63, v31  ; v63 = -1342177246
 ;;                                     v66 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -66,7 +66,7 @@
 ;; @002a                               v21 = iconst.i32 16
 ;; @002a                               v22 = call fn0(v0, v18, v20, v5, v21), stack_map=[i32 @ ss0+0]  ; v18 = -1342177246, v5 = 32, v21 = 16
 ;; @002a                               v23 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v24 = load.i64 notrap aligned readonly can_move region7 v23+32
+;; @002a                               v24 = load.i64 notrap aligned readonly can_move region7 v23+40
 ;; @002a                               v25 = uextend.i64 v22
 ;; @002a                               v26 = iadd v24, v25
 ;; @002a                               jump block4(v22, v26)
diff --git a/tests/disas/gc/copying/struct-set.wat b/tests/disas/gc/copying/struct-set.wat
index e04ddcf2b202..1c6f271973f0 100644
--- a/tests/disas/gc/copying/struct-set.wat
+++ b/tests/disas/gc/copying/struct-set.wat
@@ -20,19 +20,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, f32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
 ;; @0034                               trapz v2, user16
 ;; @0034                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0034                               v4 = uextend.i64 v2
 ;; @0034                               v7 = iadd v6, v4
 ;; @0034                               v8 = iconst.i64 16
@@ -46,19 +46,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @003f                               v4 = uextend.i64 v2
 ;; @003f                               v7 = iadd v6, v4
 ;; @003f                               v8 = iconst.i64 20
@@ -72,19 +72,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @004a                               trapz v2, user16
 ;; @004a                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @004a                               v4 = uextend.i64 v2
 ;; @004a                               v7 = iadd v6, v4
 ;; @004a                               v8 = iconst.i64 24
diff --git a/tests/disas/gc/copying/v128-fields.wat b/tests/disas/gc/copying/v128-fields.wat
index 37172498c2bf..70daae200ea6 100644
--- a/tests/disas/gc/copying/v128-fields.wat
+++ b/tests/disas/gc/copying/v128-fields.wat
@@ -12,19 +12,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0022                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0022                               v3 = uextend.i64 v2
 ;; @0022                               v6 = iadd v5, v3
 ;; @0022                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/drc/array-fill.wat b/tests/disas/gc/drc/array-fill.wat
index c2b063edd9b1..7aa3e3066bae 100644
--- a/tests/disas/gc/drc/array-fill.wat
+++ b/tests/disas/gc/drc/array-fill.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):
 ;; @0027                               trapz v2, user16
 ;; @0027                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0027                               v6 = uextend.i64 v2
 ;; @0027                               v9 = iadd v8, v6
 ;; @0027                               v10 = iconst.i64 24
@@ -35,7 +35,7 @@
 ;; @0027                               v13 = uextend.i64 v12
 ;; @0027                               v19 = icmp ugt v18, v13
 ;; @0027                               trapnz v19, user17
-;; @0027                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0027                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0027                               v24 = iconst.i64 32
 ;; @0027                               v25 = iadd v9, v24  ; v24 = 32
 ;;                                     v49 = iconst.i64 3
diff --git a/tests/disas/gc/drc/array-get-s.wat b/tests/disas/gc/drc/array-get-s.wat
index 9408317aec0a..d225e6875af0 100644
--- a/tests/disas/gc/drc/array-get-s.wat
+++ b/tests/disas/gc/drc/array-get-s.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-get-u.wat b/tests/disas/gc/drc/array-get-u.wat
index 890de6e20d7b..49e704f9ee74 100644
--- a/tests/disas/gc/drc/array-get-u.wat
+++ b/tests/disas/gc/drc/array-get-u.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-get.wat b/tests/disas/gc/drc/array-get.wat
index 8a6b7e6bd585..272689163f4f 100644
--- a/tests/disas/gc/drc/array-get.wat
+++ b/tests/disas/gc/drc/array-get.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-len.wat b/tests/disas/gc/drc/array-len.wat
index 18e8ba08c67b..e234bed12b97 100644
--- a/tests/disas/gc/drc/array-len.wat
+++ b/tests/disas/gc/drc/array-len.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @001f                               trapz v2, user16
 ;; @001f                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @001f                               v3 = uextend.i64 v2
 ;; @001f                               v6 = iadd v5, v3
 ;; @001f                               v7 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat
index 9ea0e6bf3509..6507b16b2761 100644
--- a/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat
+++ b/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat
@@ -14,18 +14,18 @@
 ;;     ss1 = explicit_slot 4, align = 4
 ;;     ss2 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
-;;     region6 = 67108904 "VMStoreContext+0x28"
+;;     region6 = 67108912 "VMStoreContext+0x30"
 ;;     region7 = 1543503872 "Stack(ss0)"
 ;;     region8 = 1543503873 "Stack(ss1)"
 ;;     region9 = 1543503874 "Stack(ss2)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -45,7 +45,7 @@
 ;; @0025                               v18 = call fn0(v0, v14, v16, v216, v17), stack_map=[i32 @ ss2+0, i32 @ ss1+0, i32 @ ss0+0]  ; v14 = -1476395008, v216 = 40, v17 = 8
 ;; @0025                               v5 = iconst.i32 3
 ;; @0025                               v19 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v20 = load.i64 notrap aligned readonly can_move region4 v19+32
+;; @0025                               v20 = load.i64 notrap aligned readonly can_move region4 v19+40
 ;; @0025                               v21 = uextend.i64 v18
 ;; @0025                               v22 = iadd v20, v21
 ;; @0025                               v23 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-new-fixed.wat b/tests/disas/gc/drc/array-new-fixed.wat
index ab1bc04f634c..66b139436c2a 100644
--- a/tests/disas/gc/drc/array-new-fixed.wat
+++ b/tests/disas/gc/drc/array-new-fixed.wat
@@ -11,15 +11,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
-;;     region6 = 67108904 "VMStoreContext+0x28"
+;;     region6 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -33,7 +33,7 @@
 ;; @0025                               v18 = call fn0(v0, v14, v16, v119, v17)  ; v14 = -1476395008, v119 = 56, v17 = 8
 ;; @0025                               v5 = iconst.i32 3
 ;; @0025                               v19 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v20 = load.i64 notrap aligned readonly can_move region4 v19+32
+;; @0025                               v20 = load.i64 notrap aligned readonly can_move region4 v19+40
 ;; @0025                               v21 = uextend.i64 v18
 ;; @0025                               v22 = iadd v20, v21
 ;;                                     v110 = iconst.i64 24
diff --git a/tests/disas/gc/drc/array-new.wat b/tests/disas/gc/drc/array-new.wat
index 540a676547cd..d790f602e2e4 100644
--- a/tests/disas/gc/drc/array-new.wat
+++ b/tests/disas/gc/drc/array-new.wat
@@ -11,15 +11,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
-;;     region6 = 67108904 "VMStoreContext+0x28"
+;;     region6 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -41,14 +41,14 @@
 ;;                                     v70 = iconst.i32 8
 ;; @0022                               v16 = call fn0(v0, v12, v14, v11, v70)  ; v12 = -1476395008, v70 = 8
 ;; @0022                               v17 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v18 = load.i64 notrap aligned readonly can_move region4 v17+32
+;; @0022                               v18 = load.i64 notrap aligned readonly can_move region4 v17+40
 ;; @0022                               v19 = uextend.i64 v16
 ;; @0022                               v20 = iadd v18, v19
 ;; @0022                               v21 = iconst.i64 24
 ;; @0022                               v22 = iadd v20, v21  ; v21 = 24
 ;; @0022                               store user2 region5 v3, v22
 ;; @0022                               trapz v16, user16
-;; @0022                               v54 = load.i64 notrap aligned region6 v17+40
+;; @0022                               v54 = load.i64 notrap aligned region6 v17+48
 ;; @0022                               v43 = iadd v20, v8  ; v8 = 32
 ;; @0022                               v56 = uadd_overflow_trap v43, v66, user2
 ;; @0022                               v55 = iadd v18, v54
diff --git a/tests/disas/gc/drc/array-set.wat b/tests/disas/gc/drc/array-set.wat
index e217b319d14e..08d7b28b2778 100644
--- a/tests/disas/gc/drc/array-set.wat
+++ b/tests/disas/gc/drc/array-set.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 24
diff --git a/tests/disas/gc/drc/br-on-cast-fail.wat b/tests/disas/gc/drc/br-on-cast-fail.wat
index 7c7f75e26597..020d6d4d0fec 100644
--- a/tests/disas/gc/drc/br-on-cast-fail.wat
+++ b/tests/disas/gc/drc/br-on-cast-fail.wat
@@ -18,17 +18,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -45,7 +45,7 @@
 ;;
 ;;                                 block4:
 ;; @002e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002e                               v12 = uextend.i64 v2
 ;; @002e                               v15 = iadd v14, v12
 ;; @002e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/drc/br-on-cast.wat b/tests/disas/gc/drc/br-on-cast.wat
index 1aec99d328f7..14d9583a706e 100644
--- a/tests/disas/gc/drc/br-on-cast.wat
+++ b/tests/disas/gc/drc/br-on-cast.wat
@@ -18,17 +18,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -45,7 +45,7 @@
 ;;
 ;;                                 block4:
 ;; @002f                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002f                               v12 = uextend.i64 v2
 ;; @002f                               v15 = iadd v14, v12
 ;; @002f                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/drc/call-indirect-and-subtyping.wat b/tests/disas/gc/drc/call-indirect-and-subtyping.wat
index 7e1d9260fe5c..543a60c8e34e 100644
--- a/tests/disas/gc/drc/call-indirect-and-subtyping.wat
+++ b/tests/disas/gc/drc/call-indirect-and-subtyping.wat
@@ -18,7 +18,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -28,7 +28,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     sig2 = (i64 vmctx, i32, i32) -> i32 tail
diff --git a/tests/disas/gc/drc/externref-globals.wat b/tests/disas/gc/drc/externref-globals.wat
index 6d240d68cbb5..d26e65dc9536 100644
--- a/tests/disas/gc/drc/externref-globals.wat
+++ b/tests/disas/gc/drc/externref-globals.wat
@@ -15,10 +15,10 @@
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
-;;     region3 = 67108896 "VMStoreContext+0x20"
-;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108912 "VMStoreContext+0x30"
 ;;     region5 = 536870912 "GcHeap"
 ;;     region6 = 32 "VMContext+0x20"
 ;;     region7 = 805306368 "VMDrcHeapData+0x0"
@@ -27,7 +27,7 @@
 ;;     region10 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i8 tail
 ;;     fn0 = colocated u805306368:45 sig0
 ;;     stack_limit = gv2
@@ -48,7 +48,7 @@
 ;;
 ;;                                 block2:
 ;; @0034                               v12 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0034                               v13 = load.i64 notrap aligned readonly can_move region3 v12+32
+;; @0034                               v13 = load.i64 notrap aligned readonly can_move region3 v12+40
 ;; @0034                               v11 = uextend.i64 v4
 ;; @0034                               v14 = iadd v13, v11
 ;; @0034                               v15 = load.i32 user2 region5 v14
@@ -100,14 +100,14 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
-;;     region3 = 67108896 "VMStoreContext+0x20"
-;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108912 "VMStoreContext+0x30"
 ;;     region5 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) tail
 ;;     fn0 = colocated u805306368:22 sig0
 ;;     stack_limit = gv2
@@ -126,7 +126,7 @@
 ;;
 ;;                                 block2:
 ;; @003b                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003b                               v14 = load.i64 notrap aligned readonly can_move region3 v13+32
+;; @003b                               v14 = load.i64 notrap aligned readonly can_move region3 v13+40
 ;; @003b                               v12 = uextend.i64 v2
 ;; @003b                               v15 = iadd v14, v12
 ;; @003b                               v16 = iconst.i64 8
@@ -150,7 +150,7 @@
 ;;
 ;;                                 block4:
 ;;                                     v67 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v68 = load.i64 notrap aligned readonly can_move region3 v67+32
+;;                                     v68 = load.i64 notrap aligned readonly can_move region3 v67+40
 ;; @003b                               v33 = uextend.i64 v5
 ;; @003b                               v36 = iadd v68, v33
 ;;                                     v69 = iconst.i64 8
diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat b/tests/disas/gc/drc/funcref-in-gc-heap-get.wat
index 81b77e00c84e..7f4b35d03697 100644
--- a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat
+++ b/tests/disas/gc/drc/funcref-in-gc-heap-get.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:26 sig0
 ;;     stack_limit = gv2
@@ -25,7 +25,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0020                               trapz v2, user16
 ;; @0020                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0020                               v3 = uextend.i64 v2
 ;; @0020                               v6 = iadd v5, v3
 ;; @0020                               v7 = iconst.i64 24
diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-new.wat b/tests/disas/gc/drc/funcref-in-gc-heap-new.wat
index 38b5a83be3f9..943bf81a698f 100644
--- a/tests/disas/gc/drc/funcref-in-gc-heap-new.wat
+++ b/tests/disas/gc/drc/funcref-in-gc-heap-new.wat
@@ -12,15 +12,15 @@
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
 ;;     region6 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:24 sig0
@@ -39,7 +39,7 @@
 ;; @0020                               v15 = call fn1(v0, v2), stack_map=[i32 @ ss0+0]
 ;; @0020                               v16 = ireduce.i32 v15
 ;; @0020                               v9 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v10 = load.i64 notrap aligned readonly can_move region4 v9+32
+;; @0020                               v10 = load.i64 notrap aligned readonly can_move region4 v9+40
 ;; @0020                               v11 = uextend.i64 v8
 ;; @0020                               v12 = iadd v10, v11
 ;; @0020                               v13 = iconst.i64 24
diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat b/tests/disas/gc/drc/funcref-in-gc-heap-set.wat
index 5787a8bf9543..8ac33359590b 100644
--- a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat
+++ b/tests/disas/gc/drc/funcref-in-gc-heap-set.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:25 sig0
 ;;     stack_limit = gv2
@@ -27,7 +27,7 @@
 ;; @0022                               v10 = call fn0(v0, v3)
 ;; @0022                               v11 = ireduce.i32 v10
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 24
diff --git a/tests/disas/gc/drc/i31ref-globals.wat b/tests/disas/gc/drc/i31ref-globals.wat
index 8e8cb8b23579..11adfe943fae 100644
--- a/tests/disas/gc/drc/i31ref-globals.wat
+++ b/tests/disas/gc/drc/i31ref-globals.wat
@@ -14,11 +14,11 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -33,11 +33,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/drc/multiple-array-get.wat b/tests/disas/gc/drc/multiple-array-get.wat
index e13d8cc119c3..75651fe94cd3 100644
--- a/tests/disas/gc/drc/multiple-array-get.wat
+++ b/tests/disas/gc/drc/multiple-array-get.wat
@@ -12,19 +12,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 24
diff --git a/tests/disas/gc/drc/multiple-struct-get.wat b/tests/disas/gc/drc/multiple-struct-get.wat
index 525f9d01dc68..5829323138fc 100644
--- a/tests/disas/gc/drc/multiple-struct-get.wat
+++ b/tests/disas/gc/drc/multiple-struct-get.wat
@@ -13,19 +13,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0023                               trapz v2, user16
 ;; @0023                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0023                               v3 = uextend.i64 v2
 ;; @0023                               v6 = iadd v5, v3
 ;; @0023                               v7 = iconst.i64 24
diff --git a/tests/disas/gc/drc/ref-cast.wat b/tests/disas/gc/drc/ref-cast.wat
index 9ee28ff22edb..20f8ae4aaaca 100644
--- a/tests/disas/gc/drc/ref-cast.wat
+++ b/tests/disas/gc/drc/ref-cast.wat
@@ -10,15 +10,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -34,7 +34,7 @@
 ;;
 ;;                                 block3:
 ;; @001e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001e                               v12 = uextend.i64 v2
 ;; @001e                               v15 = iadd v14, v12
 ;; @001e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/drc/ref-is-null.wat b/tests/disas/gc/drc/ref-is-null.wat
index 0e7918fd2bbe..5a8e0003f831 100644
--- a/tests/disas/gc/drc/ref-is-null.wat
+++ b/tests/disas/gc/drc/ref-is-null.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,10 +30,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/drc/ref-test-any.wat b/tests/disas/gc/drc/ref-test-any.wat
index 6180b722a06b..e6b118517056 100644
--- a/tests/disas/gc/drc/ref-test-any.wat
+++ b/tests/disas/gc/drc/ref-test-any.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,10 +30,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/drc/ref-test-array.wat b/tests/disas/gc/drc/ref-test-array.wat
index 6bbd27242526..6b2b134bd658 100644
--- a/tests/disas/gc/drc/ref-test-array.wat
+++ b/tests/disas/gc/drc/ref-test-array.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -31,7 +31,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/drc/ref-test-concrete-func-type.wat b/tests/disas/gc/drc/ref-test-concrete-func-type.wat
index e4a9abda4f54..22281a5f848b 100644
--- a/tests/disas/gc/drc/ref-test-concrete-func-type.wat
+++ b/tests/disas/gc/drc/ref-test-concrete-func-type.wat
@@ -10,13 +10,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
 ;;     region4 = 1610612752 "VMFuncRef+0x10"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/gc/drc/ref-test-concrete-type.wat b/tests/disas/gc/drc/ref-test-concrete-type.wat
index abba85535a44..e1d36bbf94de 100644
--- a/tests/disas/gc/drc/ref-test-concrete-type.wat
+++ b/tests/disas/gc/drc/ref-test-concrete-type.wat
@@ -10,15 +10,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -34,7 +34,7 @@
 ;;
 ;;                                 block3:
 ;; @001d                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001d                               v12 = uextend.i64 v2
 ;; @001d                               v15 = iadd v14, v12
 ;; @001d                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/drc/ref-test-eq.wat b/tests/disas/gc/drc/ref-test-eq.wat
index 75c28f800081..98be0ad9cd0b 100644
--- a/tests/disas/gc/drc/ref-test-eq.wat
+++ b/tests/disas/gc/drc/ref-test-eq.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,7 +30,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/drc/ref-test-i31.wat b/tests/disas/gc/drc/ref-test-i31.wat
index b7d018aa03e9..22c330439cf1 100644
--- a/tests/disas/gc/drc/ref-test-i31.wat
+++ b/tests/disas/gc/drc/ref-test-i31.wat
@@ -9,10 +9,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/drc/ref-test-none.wat b/tests/disas/gc/drc/ref-test-none.wat
index 0e018bd5b5a1..3e72cc5ed187 100644
--- a/tests/disas/gc/drc/ref-test-none.wat
+++ b/tests/disas/gc/drc/ref-test-none.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -28,10 +28,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/drc/ref-test-struct.wat b/tests/disas/gc/drc/ref-test-struct.wat
index 16c119a315ef..fecb851752e3 100644
--- a/tests/disas/gc/drc/ref-test-struct.wat
+++ b/tests/disas/gc/drc/ref-test-struct.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -31,7 +31,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/drc/struct-get.wat b/tests/disas/gc/drc/struct-get.wat
index 99b6552dccf3..18879f44db6b 100644
--- a/tests/disas/gc/drc/struct-get.wat
+++ b/tests/disas/gc/drc/struct-get.wat
@@ -25,19 +25,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0033                               trapz v2, user16
 ;; @0033                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0033                               v3 = uextend.i64 v2
 ;; @0033                               v6 = iadd v5, v3
 ;; @0033                               v7 = iconst.i64 24
@@ -51,19 +51,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @003c                               trapz v2, user16
 ;; @003c                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @003c                               v3 = uextend.i64 v2
 ;; @003c                               v6 = iadd v5, v3
 ;; @003c                               v7 = iconst.i64 28
@@ -78,19 +78,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0045                               trapz v2, user16
 ;; @0045                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0045                               v3 = uextend.i64 v2
 ;; @0045                               v6 = iadd v5, v3
 ;; @0045                               v7 = iconst.i64 28
@@ -106,9 +106,9 @@
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     region5 = 32 "VMContext+0x20"
 ;;     region6 = 805306368 "VMDrcHeapData+0x0"
@@ -117,7 +117,7 @@
 ;;     region9 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i8 tail
 ;;     fn0 = colocated u805306368:45 sig0
 ;;     stack_limit = gv2
@@ -125,7 +125,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @004e                               v3 = uextend.i64 v2
 ;; @004e                               v6 = iadd v5, v3
 ;; @004e                               v7 = iconst.i64 32
diff --git a/tests/disas/gc/drc/struct-new-default.wat b/tests/disas/gc/drc/struct-new-default.wat
index 913b5862d4b3..09c037a15349 100644
--- a/tests/disas/gc/drc/struct-new-default.wat
+++ b/tests/disas/gc/drc/struct-new-default.wat
@@ -13,15 +13,15 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
-;;     region6 = 67108904 "VMStoreContext+0x28"
+;;     region6 = 67108912 "VMStoreContext+0x30"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -35,7 +35,7 @@
 ;; @0021                               v10 = call fn0(v0, v6, v8, v5, v9)  ; v6 = -1342177280, v5 = 40, v9 = 8
 ;; @0021                               v2 = f32const 0.0
 ;; @0021                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0021                               v12 = load.i64 notrap aligned readonly can_move region4 v11+32
+;; @0021                               v12 = load.i64 notrap aligned readonly can_move region4 v11+40
 ;; @0021                               v13 = uextend.i64 v10
 ;; @0021                               v14 = iadd v12, v13
 ;; @0021                               v15 = iconst.i64 24
diff --git a/tests/disas/gc/drc/struct-new.wat b/tests/disas/gc/drc/struct-new.wat
index 5c83bed9c857..4b5683ef44e8 100644
--- a/tests/disas/gc/drc/struct-new.wat
+++ b/tests/disas/gc/drc/struct-new.wat
@@ -14,16 +14,16 @@
 ;; function u0:0(i64 vmctx, i64, f32, i32, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108904 "VMStoreContext+0x28"
 ;;     region5 = 536870912 "GcHeap"
-;;     region6 = 67108904 "VMStoreContext+0x28"
+;;     region6 = 67108912 "VMStoreContext+0x30"
 ;;     region7 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -38,7 +38,7 @@
 ;; @002a                               v9 = iconst.i32 8
 ;; @002a                               v10 = call fn0(v0, v6, v8, v5, v9), stack_map=[i32 @ ss0+0]  ; v6 = -1342177280, v5 = 40, v9 = 8
 ;; @002a                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v12 = load.i64 notrap aligned readonly can_move region4 v11+32
+;; @002a                               v12 = load.i64 notrap aligned readonly can_move region4 v11+40
 ;; @002a                               v13 = uextend.i64 v10
 ;; @002a                               v14 = iadd v12, v13
 ;; @002a                               v15 = iconst.i64 24
diff --git a/tests/disas/gc/drc/struct-set.wat b/tests/disas/gc/drc/struct-set.wat
index 9835e23fb1b0..f6d95ea1a867 100644
--- a/tests/disas/gc/drc/struct-set.wat
+++ b/tests/disas/gc/drc/struct-set.wat
@@ -21,19 +21,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, f32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
 ;; @0034                               trapz v2, user16
 ;; @0034                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0034                               v4 = uextend.i64 v2
 ;; @0034                               v7 = iadd v6, v4
 ;; @0034                               v8 = iconst.i64 24
@@ -47,19 +47,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @003f                               v4 = uextend.i64 v2
 ;; @003f                               v7 = iadd v6, v4
 ;; @003f                               v8 = iconst.i64 28
@@ -73,13 +73,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) tail
 ;;     fn0 = colocated u805306368:22 sig0
 ;;     stack_limit = gv2
@@ -87,7 +87,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @004a                               trapz v2, user16
 ;; @004a                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @004a                               v4 = uextend.i64 v2
 ;; @004a                               v7 = iadd v6, v4
 ;; @004a                               v8 = iconst.i64 32
diff --git a/tests/disas/gc/issue-11753.wat b/tests/disas/gc/issue-11753.wat
index bfcf95eeb84e..26dd49bb522c 100644
--- a/tests/disas/gc/issue-11753.wat
+++ b/tests/disas/gc/issue-11753.wat
@@ -26,7 +26,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x50, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x11a
@@ -48,7 +48,7 @@
 ;;       movl    %edi, (%rsi)
 ;;       movq    8(%rsp), %r9
 ;;       movq    8(%r9), %rsi
-;;       movq    0x20(%rsi), %rdi
+;;       movq    0x28(%rsi), %rdi
 ;;       leaq    (%rdi, %rcx), %rsi
 ;;       movl    $0xb0000002, (%rdi, %rcx)
 ;;       ╰─╼ trap: GcHeapCorrupt
@@ -75,7 +75,7 @@
 ;;       je      0x11c
 ;;   b1: movq    8(%rsp), %r9
 ;;       movq    8(%r9), %rcx
-;;       movq    0x20(%rcx), %rcx
+;;       movq    0x28(%rcx), %rcx
 ;;       movl    %eax, %eax
 ;;       movl    0x10(%rcx, %rax), %eax
 ;;       ╰─╼ trap: GcHeapCorrupt
@@ -98,7 +98,7 @@
 ;;  106: movq    8(%rsp), %r9
 ;;  10b: movq    8(%r9), %rcx
 ;;  10f: movl    %eax, %esi
-;;  111: addq    0x20(%rcx), %rsi
+;;  111: addq    0x28(%rcx), %rsi
 ;;  115: jmp     0x88
 ;;  11a: ud2
 ;;       ╰─╼ trap: Normal(StackOverflow)
diff --git a/tests/disas/gc/null/array-fill.wat b/tests/disas/gc/null/array-fill.wat
index 01c5466df089..02c9432e3f3b 100644
--- a/tests/disas/gc/null/array-fill.wat
+++ b/tests/disas/gc/null/array-fill.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64, v5: i32):
 ;; @0027                               trapz v2, user16
 ;; @0027                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+32
+;; @0027                               v8 = load.i64 notrap aligned readonly can_move region2 v7+40
 ;; @0027                               v6 = uextend.i64 v2
 ;; @0027                               v9 = iadd v8, v6
 ;; @0027                               v10 = iconst.i64 8
@@ -35,7 +35,7 @@
 ;; @0027                               v13 = uextend.i64 v12
 ;; @0027                               v19 = icmp ugt v18, v13
 ;; @0027                               trapnz v19, user17
-;; @0027                               v36 = load.i64 notrap aligned region3 v7+40
+;; @0027                               v36 = load.i64 notrap aligned region3 v7+48
 ;; @0027                               v24 = iconst.i64 16
 ;; @0027                               v25 = iadd v9, v24  ; v24 = 16
 ;;                                     v49 = iconst.i64 3
diff --git a/tests/disas/gc/null/array-get-s.wat b/tests/disas/gc/null/array-get-s.wat
index 16e0904cdd42..02e222345362 100644
--- a/tests/disas/gc/null/array-get-s.wat
+++ b/tests/disas/gc/null/array-get-s.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 8
diff --git a/tests/disas/gc/null/array-get-u.wat b/tests/disas/gc/null/array-get-u.wat
index f47608d6ddac..6ade7ce0d17e 100644
--- a/tests/disas/gc/null/array-get-u.wat
+++ b/tests/disas/gc/null/array-get-u.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 8
diff --git a/tests/disas/gc/null/array-get.wat b/tests/disas/gc/null/array-get.wat
index be3d91eb5537..67df14c86fca 100644
--- a/tests/disas/gc/null/array-get.wat
+++ b/tests/disas/gc/null/array-get.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 8
diff --git a/tests/disas/gc/null/array-len.wat b/tests/disas/gc/null/array-len.wat
index 6de1e98f9349..55a2e2ffb0eb 100644
--- a/tests/disas/gc/null/array-len.wat
+++ b/tests/disas/gc/null/array-len.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @001f                               trapz v2, user16
 ;; @001f                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @001f                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @001f                               v3 = uextend.i64 v2
 ;; @001f                               v6 = iadd v5, v3
 ;; @001f                               v7 = iconst.i64 8
diff --git a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat
index 9a66faaa4ac8..5ccea0eb26b8 100644
--- a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat
+++ b/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat
@@ -14,11 +14,11 @@
 ;;     ss1 = explicit_slot 4, align = 4
 ;;     ss2 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
@@ -27,7 +27,7 @@
 ;;     region11 = 1543503874 "Stack(ss2)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     fn0 = colocated u805306368:23 sig0
 ;;     stack_limit = gv2
@@ -48,14 +48,14 @@
 ;;                                     v144 = iconst.i32 24
 ;; @0025                               v24 = uadd_overflow_trap v23, v144, user18  ; v144 = 24
 ;; @0025                               v26 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v27 = load.i64 notrap aligned region4 v26+40
+;; @0025                               v27 = load.i64 notrap aligned region4 v26+48
 ;; @0025                               v25 = uextend.i64 v24
 ;; @0025                               v28 = icmp ule v25, v27
 ;; @0025                               brif v28, block2, block3
 ;;
 ;;                                 block2:
 ;;                                     v158 = iconst.i32 -1476394984
-;; @0025                               v32 = load.i64 notrap aligned readonly can_move region5 v26+32
+;; @0025                               v32 = load.i64 notrap aligned readonly can_move region5 v26+40
 ;;                                     v252 = band.i32 v21, v157  ; v157 = -8
 ;;                                     v253 = uextend.i64 v252
 ;; @0025                               v34 = iadd v32, v253
diff --git a/tests/disas/gc/null/array-new-fixed.wat b/tests/disas/gc/null/array-new-fixed.wat
index 7267cb4e0206..61e4416a0ea1 100644
--- a/tests/disas/gc/null/array-new-fixed.wat
+++ b/tests/disas/gc/null/array-new-fixed.wat
@@ -11,17 +11,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     fn0 = colocated u805306368:23 sig0
 ;;     stack_limit = gv2
@@ -36,14 +36,14 @@
 ;;                                     v135 = iconst.i32 40
 ;; @0025                               v24 = uadd_overflow_trap v23, v135, user18  ; v135 = 40
 ;; @0025                               v26 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0025                               v27 = load.i64 notrap aligned region4 v26+40
+;; @0025                               v27 = load.i64 notrap aligned region4 v26+48
 ;; @0025                               v25 = uextend.i64 v24
 ;; @0025                               v28 = icmp ule v25, v27
 ;; @0025                               brif v28, block2, block3
 ;;
 ;;                                 block2:
 ;;                                     v149 = iconst.i32 -1476394968
-;; @0025                               v32 = load.i64 notrap aligned readonly can_move region5 v26+32
+;; @0025                               v32 = load.i64 notrap aligned readonly can_move region5 v26+40
 ;;                                     v240 = band.i32 v21, v148  ; v148 = -8
 ;;                                     v241 = uextend.i64 v240
 ;; @0025                               v34 = iadd v32, v241
diff --git a/tests/disas/gc/null/array-new.wat b/tests/disas/gc/null/array-new.wat
index da830db79553..679e11efdc35 100644
--- a/tests/disas/gc/null/array-new.wat
+++ b/tests/disas/gc/null/array-new.wat
@@ -11,17 +11,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     fn0 = colocated u805306368:23 sig0
 ;;     stack_limit = gv2
@@ -48,7 +48,7 @@
 ;; @0022                               v21 = band v19, v98  ; v98 = -8
 ;; @0022                               v22 = uadd_overflow_trap v21, v11, user18
 ;; @0022                               v24 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v25 = load.i64 notrap aligned region4 v24+40
+;; @0022                               v25 = load.i64 notrap aligned region4 v24+48
 ;; @0022                               v23 = uextend.i64 v22
 ;; @0022                               v26 = icmp ule v23, v25
 ;; @0022                               brif v26, block2, block3
@@ -56,7 +56,7 @@
 ;;                                 block2:
 ;; @0022                               v33 = iconst.i32 -1476395008
 ;;                                     v99 = bor.i32 v11, v33  ; v33 = -1476395008
-;; @0022                               v30 = load.i64 notrap aligned readonly can_move region5 v24+32
+;; @0022                               v30 = load.i64 notrap aligned readonly can_move region5 v24+40
 ;;                                     v116 = band.i32 v19, v98  ; v98 = -8
 ;;                                     v117 = uextend.i64 v116
 ;; @0022                               v32 = iadd v30, v117
@@ -69,7 +69,7 @@
 ;; @0022                               v38 = iadd v32, v6  ; v6 = 8
 ;; @0022                               store.i32 user2 region8 v3, v38
 ;; @0022                               trapz v116, user16
-;; @0022                               v70 = load.i64 notrap aligned region4 v24+40
+;; @0022                               v70 = load.i64 notrap aligned region4 v24+48
 ;; @0022                               v58 = iconst.i64 16
 ;; @0022                               v59 = iadd v32, v58  ; v58 = 16
 ;; @0022                               v72 = uadd_overflow_trap v59, v82, user2
diff --git a/tests/disas/gc/null/array-set.wat b/tests/disas/gc/null/array-set.wat
index a4f5bf3b3d25..d3d34c955945 100644
--- a/tests/disas/gc/null/array-set.wat
+++ b/tests/disas/gc/null/array-set.wat
@@ -11,19 +11,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i64):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 8
diff --git a/tests/disas/gc/null/br-on-cast-fail.wat b/tests/disas/gc/null/br-on-cast-fail.wat
index b6bdc6798c63..d735f1fd3e16 100644
--- a/tests/disas/gc/null/br-on-cast-fail.wat
+++ b/tests/disas/gc/null/br-on-cast-fail.wat
@@ -18,17 +18,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -45,7 +45,7 @@
 ;;
 ;;                                 block4:
 ;; @002e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002e                               v12 = uextend.i64 v2
 ;; @002e                               v15 = iadd v14, v12
 ;; @002e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/null/br-on-cast.wat b/tests/disas/gc/null/br-on-cast.wat
index 75d7e2208305..f2d8d0ecc05c 100644
--- a/tests/disas/gc/null/br-on-cast.wat
+++ b/tests/disas/gc/null/br-on-cast.wat
@@ -18,17 +18,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     region7 = 1207959576 "VMFunctionImport+0x18"
 ;;     region8 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
@@ -45,7 +45,7 @@
 ;;
 ;;                                 block4:
 ;; @002f                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002f                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002f                               v12 = uextend.i64 v2
 ;; @002f                               v15 = iadd v14, v12
 ;; @002f                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/null/call-indirect-and-subtyping.wat b/tests/disas/gc/null/call-indirect-and-subtyping.wat
index b3144b10ade1..f9df058bf380 100644
--- a/tests/disas/gc/null/call-indirect-and-subtyping.wat
+++ b/tests/disas/gc/null/call-indirect-and-subtyping.wat
@@ -18,7 +18,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -28,7 +28,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     sig2 = (i64 vmctx, i32, i32) -> i32 tail
diff --git a/tests/disas/gc/null/externref-globals.wat b/tests/disas/gc/null/externref-globals.wat
index 65cb9d590693..c146c20f880b 100644
--- a/tests/disas/gc/null/externref-globals.wat
+++ b/tests/disas/gc/null/externref-globals.wat
@@ -14,11 +14,11 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -33,11 +33,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/funcref-in-gc-heap-get.wat b/tests/disas/gc/null/funcref-in-gc-heap-get.wat
index 17d1d5dc3b6f..d40bfc421973 100644
--- a/tests/disas/gc/null/funcref-in-gc-heap-get.wat
+++ b/tests/disas/gc/null/funcref-in-gc-heap-get.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:26 sig0
 ;;     stack_limit = gv2
@@ -25,7 +25,7 @@
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0020                               trapz v2, user16
 ;; @0020                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0020                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0020                               v3 = uextend.i64 v2
 ;; @0020                               v6 = iadd v5, v3
 ;; @0020                               v7 = iconst.i64 8
diff --git a/tests/disas/gc/null/funcref-in-gc-heap-new.wat b/tests/disas/gc/null/funcref-in-gc-heap-new.wat
index 5b48d29f8ae7..e36f8141b92d 100644
--- a/tests/disas/gc/null/funcref-in-gc-heap-new.wat
+++ b/tests/disas/gc/null/funcref-in-gc-heap-new.wat
@@ -11,17 +11,17 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     sig1 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:23 sig0
@@ -38,14 +38,14 @@
 ;; @0020                               v3 = iconst.i32 16
 ;; @0020                               v14 = uadd_overflow_trap v13, v3, user18  ; v3 = 16
 ;; @0020                               v16 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0020                               v17 = load.i64 notrap aligned region4 v16+40
+;; @0020                               v17 = load.i64 notrap aligned region4 v16+48
 ;; @0020                               v15 = uextend.i64 v14
 ;; @0020                               v18 = icmp ule v15, v17
 ;; @0020                               brif v18, block2, block3
 ;;
 ;;                                 block2:
 ;;                                     v46 = iconst.i32 -1342177264
-;; @0020                               v22 = load.i64 notrap aligned readonly can_move region5 v16+32
+;; @0020                               v22 = load.i64 notrap aligned readonly can_move region5 v16+40
 ;;                                     v52 = band.i32 v11, v45  ; v45 = -8
 ;;                                     v53 = uextend.i64 v52
 ;; @0020                               v24 = iadd v22, v53
diff --git a/tests/disas/gc/null/funcref-in-gc-heap-set.wat b/tests/disas/gc/null/funcref-in-gc-heap-set.wat
index a54911faed1b..f0c58114849e 100644
--- a/tests/disas/gc/null/funcref-in-gc-heap-set.wat
+++ b/tests/disas/gc/null/funcref-in-gc-heap-set.wat
@@ -11,13 +11,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:25 sig0
 ;;     stack_limit = gv2
@@ -27,7 +27,7 @@
 ;; @0022                               v10 = call fn0(v0, v3)
 ;; @0022                               v11 = ireduce.i32 v10
 ;; @0022                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0022                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0022                               v4 = uextend.i64 v2
 ;; @0022                               v7 = iadd v6, v4
 ;; @0022                               v8 = iconst.i64 8
diff --git a/tests/disas/gc/null/i31ref-globals.wat b/tests/disas/gc/null/i31ref-globals.wat
index d574e45de0c9..a159b140a21b 100644
--- a/tests/disas/gc/null/i31ref-globals.wat
+++ b/tests/disas/gc/null/i31ref-globals.wat
@@ -14,11 +14,11 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -33,11 +33,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/multiple-array-get.wat b/tests/disas/gc/null/multiple-array-get.wat
index 1e6f92646983..edd1766bac90 100644
--- a/tests/disas/gc/null/multiple-array-get.wat
+++ b/tests/disas/gc/null/multiple-array-get.wat
@@ -12,19 +12,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
 ;; @0024                               trapz v2, user16
 ;; @0024                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+32
+;; @0024                               v7 = load.i64 notrap aligned readonly can_move region2 v6+40
 ;; @0024                               v5 = uextend.i64 v2
 ;; @0024                               v8 = iadd v7, v5
 ;; @0024                               v9 = iconst.i64 8
diff --git a/tests/disas/gc/null/multiple-struct-get.wat b/tests/disas/gc/null/multiple-struct-get.wat
index 71ad809cd6f9..8ef89f0e3df6 100644
--- a/tests/disas/gc/null/multiple-struct-get.wat
+++ b/tests/disas/gc/null/multiple-struct-get.wat
@@ -13,19 +13,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32, i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0023                               trapz v2, user16
 ;; @0023                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0023                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0023                               v3 = uextend.i64 v2
 ;; @0023                               v6 = iadd v5, v3
 ;; @0023                               v7 = iconst.i64 8
diff --git a/tests/disas/gc/null/ref-cast.wat b/tests/disas/gc/null/ref-cast.wat
index 5ca5bb1fd7e7..002766330661 100644
--- a/tests/disas/gc/null/ref-cast.wat
+++ b/tests/disas/gc/null/ref-cast.wat
@@ -10,15 +10,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -34,7 +34,7 @@
 ;;
 ;;                                 block3:
 ;; @001e                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001e                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001e                               v12 = uextend.i64 v2
 ;; @001e                               v15 = iadd v14, v12
 ;; @001e                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/null/ref-is-null.wat b/tests/disas/gc/null/ref-is-null.wat
index 64a0d2149a2d..871679282910 100644
--- a/tests/disas/gc/null/ref-is-null.wat
+++ b/tests/disas/gc/null/ref-is-null.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,10 +30,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/ref-test-any.wat b/tests/disas/gc/null/ref-test-any.wat
index bceee0f2a522..852ae02b3658 100644
--- a/tests/disas/gc/null/ref-test-any.wat
+++ b/tests/disas/gc/null/ref-test-any.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,10 +30,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/ref-test-array.wat b/tests/disas/gc/null/ref-test-array.wat
index ac595109e643..f54fbad5bebf 100644
--- a/tests/disas/gc/null/ref-test-array.wat
+++ b/tests/disas/gc/null/ref-test-array.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -31,7 +31,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/null/ref-test-concrete-func-type.wat b/tests/disas/gc/null/ref-test-concrete-func-type.wat
index 9216535a9628..3eacae061124 100644
--- a/tests/disas/gc/null/ref-test-concrete-func-type.wat
+++ b/tests/disas/gc/null/ref-test-concrete-func-type.wat
@@ -10,13 +10,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
 ;;     region4 = 1610612752 "VMFuncRef+0x10"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/gc/null/ref-test-concrete-type.wat b/tests/disas/gc/null/ref-test-concrete-type.wat
index 04eb15fb05c2..57aa99b1c089 100644
--- a/tests/disas/gc/null/ref-test-concrete-type.wat
+++ b/tests/disas/gc/null/ref-test-concrete-type.wat
@@ -10,15 +10,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -34,7 +34,7 @@
 ;;
 ;;                                 block3:
 ;; @001d                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @001d                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @001d                               v12 = uextend.i64 v2
 ;; @001d                               v15 = iadd v14, v12
 ;; @001d                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/null/ref-test-eq.wat b/tests/disas/gc/null/ref-test-eq.wat
index 804206c05d86..6a8c32ae7768 100644
--- a/tests/disas/gc/null/ref-test-eq.wat
+++ b/tests/disas/gc/null/ref-test-eq.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -30,7 +30,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/null/ref-test-i31.wat b/tests/disas/gc/null/ref-test-i31.wat
index e0e3feb08883..e076a1aeaeba 100644
--- a/tests/disas/gc/null/ref-test-i31.wat
+++ b/tests/disas/gc/null/ref-test-i31.wat
@@ -9,10 +9,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/ref-test-none.wat b/tests/disas/gc/null/ref-test-none.wat
index 69f6aa9c650b..f47c89ba0927 100644
--- a/tests/disas/gc/null/ref-test-none.wat
+++ b/tests/disas/gc/null/ref-test-none.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -28,10 +28,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/gc/null/ref-test-struct.wat b/tests/disas/gc/null/ref-test-struct.wat
index 46d36d15fa96..218e9b54b581 100644
--- a/tests/disas/gc/null/ref-test-struct.wat
+++ b/tests/disas/gc/null/ref-test-struct.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -31,7 +31,7 @@
 ;;
 ;;                                 block3:
 ;; @001b                               v11 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+32
+;; @001b                               v12 = load.i64 notrap aligned readonly can_move region2 v11+40
 ;; @001b                               v10 = uextend.i64 v2
 ;; @001b                               v13 = iadd v12, v10
 ;; @001b                               v16 = load.i32 user2 readonly region4 v13
diff --git a/tests/disas/gc/null/struct-get-guard-pages.wat b/tests/disas/gc/null/struct-get-guard-pages.wat
index 06682ff9e4f8..ee03e89e05c3 100644
--- a/tests/disas/gc/null/struct-get-guard-pages.wat
+++ b/tests/disas/gc/null/struct-get-guard-pages.wat
@@ -25,19 +25,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0033                               trapz v2, user16
 ;; @0033                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0033                               v3 = uextend.i64 v2
 ;; @0033                               v6 = iadd v5, v3
 ;; @0033                               v7 = iconst.i64 8
@@ -51,19 +51,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @003c                               trapz v2, user16
 ;; @003c                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @003c                               v3 = uextend.i64 v2
 ;; @003c                               v6 = iadd v5, v3
 ;; @003c                               v7 = iconst.i64 12
@@ -78,19 +78,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0045                               trapz v2, user16
 ;; @0045                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0045                               v3 = uextend.i64 v2
 ;; @0045                               v6 = iadd v5, v3
 ;; @0045                               v7 = iconst.i64 12
@@ -105,19 +105,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @004e                               v3 = uextend.i64 v2
 ;; @004e                               v6 = iadd v5, v3
 ;; @004e                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/null/struct-get-no-guard-pages.wat b/tests/disas/gc/null/struct-get-no-guard-pages.wat
index 52cd3e3f97a5..9c148d22b821 100644
--- a/tests/disas/gc/null/struct-get-no-guard-pages.wat
+++ b/tests/disas/gc/null/struct-get-no-guard-pages.wat
@@ -25,13 +25,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -40,8 +40,8 @@
 ;; @0033                               v4 = iconst.i64 24
 ;; @0033                               v5 = uadd_overflow_trap v3, v4, user2  ; v4 = 24
 ;; @0033                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0033                               v7 = load.i64 notrap aligned region3 v6+40
-;; @0033                               v10 = load.i64 notrap aligned region2 v6+32
+;; @0033                               v7 = load.i64 notrap aligned region3 v6+48
+;; @0033                               v10 = load.i64 notrap aligned region2 v6+40
 ;; @0033                               v8 = icmp ugt v5, v7
 ;; @0033                               v12 = iconst.i64 0
 ;; @0033                               v11 = iadd v10, v3
@@ -57,13 +57,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -72,8 +72,8 @@
 ;; @003c                               v4 = iconst.i64 24
 ;; @003c                               v5 = uadd_overflow_trap v3, v4, user2  ; v4 = 24
 ;; @003c                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003c                               v7 = load.i64 notrap aligned region3 v6+40
-;; @003c                               v10 = load.i64 notrap aligned region2 v6+32
+;; @003c                               v7 = load.i64 notrap aligned region3 v6+48
+;; @003c                               v10 = load.i64 notrap aligned region2 v6+40
 ;; @003c                               v8 = icmp ugt v5, v7
 ;; @003c                               v12 = iconst.i64 0
 ;; @003c                               v11 = iadd v10, v3
@@ -90,13 +90,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -105,8 +105,8 @@
 ;; @0045                               v4 = iconst.i64 24
 ;; @0045                               v5 = uadd_overflow_trap v3, v4, user2  ; v4 = 24
 ;; @0045                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v7 = load.i64 notrap aligned region3 v6+40
-;; @0045                               v10 = load.i64 notrap aligned region2 v6+32
+;; @0045                               v7 = load.i64 notrap aligned region3 v6+48
+;; @0045                               v10 = load.i64 notrap aligned region2 v6+40
 ;; @0045                               v8 = icmp ugt v5, v7
 ;; @0045                               v12 = iconst.i64 0
 ;; @0045                               v11 = iadd v10, v3
@@ -123,13 +123,13 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -138,8 +138,8 @@
 ;; @004e                               v4 = iconst.i64 24
 ;; @004e                               v5 = uadd_overflow_trap v3, v4, user2  ; v4 = 24
 ;; @004e                               v6 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v7 = load.i64 notrap aligned region3 v6+40
-;; @004e                               v10 = load.i64 notrap aligned region2 v6+32
+;; @004e                               v7 = load.i64 notrap aligned region3 v6+48
+;; @004e                               v10 = load.i64 notrap aligned region2 v6+40
 ;; @004e                               v8 = icmp ugt v5, v7
 ;; @004e                               v12 = iconst.i64 0
 ;; @004e                               v11 = iadd v10, v3
diff --git a/tests/disas/gc/null/struct-get.wat b/tests/disas/gc/null/struct-get.wat
index 9bb373d9d10d..d21ed17c3fae 100644
--- a/tests/disas/gc/null/struct-get.wat
+++ b/tests/disas/gc/null/struct-get.wat
@@ -25,19 +25,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0033                               trapz v2, user16
 ;; @0033                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0033                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0033                               v3 = uextend.i64 v2
 ;; @0033                               v6 = iadd v5, v3
 ;; @0033                               v7 = iconst.i64 8
@@ -51,19 +51,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @003c                               trapz v2, user16
 ;; @003c                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @003c                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @003c                               v3 = uextend.i64 v2
 ;; @003c                               v6 = iadd v5, v3
 ;; @003c                               v7 = iconst.i64 12
@@ -78,19 +78,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0045                               trapz v2, user16
 ;; @0045                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0045                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0045                               v3 = uextend.i64 v2
 ;; @0045                               v6 = iadd v5, v3
 ;; @0045                               v7 = iconst.i64 12
@@ -105,19 +105,19 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @004e                               trapz v2, user16
 ;; @004e                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @004e                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @004e                               v3 = uextend.i64 v2
 ;; @004e                               v6 = iadd v5, v3
 ;; @004e                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/null/struct-new-default.wat b/tests/disas/gc/null/struct-new-default.wat
index d3b1a3612f97..0a7cb7a23e63 100644
--- a/tests/disas/gc/null/struct-new-default.wat
+++ b/tests/disas/gc/null/struct-new-default.wat
@@ -13,17 +13,17 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     fn0 = colocated u805306368:23 sig0
 ;;     stack_limit = gv2
@@ -38,14 +38,14 @@
 ;; @0021                               v5 = iconst.i32 24
 ;; @0021                               v16 = uadd_overflow_trap v15, v5, user18  ; v5 = 24
 ;; @0021                               v18 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0021                               v19 = load.i64 notrap aligned region4 v18+40
+;; @0021                               v19 = load.i64 notrap aligned region4 v18+48
 ;; @0021                               v17 = uextend.i64 v16
 ;; @0021                               v20 = icmp ule v17, v19
 ;; @0021                               brif v20, block2, block3
 ;;
 ;;                                 block2:
 ;;                                     v49 = iconst.i32 -1342177256
-;; @0021                               v24 = load.i64 notrap aligned readonly can_move region5 v18+32
+;; @0021                               v24 = load.i64 notrap aligned readonly can_move region5 v18+40
 ;;                                     v55 = band.i32 v13, v48  ; v48 = -8
 ;;                                     v56 = uextend.i64 v55
 ;; @0021                               v26 = iadd v24, v56
diff --git a/tests/disas/gc/null/struct-new.wat b/tests/disas/gc/null/struct-new.wat
index 6ea9bb70e93b..42625f86f3ee 100644
--- a/tests/disas/gc/null/struct-new.wat
+++ b/tests/disas/gc/null/struct-new.wat
@@ -14,18 +14,18 @@
 ;; function u0:0(i64 vmctx, i64, f32, i32, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 939524096 "VMNullHeapData+0x0"
-;;     region4 = 67108904 "VMStoreContext+0x28"
-;;     region5 = 67108896 "VMStoreContext+0x20"
+;;     region4 = 67108912 "VMStoreContext+0x30"
+;;     region5 = 67108904 "VMStoreContext+0x28"
 ;;     region6 = 40 "VMContext+0x28"
 ;;     region7 = 1677721600 "TypeIdsArray+0x0"
 ;;     region8 = 536870912 "GcHeap"
 ;;     region9 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8 tail
 ;;     fn0 = colocated u805306368:23 sig0
 ;;     stack_limit = gv2
@@ -42,14 +42,14 @@
 ;; @002a                               v5 = iconst.i32 24
 ;; @002a                               v16 = uadd_overflow_trap v15, v5, user18  ; v5 = 24
 ;; @002a                               v18 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v19 = load.i64 notrap aligned region4 v18+40
+;; @002a                               v19 = load.i64 notrap aligned region4 v18+48
 ;; @002a                               v17 = uextend.i64 v16
 ;; @002a                               v20 = icmp ule v17, v19
 ;; @002a                               brif v20, block2, block3
 ;;
 ;;                                 block2:
 ;;                                     v53 = iconst.i32 -1342177256
-;; @002a                               v24 = load.i64 notrap aligned readonly can_move region5 v18+32
+;; @002a                               v24 = load.i64 notrap aligned readonly can_move region5 v18+40
 ;;                                     v59 = band.i32 v13, v52  ; v52 = -8
 ;;                                     v60 = uextend.i64 v59
 ;; @002a                               v26 = iadd v24, v60
diff --git a/tests/disas/gc/null/struct-set.wat b/tests/disas/gc/null/struct-set.wat
index 2731a51afa76..79a5c406eca3 100644
--- a/tests/disas/gc/null/struct-set.wat
+++ b/tests/disas/gc/null/struct-set.wat
@@ -21,19 +21,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, f32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
 ;; @0034                               trapz v2, user16
 ;; @0034                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @0034                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @0034                               v4 = uextend.i64 v2
 ;; @0034                               v7 = iadd v6, v4
 ;; @0034                               v8 = iconst.i64 8
@@ -47,19 +47,19 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @003f                               trapz v2, user16
 ;; @003f                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @003f                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @003f                               v4 = uextend.i64 v2
 ;; @003f                               v7 = iadd v6, v4
 ;; @003f                               v8 = iconst.i64 12
@@ -73,19 +73,19 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @004a                               trapz v2, user16
 ;; @004a                               v5 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+32
+;; @004a                               v6 = load.i64 notrap aligned readonly can_move region2 v5+40
 ;; @004a                               v4 = uextend.i64 v2
 ;; @004a                               v7 = iadd v6, v4
 ;; @004a                               v8 = iconst.i64 16
diff --git a/tests/disas/gc/null/v128-fields.wat b/tests/disas/gc/null/v128-fields.wat
index 99d385a6829b..5efe3cd21f35 100644
--- a/tests/disas/gc/null/v128-fields.wat
+++ b/tests/disas/gc/null/v128-fields.wat
@@ -13,19 +13,19 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108896 "VMStoreContext+0x20"
-;;     region3 = 67108904 "VMStoreContext+0x28"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108904 "VMStoreContext+0x28"
+;;     region3 = 67108912 "VMStoreContext+0x30"
 ;;     region4 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0022                               trapz v2, user16
 ;; @0022                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0022                               v5 = load.i64 notrap aligned readonly can_move region2 v4+32
+;; @0022                               v5 = load.i64 notrap aligned readonly can_move region2 v4+40
 ;; @0022                               v3 = uextend.i64 v2
 ;; @0022                               v6 = iadd v5, v3
 ;; @0022                               v7 = iconst.i64 16
diff --git a/tests/disas/gc/ref-test-cast-final-type.wat b/tests/disas/gc/ref-test-cast-final-type.wat
index 384cecc5e9d7..4ef2c0188eb8 100644
--- a/tests/disas/gc/ref-test-cast-final-type.wat
+++ b/tests/disas/gc/ref-test-cast-final-type.wat
@@ -16,15 +16,15 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -40,7 +40,7 @@
 ;;
 ;;                                 block3:
 ;; @0024                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0024                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @0024                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @0024                               v12 = uextend.i64 v2
 ;; @0024                               v15 = iadd v14, v12
 ;; @0024                               v16 = iconst.i64 4
@@ -61,15 +61,15 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 40 "VMContext+0x28"
 ;;     region3 = 1677721600 "TypeIdsArray+0x0"
-;;     region4 = 67108896 "VMStoreContext+0x20"
-;;     region5 = 67108904 "VMStoreContext+0x28"
+;;     region4 = 67108904 "VMStoreContext+0x28"
+;;     region5 = 67108912 "VMStoreContext+0x30"
 ;;     region6 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -85,7 +85,7 @@
 ;;
 ;;                                 block3:
 ;; @002c                               v13 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002c                               v14 = load.i64 notrap aligned readonly can_move region4 v13+32
+;; @002c                               v14 = load.i64 notrap aligned readonly can_move region4 v13+40
 ;; @002c                               v12 = uextend.i64 v2
 ;; @002c                               v15 = iadd v14, v12
 ;; @002c                               v16 = iconst.i64 4
diff --git a/tests/disas/gc/struct-new-default.wat b/tests/disas/gc/struct-new-default.wat
index da7731d5446e..abd57a1b2c87 100644
--- a/tests/disas/gc/struct-new-default.wat
+++ b/tests/disas/gc/struct-new-default.wat
@@ -14,17 +14,17 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -47,7 +47,7 @@
 ;; @0023                               store notrap aligned region3 v60, v7
 ;;                                     v63 = iconst.i32 -1342177246
 ;;                                     v64 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+32
+;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+40
 ;; @0023                               v32 = iadd v65, v15
 ;; @0023                               store user2 region8 v63, v32  ; v63 = -1342177246
 ;;                                     v66 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -65,7 +65,7 @@
 ;; @0023                               v22 = iconst.i32 16
 ;; @0023                               v23 = call fn0(v0, v19, v21, v6, v22)  ; v19 = -1342177246, v6 = 48, v22 = 16
 ;; @0023                               v24 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0023                               v25 = load.i64 notrap aligned readonly can_move region7 v24+32
+;; @0023                               v25 = load.i64 notrap aligned readonly can_move region7 v24+40
 ;; @0023                               v26 = uextend.i64 v23
 ;; @0023                               v27 = iadd v25, v26
 ;; @0023                               jump block4(v23, v27)
diff --git a/tests/disas/gc/struct-new-stack-map.wat b/tests/disas/gc/struct-new-stack-map.wat
index d5806d55e7e5..7411e9b5c290 100644
--- a/tests/disas/gc/struct-new-stack-map.wat
+++ b/tests/disas/gc/struct-new-stack-map.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x40, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0xd7
@@ -36,7 +36,7 @@
 ;;       leal    0x20(%rax), %esi
 ;;       movl    %esi, (%rdx)
 ;;       movq    8(%rbx), %rdx
-;;       movq    0x20(%rdx), %rsi
+;;       movq    0x28(%rdx), %rsi
 ;;       leaq    (%rsi, %rcx), %rdx
 ;;       movl    $0xb0000022, (%rsi, %rcx)
 ;;       movq    0x28(%rbx), %rdi
@@ -66,7 +66,7 @@
 ;;   c2: movq    8(%rbx), %rcx
 ;;       ╰─╼ stack_map: frame_size=48, frame_offsets=[0]
 ;;   c6: movl    %eax, %edx
-;;   c8: addq    0x20(%rcx), %rdx
+;;   c8: addq    0x28(%rcx), %rdx
 ;;   cc: movdqu  8(%rsp), %xmm0
 ;;   d2: jmp     0x80
 ;;   d7: ud2
diff --git a/tests/disas/gc/struct-new.wat b/tests/disas/gc/struct-new.wat
index 13979f7f80ba..34fbb3676259 100644
--- a/tests/disas/gc/struct-new.wat
+++ b/tests/disas/gc/struct-new.wat
@@ -14,18 +14,18 @@
 ;; function u0:0(i64 vmctx, i64, f32, i32, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 32 "VMContext+0x20"
 ;;     region3 = 872415232 "VMCopyingHeapData+0x0"
 ;;     region4 = 872415236 "VMCopyingHeapData+0x4"
 ;;     region5 = 40 "VMContext+0x28"
 ;;     region6 = 1677721600 "TypeIdsArray+0x0"
-;;     region7 = 67108896 "VMStoreContext+0x20"
+;;     region7 = 67108904 "VMStoreContext+0x28"
 ;;     region8 = 536870912 "GcHeap"
 ;;     region9 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:24 sig0
 ;;     stack_limit = gv2
@@ -49,7 +49,7 @@
 ;; @002a                               store notrap aligned region3 v60, v6
 ;;                                     v63 = iconst.i32 -1342177246
 ;;                                     v64 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+32
+;;                                     v65 = load.i64 notrap aligned readonly can_move region7 v64+40
 ;; @002a                               v31 = iadd v65, v14
 ;; @002a                               store user2 region8 v63, v31  ; v63 = -1342177246
 ;;                                     v66 = load.i64 notrap aligned readonly can_move region5 v0+40
@@ -67,7 +67,7 @@
 ;; @002a                               v21 = iconst.i32 16
 ;; @002a                               v22 = call fn0(v0, v18, v20, v5, v21), stack_map=[i32 @ ss0+0]  ; v18 = -1342177246, v5 = 32, v21 = 16
 ;; @002a                               v23 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @002a                               v24 = load.i64 notrap aligned readonly can_move region7 v23+32
+;; @002a                               v24 = load.i64 notrap aligned readonly can_move region7 v23+40
 ;; @002a                               v25 = uextend.i64 v22
 ;; @002a                               v26 = iadd v24, v25
 ;; @002a                               jump block4(v22, v26)
diff --git a/tests/disas/gc/typed-select-and-stack-maps.wat b/tests/disas/gc/typed-select-and-stack-maps.wat
index ae5a98390316..81074a4fa71b 100644
--- a/tests/disas/gc/typed-select-and-stack-maps.wat
+++ b/tests/disas/gc/typed-select-and-stack-maps.wat
@@ -42,13 +42,13 @@
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     ss0 = explicit_slot 4, align = 4
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     region4 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i64, i32) tail
 ;;     stack_limit = gv2
@@ -72,12 +72,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i64, i32) tail
 ;;     stack_limit = gv2
diff --git a/tests/disas/global-get.wat b/tests/disas/global-get.wat
index 6776b51541d1..683da97ea204 100644
--- a/tests/disas/global-get.wat
+++ b/tests/disas/global-get.wat
@@ -32,12 +32,12 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1476395008 "VMGlobalImport+0x0"
 ;;     region3 = 402653184 "PublicGlobal"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -51,12 +51,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1476395008 "VMGlobalImport+0x0"
 ;;     region3 = 402653184 "PublicGlobal"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -70,10 +70,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -86,11 +86,11 @@
 ;;
 ;; function u0:3(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762049 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/globals.wat b/tests/disas/globals.wat
index b9ed85c5df78..f446ba7ffa25 100644
--- a/tests/disas/globals.wat
+++ b/tests/disas/globals.wat
@@ -11,14 +11,14 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     region3 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region4 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region5 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/guest-debugging.wat b/tests/disas/guest-debugging.wat
index 5c269be55632..074e2da70f12 100644
--- a/tests/disas/guest-debugging.wat
+++ b/tests/disas/guest-debugging.wat
@@ -21,7 +21,7 @@
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     ss0 = explicit_slot 28, key = 0
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1543503872 "Stack(ss0)"
 ;;     sig0 = (i64 vmctx, i8) tail
 ;;     sig1 = (i64 vmctx) tail
@@ -39,7 +39,7 @@
 ;; @0019                               v6 = stack_addr.i64 ss0+16
 ;; @0019                               store notrap region2 v4, v6  ; v4 = 0
 ;; @0019                               v7 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @0019                               v8 = load.i64 notrap aligned region1 v7+24
+;; @0019                               v8 = load.i64 notrap aligned region1 v7+32
 ;; @0019                               v9 = get_stack_pointer.i64 
 ;; @0019                               v10 = icmp ult v9, v8
 ;; @0019                               brif v10, block2, block3
diff --git a/tests/disas/i128-cmp.wat b/tests/disas/i128-cmp.wat
index 19fb142a4e91..d878add2bcec 100644
--- a/tests/disas/i128-cmp.wat
+++ b/tests/disas/i128-cmp.wat
@@ -101,10 +101,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -120,10 +120,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -139,10 +139,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -158,10 +158,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -177,10 +177,10 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -196,10 +196,10 @@
 ;;
 ;; function u0:5(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -215,10 +215,10 @@
 ;;
 ;; function u0:6(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
@@ -234,10 +234,10 @@
 ;;
 ;; function u0:7(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
diff --git a/tests/disas/i32-load.wat b/tests/disas/i32-load.wat
index 22c56fe5e8d1..e52db70ecfbb 100644
--- a/tests/disas/i32-load.wat
+++ b/tests/disas/i32-load.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i32-load16-s.wat b/tests/disas/i32-load16-s.wat
index e00f4e0c5983..5b0936eee86e 100644
--- a/tests/disas/i32-load16-s.wat
+++ b/tests/disas/i32-load16-s.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i32-load16-u.wat b/tests/disas/i32-load16-u.wat
index f0dffb1e7d29..053fb603c800 100644
--- a/tests/disas/i32-load16-u.wat
+++ b/tests/disas/i32-load16-u.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i32-load8-s.wat b/tests/disas/i32-load8-s.wat
index 28849cd15455..a0462ac454b9 100644
--- a/tests/disas/i32-load8-s.wat
+++ b/tests/disas/i32-load8-s.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i32-load8-u.wat b/tests/disas/i32-load8-u.wat
index 4764d4ddcf9a..aff2e1c2d332 100644
--- a/tests/disas/i32-load8-u.wat
+++ b/tests/disas/i32-load8-u.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i32-store.wat b/tests/disas/i32-store.wat
index d3ee06cf5129..92b08975f775 100644
--- a/tests/disas/i32-store.wat
+++ b/tests/disas/i32-store.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/i32-store16.wat b/tests/disas/i32-store16.wat
index 6c78b6ceae75..e5cacce05cf5 100644
--- a/tests/disas/i32-store16.wat
+++ b/tests/disas/i32-store16.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/i32-store8.wat b/tests/disas/i32-store8.wat
index 52aac2f740cd..48c591365ad8 100644
--- a/tests/disas/i32-store8.wat
+++ b/tests/disas/i32-store8.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/i64-load.wat b/tests/disas/i64-load.wat
index 4c79eb953cfd..dc4680789898 100644
--- a/tests/disas/i64-load.wat
+++ b/tests/disas/i64-load.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i64-load16-s.wat b/tests/disas/i64-load16-s.wat
index 2a8ce1316837..1234dcb3ba5c 100644
--- a/tests/disas/i64-load16-s.wat
+++ b/tests/disas/i64-load16-s.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i64-load16-u.wat b/tests/disas/i64-load16-u.wat
index 9170210cbd05..f55bed7926d2 100644
--- a/tests/disas/i64-load16-u.wat
+++ b/tests/disas/i64-load16-u.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i64-load8-s.wat b/tests/disas/i64-load8-s.wat
index 9027f8d02c26..842bf832fbbf 100644
--- a/tests/disas/i64-load8-s.wat
+++ b/tests/disas/i64-load8-s.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i64-load8-u.wat b/tests/disas/i64-load8-u.wat
index 3d028d97d719..0bf4cce3d268 100644
--- a/tests/disas/i64-load8-u.wat
+++ b/tests/disas/i64-load8-u.wat
@@ -10,13 +10,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/i64-store.wat b/tests/disas/i64-store.wat
index f534e27bf558..b980b3906281 100644
--- a/tests/disas/i64-store.wat
+++ b/tests/disas/i64-store.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
diff --git a/tests/disas/i64-store16.wat b/tests/disas/i64-store16.wat
index bc655f5c0e24..7cc8e6be05f8 100644
--- a/tests/disas/i64-store16.wat
+++ b/tests/disas/i64-store16.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
diff --git a/tests/disas/i64-store32.wat b/tests/disas/i64-store32.wat
index 35b994316519..d7b1f086e612 100644
--- a/tests/disas/i64-store32.wat
+++ b/tests/disas/i64-store32.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
diff --git a/tests/disas/i64-store8.wat b/tests/disas/i64-store8.wat
index c6f784379bd8..6155a8b9c1ec 100644
--- a/tests/disas/i64-store8.wat
+++ b/tests/disas/i64-store8.wat
@@ -11,13 +11,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
diff --git a/tests/disas/icall-loop.wat b/tests/disas/icall-loop.wat
index 2a3ede41eb9c..63d8da2f6c36 100644
--- a/tests/disas/icall-loop.wat
+++ b/tests/disas/icall-loop.wat
@@ -24,7 +24,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -34,7 +34,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
@@ -79,7 +79,7 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -89,7 +89,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/icall-simd.wat b/tests/disas/icall-simd.wat
index a3945b016eac..07ab3c4f3d22 100644
--- a/tests/disas/icall-simd.wat
+++ b/tests/disas/icall-simd.wat
@@ -10,7 +10,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -20,7 +20,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i8x16) -> i8x16 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/icall.wat b/tests/disas/icall.wat
index 59e082f19300..c8af5d152154 100644
--- a/tests/disas/icall.wat
+++ b/tests/disas/icall.wat
@@ -10,7 +10,7 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, f32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -20,7 +20,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, f32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/idempotent-store.wat b/tests/disas/idempotent-store.wat
index d780f65d023d..9e3cd92e07cc 100644
--- a/tests/disas/idempotent-store.wat
+++ b/tests/disas/idempotent-store.wat
@@ -16,13 +16,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/if-reachability-translation-0.wat b/tests/disas/if-reachability-translation-0.wat
index 65ffbe598482..2f3397e274bb 100644
--- a/tests/disas/if-reachability-translation-0.wat
+++ b/tests/disas/if-reachability-translation-0.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/if-reachability-translation-1.wat b/tests/disas/if-reachability-translation-1.wat
index 1ccdb967ff71..a2c72fecac8b 100644
--- a/tests/disas/if-reachability-translation-1.wat
+++ b/tests/disas/if-reachability-translation-1.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/if-reachability-translation-2.wat b/tests/disas/if-reachability-translation-2.wat
index 0db7d8500753..2e3db0732b5d 100644
--- a/tests/disas/if-reachability-translation-2.wat
+++ b/tests/disas/if-reachability-translation-2.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/if-reachability-translation-3.wat b/tests/disas/if-reachability-translation-3.wat
index 8612a7a235a8..5a74ef8b3c84 100644
--- a/tests/disas/if-reachability-translation-3.wat
+++ b/tests/disas/if-reachability-translation-3.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/if-reachability-translation-4.wat b/tests/disas/if-reachability-translation-4.wat
index 1a9dc2d7a817..505f96db31fc 100644
--- a/tests/disas/if-reachability-translation-4.wat
+++ b/tests/disas/if-reachability-translation-4.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/if-reachability-translation-5.wat b/tests/disas/if-reachability-translation-5.wat
index 5787e178b6e6..bea935122a82 100644
--- a/tests/disas/if-reachability-translation-5.wat
+++ b/tests/disas/if-reachability-translation-5.wat
@@ -17,10 +17,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/if-reachability-translation-6.wat b/tests/disas/if-reachability-translation-6.wat
index 3841b6e0401d..8bb2df03c169 100644
--- a/tests/disas/if-reachability-translation-6.wat
+++ b/tests/disas/if-reachability-translation-6.wat
@@ -17,10 +17,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/if-unreachable-else-params-2.wat b/tests/disas/if-unreachable-else-params-2.wat
index 85dd980ea358..8658a7d5e79c 100644
--- a/tests/disas/if-unreachable-else-params-2.wat
+++ b/tests/disas/if-unreachable-else-params-2.wat
@@ -21,13 +21,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> f64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/if-unreachable-else-params.wat b/tests/disas/if-unreachable-else-params.wat
index 51e7fdc63cee..4cd7b4f5d59e 100644
--- a/tests/disas/if-unreachable-else-params.wat
+++ b/tests/disas/if-unreachable-else-params.wat
@@ -44,13 +44,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/indirect-call-no-caching.wat b/tests/disas/indirect-call-no-caching.wat
index d216ca74abe6..7966cc648bb0 100644
--- a/tests/disas/indirect-call-no-caching.wat
+++ b/tests/disas/indirect-call-no-caching.wat
@@ -22,10 +22,10 @@
  (elem (i32.const 1) func $f1 $f2 $f3))
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -38,10 +38,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -54,10 +54,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -70,7 +70,7 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -80,7 +80,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/intra-module-inlining.wat b/tests/disas/intra-module-inlining.wat
index 7ce3492d267a..db4aea3d0141 100644
--- a/tests/disas/intra-module-inlining.wat
+++ b/tests/disas/intra-module-inlining.wat
@@ -11,10 +11,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -27,13 +27,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8
-;;     gv5 = load.i64 notrap aligned region1 gv4+24
+;;     gv5 = load.i64 notrap aligned region1 gv4+32
 ;;     sig0 = (i64 vmctx, i64) -> i32 tail
 ;;     fn0 = colocated u0:0 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/issue-10929-v128-icmp-egraphs.wat b/tests/disas/issue-10929-v128-icmp-egraphs.wat
index 2d5a3645ae3b..3485ac1e9701 100644
--- a/tests/disas/issue-10929-v128-icmp-egraphs.wat
+++ b/tests/disas/issue-10929-v128-icmp-egraphs.wat
@@ -12,10 +12,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     const0 = 0xffffffffffffffffffffffffffffffff
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/issue-12808.wat b/tests/disas/issue-12808.wat
index 37c57321f5b2..0524e1bd1e9f 100644
--- a/tests/disas/issue-12808.wat
+++ b/tests/disas/issue-12808.wat
@@ -16,7 +16,7 @@
 ;;       subq    $0x30, %rsp
 ;;       movq    %r14, 0x20(%rsp)
 ;;       movq    8(%rdi), %rax
-;;       movq    0x18(%rax), %rax
+;;       movq    0x20(%rax), %rax
 ;;       movq    %rsp, %rcx
 ;;       cmpq    %rax, %rcx
 ;;       jb      0x93
diff --git a/tests/disas/issue-5696.wat b/tests/disas/issue-5696.wat
index f62c4414a93d..67116c8f354b 100644
--- a/tests/disas/issue-5696.wat
+++ b/tests/disas/issue-5696.wat
@@ -11,10 +11,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
index 9c0044b028cf..998bb2f12f0b 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 8d7e52e515f8..d6f2550305d2 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index e4f3720e25d1..5846f180cb38 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
index 4b2d8fa36c12..f1c2842476ab 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index 790a376240f0..a445aa68b091 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 6162b34de48b..072e51b0f6a6 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
index a430bc0e3303..4331b5831b9e 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 667fbc2e2cf5..d2a79cd1ec37 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -50,13 +50,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index be83c3291f0a..dd91284e2cd2 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -50,13 +50,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 307902c2fdc1..f6410ca46d8a 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 984b8504c781..b4c6fffae6d9 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -50,13 +50,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 7825e6dbc195..bb869f65c8c1 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -50,13 +50,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index 73a21952afbe..1e31c3df2558 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index f0e54c33ece6..ab960e560fed 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index b56774e1bf56..9e5f449eb152 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 8f59f5d29620..f63e343ac8ed 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index 246bbbd498b5..735df81c9cd3 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 3563721b32cb..e53153875c3d 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index 9eed6bfaeab8..cb1b40341d61 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 9a3303bdcbe3..be85b7f265ca 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 2bb8f4f5cb5e..dd39cfd754ad 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 8398a318a63a..2844b3d3aa5b 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index 485ed12f6150..fcc71eef14f9 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index ebccfcc2376e..19194d5ecfdb 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
index dbf739b50ea9..ca45c75feb10 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 921f32075c34..2fcb2b2d8a31 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index dca2b258b1be..f65c6c74fcb2 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
index a90dde2a9dc0..c77933923557 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index d0e7cda5bfe7..2f96ed317e2f 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 065be4b82f4a..deaffbf150c8 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
index d68ad81ac26b..567cba555cd0 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 2e9e6bce7b91..68894a401c66 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 12a29fde10b8..20c644ea9ab1 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
index bbaa1989012e..309b64be2bf0 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 05f297b32bc8..6af5a52a9dba 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index ad0cb5594e2e..b48a4b37ccc7 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -49,13 +49,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index eef14e79d3a0..a8b230b1e1ae 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index 025c21933f51..f16dfd53e10a 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 211bafd51e02..02f58a1f53b6 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 3efd391cd213..5a409096bc91 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index 507ede1c3ddf..4e274a627eda 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index ce7779c48c8d..700dc27742a9 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index e77195d7b616..18a734b9f526 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 2495c786e5e2..ee9cefd5302a 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 7d3cbab0ac44..cdcfc526da3a 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 2f31540c4433..6b03809f5282 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index 8713c6e348e7..c4828696df4f 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index ab05e756ad21..429c5234e2f5 100644
--- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
index 9aabcde4096f..d4f1ef64f555 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 678847c1534b..bb8b1f170d71 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index ea86bd149aee..79973ba54a98 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
index 0f94b01c78b1..e607ff648914 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index cb2a1f0d6b4d..a9dc1f9df99e 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index fcb393ad1b77..3e789fbcdac2 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
index 5721a1858619..1421ecb31d8b 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 5172e05d9f1d..5bb817e4cba9 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 988a78c35789..c5b20cb35a80 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 8c4aee640bf6..7cfcf163bbfd 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index a96c34c825c3..36dfb8f98e2d 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 35d887fdcad7..f134b4a18fae 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index 2a1f36ddfdc0..ea995d91a05b 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index 3f90d8527025..22e4575f753e 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 3eb4620bf9fb..ada577ad7eb4 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 2e814f514d46..87ebd1ce503d 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index 7be8641badaa..4df259e502d4 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 17ed8a94b0e2..fdf7b830d49e 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index 8044c78f797f..abfc16527e58 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 95df1bf1c59d..24d6bf0eeaef 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index e905a0b62662..89cef66520dc 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 5edc9f61f379..98f39482df82 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -42,13 +42,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index 2a60284153fe..00603e0cbff7 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 3f00817b31be..f59b21a12567 100644
--- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
index 459299696bb6..903408cd3b2f 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 7fd01d3945ba..ae2150fb2412 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index e54675a931f7..9be1d6b80fd5 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
index de8517a79ecf..edd0e3ef450d 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index 1aa7d20d51b7..51110331811a 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 589727148ec8..5928badb0d83 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
index d3cea2339743..2a3fcfb24b1a 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 876ff32fa570..bf06e6888e67 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 84884a0ecddc..0cd715dac7a4 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 86964227871b..b83f6d8326c2 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 3c1efc83ad8e..48eab22796c2 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index c5b9a07671db..55b04659f1a4 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index ea073317fc18..ed5d4c6903fb 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index 1a3fb048fbd3..f30622d0d2ed 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 613d276457cb..ba215db72dcb 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 1ae5ed273b9c..7254aa095c87 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -44,13 +44,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index dd668aace62c..a1325700374e 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index fc3ca45ece88..9106f3e271c5 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index ccb7665ed1e2..17ae7f31b348 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 4f375f459eb5..36efae26be37 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 15b140e83b3a..800fde08aa8c 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 748ef00c7f8b..02d6a1c0be4d 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -45,13 +45,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index ca8b58e5807b..6e5f9fb3b5c5 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 4956df8b43e4..8e11f4cd4351 100644
--- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,13 +20,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
index ec64806c0660..15f26cd2547f 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index bef7bedb2129..8d51e34e218f 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 1c6cae09a5c4..25fcb389f73b 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -42,7 +42,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
index ae3d14588385..be2be83e01ff 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index c28dce417ead..a75ac1b9c861 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 018b4d914ec7..1745c8bd160b 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -42,7 +42,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
index a3dc3ac91d25..2a3e19cc0248 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -42,7 +42,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 3399c24f20e3..699e73442833 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -43,7 +43,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 8bb5b6f50c94..a848b433f21a 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -46,7 +46,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 947ccb123ea4..8382ac8793f1 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 9c3a9f6d2a68..f54d431b7159 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -43,7 +43,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 4097a5e53e65..5c08d8879869 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -46,7 +46,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index bb5bbaa59520..af830c59474c 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index 159381d67c72..1afc373bd6d3 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 483d35294341..0d54ddd61a08 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 82f549ee8a69..40cb7844040b 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index 2ba47791c56e..e7e5c8994a49 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 0176c1bcca5f..ff7071ad185c 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index 477c6d747e29..768df186722e 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 735ae82e1a83..53771e233205 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index fbb21100e280..7971b170d60d 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -42,7 +42,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 0cfa47715727..a9b447dac1f9 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index 57bfa481b1f0..9849b938bb93 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index ce77cf7a0c98..057a6fdd4947 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -42,7 +42,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
index 09e6aa539608..c1aec1b2bd22 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 42b858149293..0f9a7b4310b2 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index b8509c210fbf..8cb701da4c6a 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
index e61d1b4ff808..7c33380fd6c7 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index b6a6866f2a76..212b1d784644 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 114ba3315523..e2be090a6b5f 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
index de65474408c3..c6e975813b30 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 3d67eefd3bd3..35447e05ca9e 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 16bf0ca7a705..e5408838cb8c 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -43,7 +43,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 229aa053de80..f20f209301ec 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 0097c9fa759c..bb8cb3870f81 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 7d9c0ac17a07..c22f3e5fa5a6 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -43,7 +43,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index e8458db1ca32..5abeffa0c552 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index d62139a13a80..06eae93ac539 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index ce943f1d12c2..cc1a8bc0c368 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 3a25bd59ee7f..7a9ae13d923f 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index f40e2f313fb3..6cb4391974bb 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 4b1ac6e38d08..a13f79d689ba 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index 35496c977e70..3c3cf6498b5e 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 24e12a146304..3cb1eb3c0862 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 7fb26be60329..8af06788c3f2 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 3dd1887fb4d2..a1ef5e4befea 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index 811e88375fab..dd397d956c7b 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index b234605b2837..52315ca5d495 100644
--- a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
index bc1713dee8d7..8965d1055618 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index b269e6755633..7c456e12edd9 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index ff8892f05b72..22aedb78bd4a 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
index 3c545cecab8c..96cc30da2d13 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index 630a93fa9231..c43a3af404cf 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index a739b86a9655..35bee09892fa 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
index 0eeda60bc986..54f4d39dfecc 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index ff369051be30..e3ad2903b59c 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index da54a441ad0f..f5a98b130b8f 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
index a79a0bc9dce4..90397af2eb4d 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 1664e500da16..ebe6dce75047 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 9dab79a09370..55075d8c65b6 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -41,7 +41,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index 45bf164cb7c4..cc7f42187112 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index 7180cee55ae1..46c40998dcd2 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 7c7247699e84..07a53d1944fb 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 4b09dfa79502..b295cb4ac048 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index 032bc28e3f59..2fc365527058 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index 4c00180be48d..387729776edb 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index 691d7fbb6e54..023122669e16 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 59aadb89b8f8..84b4cce935c6 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 9f9579a818c2..628ca388c232 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 8082a99b4ef9..877a5bb19cc9 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -35,7 +35,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index df93df83f3a2..904beeb38aa9 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index b181948e7dff..cbcf798cc69d 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
index 92692cd91972..606b2e123e18 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
index 0b7054e7f377..051b435eace1 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 30b39d14071c..7149a919a338 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
index cd7c4730ad4f..2ad66f26946a 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
index 60caa78cf929..077e10222512 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
index c90862aec147..81f9c85e4634 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
index d82262f0d380..08a11b2f3cae 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
index 5c77a996e0ba..7574f52e5525 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 5008f9aa36ca..927b48f4e925 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
index 0864c43320f4..4bfd9864141e 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
index 1f8f2cfcae42..6e450de64f87 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index dff360de8e10..f021c72bc055 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
index f100752eecef..ef0fa7710b3b 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
index cdc947c58edc..a72f27346fef 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
index 6b3d27757576..031539a1ff57 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
index 690e5a4bd5d5..0f17c4db5cb8 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -36,7 +36,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
index f6ab577c9e60..4ba900073c2b 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
index db2fe252a60c..f5606998baf7 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -37,7 +37,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
index a325faf41da9..327cd71e2e99 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
index 028db52bacd5..7b9c3f3e13a9 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
index 424e1bde5ad5..44cccc5f5ac7 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
index 22ad5a12aead..970460865605 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -38,7 +38,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
index c3ab3e384b12..18d4cd0f4373 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -39,7 +39,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
index 04dccafa52c3..8a0306e69aea 100644
--- a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -20,7 +20,7 @@
 
 ;; wasm[0]::function[0]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -40,7 +40,7 @@
 ;;
 ;; wasm[0]::function[1]:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/memory-copy-epochs.wat b/tests/disas/memory-copy-epochs.wat
index f712972b8774..7928793df84f 100644
--- a/tests/disas/memory-copy-epochs.wat
+++ b/tests/disas/memory-copy-epochs.wat
@@ -10,7 +10,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 24 "VMContext+0x18"
 ;;     region3 = 1744830464 "EpochCounter+0x0"
 ;;     region4 = 67108872 "VMStoreContext+0x8"
@@ -18,7 +18,7 @@
 ;;     region6 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:13 sig0
diff --git a/tests/disas/memory-copy-fuel.wat b/tests/disas/memory-copy-fuel.wat
index 45e72b7043d4..64ad0065be4d 100644
--- a/tests/disas/memory-copy-fuel.wat
+++ b/tests/disas/memory-copy-fuel.wat
@@ -10,13 +10,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 67108864 "VMStoreContext+0x0"
 ;;     region3 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region4 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx) -> i8 tail
 ;;     sig1 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:12 sig0
diff --git a/tests/disas/memory-copy-inline.wat b/tests/disas/memory-copy-inline.wat
index 1f1bf7efac4f..c80074f9d631 100644
--- a/tests/disas/memory-copy-inline.wat
+++ b/tests/disas/memory-copy-inline.wat
@@ -13,13 +13,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/memory-min-max-same.wat b/tests/disas/memory-min-max-same.wat
index 1ddbca1186c5..938a38c375d9 100644
--- a/tests/disas/memory-min-max-same.wat
+++ b/tests/disas/memory-min-max-same.wat
@@ -35,7 +35,7 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1207959576 "VMFunctionImport+0x18"
 ;;     region3 = 1207959560 "VMFunctionImport+0x8"
 ;;     region4 = 603979776 "VMMemoryDefinition+0x0"
@@ -43,7 +43,7 @@
 ;;     region6 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/memory.wat b/tests/disas/memory.wat
index d52b954d4010..6aebe4507e9e 100644
--- a/tests/disas/memory.wat
+++ b/tests/disas/memory.wat
@@ -14,13 +14,13 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/memory_copy_host64.wat b/tests/disas/memory_copy_host64.wat
index af4e249adeb4..6a0e3d2735ce 100644
--- a/tests/disas/memory_copy_host64.wat
+++ b/tests/disas/memory_copy_host64.wat
@@ -51,12 +51,12 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -84,12 +84,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -119,12 +119,12 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -153,12 +153,12 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -183,12 +183,12 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -215,12 +215,12 @@
 ;;
 ;; function u0:5(i64 vmctx, i64, i32, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/memory_fill_host64.wat b/tests/disas/memory_fill_host64.wat
index 48b7d9f600b6..97a2429496a7 100644
--- a/tests/disas/memory_fill_host64.wat
+++ b/tests/disas/memory_fill_host64.wat
@@ -45,12 +45,12 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -74,12 +74,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -101,12 +101,12 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -130,12 +130,12 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i64, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
@@ -157,12 +157,12 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i64) tail
 ;;     fn0 = colocated u805306368:2 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/metadata-for-internal-asserts.wat b/tests/disas/metadata-for-internal-asserts.wat
index f75dba39e0eb..e03aaf264873 100644
--- a/tests/disas/metadata-for-internal-asserts.wat
+++ b/tests/disas/metadata-for-internal-asserts.wat
@@ -22,10 +22,10 @@
 ;;       jne     0x70
 ;;   22: movq    %rbp, %rcx
 ;;       movq    8(%rsi), %rax
-;;       movq    %rcx, 0x30(%rax)
+;;       movq    %rcx, 0x38(%rax)
 ;;       movq    %rbp, %rcx
 ;;       movq    8(%rcx), %rcx
-;;       movq    %rcx, 0x38(%rax)
+;;       movq    %rcx, 0x40(%rax)
 ;;       movq    8(%rdi), %r8
 ;;       leaq    (%rsp), %rdx
 ;;       xorq    %rcx, %rcx
diff --git a/tests/disas/mmu-interruption-aarch64.wat b/tests/disas/mmu-interruption-aarch64.wat
new file mode 100644
index 000000000000..ca555334235e
--- /dev/null
+++ b/tests/disas/mmu-interruption-aarch64.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! flags = ["-Wmmu-interruption=y"]
+
+(module
+  (memory 0)
+  (func)
+)
+;; function u0:0(i64 vmctx, i64) tail {
+;;     region0 = 8 "VMContext+0x8"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108880 "VMStoreContext+0x10"
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001b                               v2 = load.i64 notrap aligned readonly can_move region0 v0+8
+;; @001b                               v3 = load.i64 notrap aligned region2 v2+16
+;; @001b                               dead_load_with_context v3, v0
+;; @001c                               jump block1
+;;
+;;                                 block1:
+;; @001c                               return
+;; }
diff --git a/tests/disas/mmu-interruption-compile-aarch64.wat b/tests/disas/mmu-interruption-compile-aarch64.wat
new file mode 100644
index 000000000000..1c1422e2ec7e
--- /dev/null
+++ b/tests/disas/mmu-interruption-compile-aarch64.wat
@@ -0,0 +1,17 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = ["-Wmmu-interruption=y"]
+
+(module
+  (memory 0)
+  (func)
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x4, [x2, #8]
+;;       ldr     x4, [x4, #0x10]
+;;       mov     x0, x2
+;;       ldr     x9, [x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/mmu-interruption-compile-loop-aarch64.wat b/tests/disas/mmu-interruption-compile-loop-aarch64.wat
new file mode 100644
index 000000000000..ac6edae4eee9
--- /dev/null
+++ b/tests/disas/mmu-interruption-compile-loop-aarch64.wat
@@ -0,0 +1,17 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = ["-Wmmu-interruption=y"]
+
+(module
+  (memory 0)
+  (func (loop (br 0)))
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #8]
+;;       ldr     x5, [x5, #0x10]
+;;       mov     x0, x2
+;;       ldr     x9, [x5]
+;;       ldr     x9, [x5]
+;;       b       #0x18
diff --git a/tests/disas/mmu-interruption-compile-loop.wat b/tests/disas/mmu-interruption-compile-loop.wat
new file mode 100644
index 000000000000..815dd8e6761d
--- /dev/null
+++ b/tests/disas/mmu-interruption-compile-loop.wat
@@ -0,0 +1,19 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = ["-Wmmu-interruption=y"]
+
+;; Nail down codegen for the snippet in mmu_interrupt_check_offsets() test. If
+;; this starts failing, that may need the offsets in its assert reexamined.
+
+(module
+  (memory 0)
+  (func (loop (br 0)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %rsi
+;;       movq    0x10(%rsi), %rsi
+;;       movq    (%rsi), %r10
+;;       movq    (%rsi), %r10
+;;       jmp     0xf
diff --git a/tests/disas/mmu-interruption-compile.wat b/tests/disas/mmu-interruption-compile.wat
new file mode 100644
index 000000000000..10a7498570b1
--- /dev/null
+++ b/tests/disas/mmu-interruption-compile.wat
@@ -0,0 +1,17 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = ["-Wmmu-interruption=y"]
+
+(module
+  (memory 0)
+  (func)
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %rsi
+;;       movq    0x10(%rsi), %rsi
+;;       movq    (%rsi), %r10
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/mmu-interruption.wat b/tests/disas/mmu-interruption.wat
new file mode 100644
index 000000000000..a3beb8c12a4f
--- /dev/null
+++ b/tests/disas/mmu-interruption.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! flags = ["-Wmmu-interruption=y"]
+
+(module
+  (memory 0)
+  (func)
+)
+;; function u0:0(i64 vmctx, i64) tail {
+;;     region0 = 8 "VMContext+0x8"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108880 "VMStoreContext+0x10"
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001b                               v2 = load.i64 notrap aligned readonly can_move region0 v0+8
+;; @001b                               v3 = load.i64 notrap aligned region2 v2+16
+;; @001b                               dead_load_with_context v3, v0
+;; @001c                               jump block1
+;;
+;;                                 block1:
+;; @001c                               return
+;; }
diff --git a/tests/disas/multi-0.wat b/tests/disas/multi-0.wat
index 9d081b8116ea..f2e858814729 100644
--- a/tests/disas/multi-0.wat
+++ b/tests/disas/multi-0.wat
@@ -6,10 +6,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/multi-1.wat b/tests/disas/multi-1.wat
index 37914c4d498d..79812de7c7ad 100644
--- a/tests/disas/multi-1.wat
+++ b/tests/disas/multi-1.wat
@@ -9,10 +9,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i32, i64, f64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
diff --git a/tests/disas/multi-10.wat b/tests/disas/multi-10.wat
index 01f6fe9537e2..c6e27d02cc56 100644
--- a/tests/disas/multi-10.wat
+++ b/tests/disas/multi-10.wat
@@ -13,10 +13,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
diff --git a/tests/disas/multi-11.wat b/tests/disas/multi-11.wat
index 0bd4cb1cefdd..70b8ea7a981d 100644
--- a/tests/disas/multi-11.wat
+++ b/tests/disas/multi-11.wat
@@ -10,10 +10,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/multi-12.wat b/tests/disas/multi-12.wat
index 67f5f6c5f63f..e9692b42fae6 100644
--- a/tests/disas/multi-12.wat
+++ b/tests/disas/multi-12.wat
@@ -12,10 +12,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64):
diff --git a/tests/disas/multi-13.wat b/tests/disas/multi-13.wat
index bb40c3ee7099..ad880695e8f3 100644
--- a/tests/disas/multi-13.wat
+++ b/tests/disas/multi-13.wat
@@ -13,10 +13,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/multi-14.wat b/tests/disas/multi-14.wat
index a0e0f788f9ea..a9bfe5781946 100644
--- a/tests/disas/multi-14.wat
+++ b/tests/disas/multi-14.wat
@@ -13,10 +13,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/multi-15.wat b/tests/disas/multi-15.wat
index 97caeb773d48..b2ca702b182c 100644
--- a/tests/disas/multi-15.wat
+++ b/tests/disas/multi-15.wat
@@ -25,10 +25,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64, f32, f32, i32, f64, f32, i32, i32, i32, f32, f64, f64, f64, i32, i32, f32) -> f64, f32, i32, i32, i32, i64, f32, i32, i32, f32, f64, f64, i32, f32, i32, f64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: f32, v5: f32, v6: i32, v7: f64, v8: f32, v9: i32, v10: i32, v11: i32, v12: f32, v13: f64, v14: f64, v15: f64, v16: i32, v17: i32, v18: f32):
diff --git a/tests/disas/multi-16.wat b/tests/disas/multi-16.wat
index 7fa7cd884718..b95cb4653d0d 100644
--- a/tests/disas/multi-16.wat
+++ b/tests/disas/multi-16.wat
@@ -12,10 +12,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/multi-17.wat b/tests/disas/multi-17.wat
index e57e1de7bd8a..dd532d2bbfd4 100644
--- a/tests/disas/multi-17.wat
+++ b/tests/disas/multi-17.wat
@@ -29,10 +29,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u0:0 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/multi-2.wat b/tests/disas/multi-2.wat
index 2022c2f9949a..76af9af4857f 100644
--- a/tests/disas/multi-2.wat
+++ b/tests/disas/multi-2.wat
@@ -9,10 +9,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
diff --git a/tests/disas/multi-3.wat b/tests/disas/multi-3.wat
index ed9c29c6b663..9840c5e61089 100644
--- a/tests/disas/multi-3.wat
+++ b/tests/disas/multi-3.wat
@@ -16,10 +16,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: i64):
diff --git a/tests/disas/multi-4.wat b/tests/disas/multi-4.wat
index 31c54f3d7708..fe9c2981b506 100644
--- a/tests/disas/multi-4.wat
+++ b/tests/disas/multi-4.wat
@@ -16,10 +16,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: i64):
diff --git a/tests/disas/multi-5.wat b/tests/disas/multi-5.wat
index a53e9b689435..eeedca24a540 100644
--- a/tests/disas/multi-5.wat
+++ b/tests/disas/multi-5.wat
@@ -14,10 +14,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/multi-6.wat b/tests/disas/multi-6.wat
index 1a3a072ab9b2..605e4f9b297c 100644
--- a/tests/disas/multi-6.wat
+++ b/tests/disas/multi-6.wat
@@ -14,10 +14,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/multi-7.wat b/tests/disas/multi-7.wat
index 297215109bec..11ff2f8f4aaa 100644
--- a/tests/disas/multi-7.wat
+++ b/tests/disas/multi-7.wat
@@ -12,10 +12,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
diff --git a/tests/disas/multi-8.wat b/tests/disas/multi-8.wat
index d971947d4cf9..fa9aeeecb300 100644
--- a/tests/disas/multi-8.wat
+++ b/tests/disas/multi-8.wat
@@ -15,10 +15,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
diff --git a/tests/disas/multi-9.wat b/tests/disas/multi-9.wat
index 55b992eaebe7..003d537d3cd6 100644
--- a/tests/disas/multi-9.wat
+++ b/tests/disas/multi-9.wat
@@ -18,10 +18,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
diff --git a/tests/disas/non-fixed-size-memory.wat b/tests/disas/non-fixed-size-memory.wat
index 871c6a693ebf..17fb507960fd 100644
--- a/tests/disas/non-fixed-size-memory.wat
+++ b/tests/disas/non-fixed-size-memory.wat
@@ -22,13 +22,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
@@ -47,13 +47,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/nullref.wat b/tests/disas/nullref.wat
index 8f2ab7b1f3c6..1c0fd3b586c7 100644
--- a/tests/disas/nullref.wat
+++ b/tests/disas/nullref.wat
@@ -14,10 +14,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -30,10 +30,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/passive-data.wat b/tests/disas/passive-data.wat
index 0cd07c1e5ab3..075453b38a54 100644
--- a/tests/disas/passive-data.wat
+++ b/tests/disas/passive-data.wat
@@ -15,14 +15,14 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 152 "VMContext+0x98"
 ;;     region5 = 144 "VMContext+0x90"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i64, i64) tail
 ;;     fn0 = colocated u805306368:1 sig0
 ;;     stack_limit = gv2
@@ -63,11 +63,11 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 152 "VMContext+0x98"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/pic.wat b/tests/disas/pic.wat
index 420514c066c7..8f05b840d59e 100644
--- a/tests/disas/pic.wat
+++ b/tests/disas/pic.wat
@@ -49,13 +49,13 @@
 )
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -71,7 +71,7 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     region3 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region4 = 603979784 "VMMemoryDefinition+0x8"
@@ -80,7 +80,7 @@
 ;;     region7 = 1207959560 "VMFunctionImport+0x8"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32) tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/pr2303.wat b/tests/disas/pr2303.wat
index 6a4e91f1cdc1..6a44cc453c97 100644
--- a/tests/disas/pr2303.wat
+++ b/tests/disas/pr2303.wat
@@ -18,13 +18,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 134217728 "PublicMemory"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/pr2559.wat b/tests/disas/pr2559.wat
index abca108c8ee3..e06356c368de 100644
--- a/tests/disas/pr2559.wat
+++ b/tests/disas/pr2559.wat
@@ -54,10 +54,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail
 ;;     fn0 = colocated u0:0 sig0
 ;;     stack_limit = gv2
@@ -96,10 +96,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail
 ;;     fn0 = colocated u0:1 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/pulley-entry-trampoline.wat b/tests/disas/pulley-entry-trampoline.wat
index 06f18fd4c9b1..c09a2b77f361 100644
--- a/tests/disas/pulley-entry-trampoline.wat
+++ b/tests/disas/pulley-entry-trampoline.wat
@@ -8,11 +8,11 @@
 ;;       push_frame_save 144, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, sp, spilltmp0
 ;;       xmov_fp x12
 ;;       xload64le_o32 x15, x0, 8
-;;       xstore64le_o32 x15, 72, x12
+;;       xstore64le_o32 x15, 80, x12
 ;;       xmov x13, sp
-;;       xstore64le_o32 x15, 64, x13
+;;       xstore64le_o32 x15, 72, x13
 ;;       xpcadd x14, 0x23    // target = 0x47
-;;       xstore64le_o32 x15, 80, x14
+;;       xstore64le_o32 x15, 88, x14
 ;;       xstore64le_o32 sp, 0, x15
 ;;       call -0x3a    // target = 0x0
 ;;       ├─╼ exception frame offset: SP = FP - 0x90
@@ -22,7 +22,7 @@
 ;;       ret
 ;;   47: xone x0
 ;;   49: xload64le_o32 x15, sp, 0
-;;   50: xstore64le_o32 x15, 136, x0
+;;   50: xstore64le_o32 x15, 144, x0
 ;;   57: xzero x0
 ;;   59: pop_frame_restore 144, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, sp, spilltmp0
 ;;   5e: ret
diff --git a/tests/disas/readonly-funcrefs.wat b/tests/disas/readonly-funcrefs.wat
index bb9fc978a844..3312306a4bbb 100644
--- a/tests/disas/readonly-funcrefs.wat
+++ b/tests/disas/readonly-funcrefs.wat
@@ -20,10 +20,10 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -35,7 +35,7 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 40 "VMContext+0x28"
@@ -45,7 +45,7 @@
 ;;     region8 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
diff --git a/tests/disas/readonly-heap-base-pointer1.wat b/tests/disas/readonly-heap-base-pointer1.wat
index 4c7b3ff4e8ca..09c0b1962951 100644
--- a/tests/disas/readonly-heap-base-pointer1.wat
+++ b/tests/disas/readonly-heap-base-pointer1.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/readonly-heap-base-pointer2.wat b/tests/disas/readonly-heap-base-pointer2.wat
index f870bcd2eca5..fe168b7fc5bd 100644
--- a/tests/disas/readonly-heap-base-pointer2.wat
+++ b/tests/disas/readonly-heap-base-pointer2.wat
@@ -9,14 +9,14 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 48 "VMContext+0x30"
 ;;     region3 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region4 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region5 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/readonly-heap-base-pointer3.wat b/tests/disas/readonly-heap-base-pointer3.wat
index 18f0e9a525d1..87ebdf40781c 100644
--- a/tests/disas/readonly-heap-base-pointer3.wat
+++ b/tests/disas/readonly-heap-base-pointer3.wat
@@ -9,13 +9,13 @@
 )
 ;; function u0:0(i64 vmctx, i64, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i64):
diff --git a/tests/disas/ref-func-0.wat b/tests/disas/ref-func-0.wat
index 4e03d79ee7fe..dad8470cc21d 100644
--- a/tests/disas/ref-func-0.wat
+++ b/tests/disas/ref-func-0.wat
@@ -15,11 +15,11 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32, i32, i64, i64 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 402653184 "PublicGlobal"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/riscv64-component-builtins-asm.wat b/tests/disas/riscv64-component-builtins-asm.wat
index 9a71f7ea3047..fe2ea10d6b7d 100644
--- a/tests/disas/riscv64-component-builtins-asm.wat
+++ b/tests/disas/riscv64-component-builtins-asm.wat
@@ -23,9 +23,9 @@
 ;;       mv      s8, a2
 ;;       mv      a3, s0
 ;;       ld      a1, 8(a1)
-;;       sd      a3, 0x30(a1)
+;;       sd      a3, 0x38(a1)
 ;;       ld      a2, 8(s0)
-;;       sd      a2, 0x38(a1)
+;;       sd      a2, 0x40(a1)
 ;;       lw      a1, 0x20(a0)
 ;;       sext.w  a1, a1
 ;;       bnez    a1, 8
diff --git a/tests/disas/riscv64-component-builtins.wat b/tests/disas/riscv64-component-builtins.wat
index 03db5c955811..9b32a2ceccf4 100644
--- a/tests/disas/riscv64-component-builtins.wat
+++ b/tests/disas/riscv64-component-builtins.wat
@@ -12,8 +12,8 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108912 "VMStoreContext+0x30"
-;;     region2 = 67108920 "VMStoreContext+0x38"
+;;     region1 = 67108920 "VMStoreContext+0x38"
+;;     region2 = 67108928 "VMStoreContext+0x40"
 ;;     region3 = 738197536 "VMComponentContext+0x20"
 ;;     region4 = 738197512 "VMComponentContext+0x8"
 ;;     region5 = 1879048208 "ComponentBuiltinFunctionsArray+0x10"
@@ -25,9 +25,9 @@
 ;; block0(v0: i64, v1: i64, v2: i32):
 ;;     v4 = get_frame_pointer.i64 
 ;;     v3 = load.i64 notrap aligned readonly can_move region0 v1+8
-;;     store notrap aligned region1 v4, v3+48
+;;     store notrap aligned region1 v4, v3+56
 ;;     v5 = get_return_address.i64 
-;;     store notrap aligned region2 v5, v3+56
+;;     store notrap aligned region2 v5, v3+64
 ;;     v6 = load.i32 notrap aligned region3 v0+32
 ;;     trapz v6, user26
 ;;     v9 = load.i64 notrap aligned readonly region4 v0+8
diff --git a/tests/disas/riscv64-entry-trampoline.wat b/tests/disas/riscv64-entry-trampoline.wat
index 620f6cab6c51..36c1aa27e805 100644
--- a/tests/disas/riscv64-entry-trampoline.wat
+++ b/tests/disas/riscv64-entry-trampoline.wat
@@ -35,12 +35,12 @@
 ;;       fsd     fs11, 0x18(sp)
 ;;       mv      a2, s0
 ;;       ld      a5, 8(a0)
-;;       sd      a2, 0x48(a5)
+;;       sd      a2, 0x50(a5)
 ;;       mv      a3, sp
-;;       sd      a3, 0x40(a5)
+;;       sd      a3, 0x48(a5)
 ;;       auipc   a4, 0
 ;;       addi    a4, a4, 0x8c
-;;       sd      a4, 0x50(a5)
+;;       sd      a4, 0x58(a5)
 ;;       sd      a5, 0(sp)
 ;;       auipc   ra, 0
 ;;       jalr    ra, ra, -0xb4
@@ -77,7 +77,7 @@
 ;;       ret
 ;;       addi    a0, zero, 1
 ;;       ld      a5, 0(sp)
-;;       sd      a0, 0x88(a5)
+;;       sd      a0, 0x90(a5)
 ;;       mv      a0, zero
 ;;       ld      s0, 0xc8(sp)
 ;;       ld      s1, 0xc0(sp)
diff --git a/tests/disas/s390x-entry-trampoline.wat b/tests/disas/s390x-entry-trampoline.wat
index 1e0d78fc8443..5bce383b1050 100644
--- a/tests/disas/s390x-entry-trampoline.wat
+++ b/tests/disas/s390x-entry-trampoline.wat
@@ -19,11 +19,11 @@
 ;;       std     %f15, 0xe0(%r15)
 ;;       lg      %r4, 0(%r15)
 ;;       lg      %r5, 8(%r2)
-;;       stg     %r4, 0x48(%r5)
+;;       stg     %r4, 0x50(%r5)
 ;;       lgr     %r4, %r15
-;;       stg     %r4, 0x40(%r5)
+;;       stg     %r4, 0x48(%r5)
 ;;       larl    %r4, 0xc4
-;;       stg     %r4, 0x50(%r5)
+;;       stg     %r4, 0x58(%r5)
 ;;       stg     %r5, 0xa0(%r15)
 ;;       brasl   %r14, 0
 ;;       ├─╼ exception frame offset: SP = FP - 0xe8
@@ -40,7 +40,7 @@
 ;;       lmg     %r6, %r15, 0x118(%r15)
 ;;       br      %r14
 ;;       lg      %r5, 0xa0(%r15)
-;;       mvghi   0x88(%r5), 1
+;;       mvghi   0x90(%r5), 1
 ;;       lhi     %r2, 0
 ;;       ld      %f8, 0xa8(%r15)
 ;;       ld      %f9, 0xb0(%r15)
diff --git a/tests/disas/s390x-wide-arithmetic.wat b/tests/disas/s390x-wide-arithmetic.wat
index 46de629ddff5..e2415120302a 100644
--- a/tests/disas/s390x-wide-arithmetic.wat
+++ b/tests/disas/s390x-wide-arithmetic.wat
@@ -46,7 +46,7 @@
 
 ;; wasm[0]::function[0]::add128:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -63,7 +63,7 @@
 ;;
 ;; wasm[0]::function[1]::sub128:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -80,7 +80,7 @@
 ;;
 ;; wasm[0]::function[2]::signed:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -96,7 +96,7 @@
 ;;
 ;; wasm[0]::function[3]::unsigned:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -113,7 +113,7 @@
 ;;
 ;; wasm[0]::function[4]::signed_only_high:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
@@ -129,7 +129,7 @@
 ;;
 ;; wasm[0]::function[5]::unsigned_only_high:
 ;;       lg      %r1, 8(%r2)
-;;       lg      %r1, 0x18(%r1)
+;;       lg      %r1, 0x20(%r1)
 ;;       la      %r1, 0xa0(%r1)
 ;;       clgrtle %r15, %r1
 ;;       stmg    %r14, %r15, 0x70(%r15)
diff --git a/tests/disas/select.wat b/tests/disas/select.wat
index ec9e0a157be8..e2f7f739a56d 100644
--- a/tests/disas/select.wat
+++ b/tests/disas/select.wat
@@ -22,10 +22,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -41,10 +41,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -60,10 +60,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/simd-store.wat b/tests/disas/simd-store.wat
index ae9ed774cded..f292eb408fe2 100644
--- a/tests/disas/simd-store.wat
+++ b/tests/disas/simd-store.wat
@@ -86,13 +86,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -110,13 +110,13 @@
 ;;
 ;; function u0:10(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -136,13 +136,13 @@
 ;;
 ;; function u0:11(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -162,13 +162,13 @@
 ;;
 ;; function u0:12(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -186,13 +186,13 @@
 ;;
 ;; function u0:13(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -212,13 +212,13 @@
 ;;
 ;; function u0:14(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -238,13 +238,13 @@
 ;;
 ;; function u0:15(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -262,13 +262,13 @@
 ;;
 ;; function u0:16(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -288,13 +288,13 @@
 ;;
 ;; function u0:17(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -314,13 +314,13 @@
 ;;
 ;; function u0:18(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -340,13 +340,13 @@
 ;;
 ;; function u0:19(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -364,13 +364,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -390,13 +390,13 @@
 ;;
 ;; function u0:20(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -416,13 +416,13 @@
 ;;
 ;; function u0:21(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -442,13 +442,13 @@
 ;;
 ;; function u0:22(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -468,13 +468,13 @@
 ;;
 ;; function u0:23(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -494,13 +494,13 @@
 ;;
 ;; function u0:24(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -520,13 +520,13 @@
 ;;
 ;; function u0:25(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -546,13 +546,13 @@
 ;;
 ;; function u0:26(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -572,13 +572,13 @@
 ;;
 ;; function u0:27(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -598,13 +598,13 @@
 ;;
 ;; function u0:28(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -624,13 +624,13 @@
 ;;
 ;; function u0:29(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -650,13 +650,13 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -676,13 +676,13 @@
 ;;
 ;; function u0:30(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -702,13 +702,13 @@
 ;;
 ;; function u0:31(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -728,13 +728,13 @@
 ;;
 ;; function u0:32(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -754,13 +754,13 @@
 ;;
 ;; function u0:33(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -780,13 +780,13 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -806,13 +806,13 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -830,13 +830,13 @@
 ;;
 ;; function u0:5(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -856,13 +856,13 @@
 ;;
 ;; function u0:6(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -882,13 +882,13 @@
 ;;
 ;; function u0:7(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -908,13 +908,13 @@
 ;;
 ;; function u0:8(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
@@ -932,13 +932,13 @@
 ;;
 ;; function u0:9(i64 vmctx, i64, i8x16) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 603979776 "VMMemoryDefinition+0x0"
 ;;     region3 = 603979784 "VMMemoryDefinition+0x8"
 ;;     region4 = 201326592 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i8x16):
diff --git a/tests/disas/simd.wat b/tests/disas/simd.wat
index 3eb80c5e816e..23f4107ae3cc 100644
--- a/tests/disas/simd.wat
+++ b/tests/disas/simd.wat
@@ -32,10 +32,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -50,10 +50,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     const0 = 0x00000000000000000000000000000000
 ;;     stack_limit = gv2
 ;;
@@ -71,10 +71,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     const0 = 0x00000004000000030000000200000001
 ;;     stack_limit = gv2
 ;;
@@ -90,10 +90,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     const0 = 0x00000000000000000000000000000000
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/simple.wat b/tests/disas/simple.wat
index c2b9233b42ab..40bfb2016a08 100644
--- a/tests/disas/simple.wat
+++ b/tests/disas/simple.wat
@@ -20,10 +20,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -37,10 +37,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -51,10 +51,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/stack-switching/resume-suspend-data-passing.wat b/tests/disas/stack-switching/resume-suspend-data-passing.wat
index 711af71c7cac..23729ff6b22c 100644
--- a/tests/disas/stack-switching/resume-suspend-data-passing.wat
+++ b/tests/disas/stack-switching/resume-suspend-data-passing.wat
@@ -40,13 +40,13 @@
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     ss0 = explicit_slot 16, align = 65536
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108952 "VMStoreContext+0x58"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108960 "VMStoreContext+0x60"
 ;;     region3 = 1073741824 "VMContRef+0x0"
 ;;     region4 = 1140850688 "ContinuationStackMemory+0x0"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -62,8 +62,8 @@
 ;; @0040                               jump block2(v3)  ; v3 = 10
 ;;
 ;;                                 block2(v4: i32):
-;; @0044                               v8 = load.i64 notrap aligned region2 v7+88
-;; @0044                               v9 = load.i64 notrap aligned region2 v7+96
+;; @0044                               v8 = load.i64 notrap aligned region2 v7+96
+;; @0044                               v9 = load.i64 notrap aligned region2 v7+104
 ;; @0044                               v12 = iconst.i64 1
 ;; @0044                               v16 = iconst.i64 24
 ;; @003a                               v2 = iconst.i32 0
@@ -151,14 +151,14 @@
 ;; function u0:1(i64 vmctx, i64) tail {
 ;;     ss0 = explicit_slot 8, align = 256
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1073741824 "VMContRef+0x0"
-;;     region3 = 67108952 "VMStoreContext+0x58"
-;;     region4 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108960 "VMStoreContext+0x60"
+;;     region4 = 67108944 "VMStoreContext+0x50"
 ;;     region5 = 1140850688 "ContinuationStackMemory+0x0"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:6 sig0
@@ -209,15 +209,15 @@
 ;;                                     v125 = iadd v20, v124  ; v124 = 1
 ;; @0062                               store notrap aligned region2 v125, v15+72
 ;; @0062                               v24 = load.i64 notrap aligned region2 v15+64
-;; @0062                               v26 = load.i64 notrap aligned region3 v25+88
-;; @0062                               v27 = load.i64 notrap aligned region3 v25+96
+;; @0062                               v26 = load.i64 notrap aligned region3 v25+96
+;; @0062                               v27 = load.i64 notrap aligned region3 v25+104
 ;; @0062                               store notrap aligned region2 v26, v24+48
 ;; @0062                               store notrap aligned region2 v27, v24+56
 ;;                                     v126 = iconst.i64 0
 ;; @0062                               store notrap aligned region2 v126, v15+64  ; v126 = 0
 ;;                                     v127 = iconst.i64 2
-;; @0062                               store notrap aligned region3 v127, v25+88  ; v127 = 2
-;; @0062                               store notrap aligned region3 v15, v25+96
+;; @0062                               store notrap aligned region3 v127, v25+96  ; v127 = 2
+;; @0062                               store notrap aligned region3 v15, v25+104
 ;;                                     v128 = iconst.i32 1
 ;;                                     v129 = iconst.i64 16
 ;;                                     v130 = iadd v15, v129  ; v129 = 16
@@ -225,14 +225,14 @@
 ;;                                     v131 = iconst.i32 2
 ;;                                     v132 = iadd v27, v129  ; v129 = 16
 ;; @0062                               store notrap aligned region2 v131, v132  ; v131 = 2
-;; @0062                               v42 = load.i64 notrap aligned region4 v25+72
+;; @0062                               v42 = load.i64 notrap aligned region4 v25+80
 ;; @0062                               store notrap aligned region2 v42, v27+8
-;; @0062                               v43 = load.i64 notrap aligned region1 v25+24
+;; @0062                               v43 = load.i64 notrap aligned region1 v25+32
 ;; @0062                               store notrap aligned region2 v43, v27
 ;; @0062                               v46 = load.i64 notrap aligned region2 v15
-;; @0062                               store notrap aligned region1 v46, v25+24
+;; @0062                               store notrap aligned region1 v46, v25+32
 ;; @0062                               v47 = load.i64 notrap aligned region2 v15+8
-;; @0062                               store notrap aligned region4 v47, v25+72
+;; @0062                               store notrap aligned region4 v47, v25+80
 ;;                                     v133 = iconst.i64 24
 ;;                                     v134 = iadd v27, v133  ; v133 = 24
 ;; @0062                               store notrap aligned region2 v128, v134+4  ; v128 = 1
@@ -248,10 +248,10 @@
 ;;                                     v139 = iadd v62, v138  ; v138 = -24
 ;;                                     v140 = iconst.i64 0x0001_0000_0000
 ;; @0062                               v65 = stack_switch v139, v139, v140  ; v140 = 0x0001_0000_0000
-;; @0062                               v67 = load.i64 notrap aligned region3 v25+88
-;; @0062                               v68 = load.i64 notrap aligned region3 v25+96
-;; @0062                               store notrap aligned region3 v26, v25+88
-;; @0062                               store notrap aligned region3 v27, v25+96
+;; @0062                               v67 = load.i64 notrap aligned region3 v25+96
+;; @0062                               v68 = load.i64 notrap aligned region3 v25+104
+;; @0062                               store notrap aligned region3 v26, v25+96
+;; @0062                               store notrap aligned region3 v27, v25+104
 ;; @0062                               store notrap aligned region2 v128, v132  ; v128 = 1
 ;;                                     v141 = iconst.i32 0
 ;; @0062                               store notrap aligned region2 v141, v134  ; v141 = 0
@@ -263,12 +263,12 @@
 ;; @0062                               brif v143, block7, block6
 ;;
 ;;                                 block7:
-;; @0062                               v82 = load.i64 notrap aligned region4 v25+72
+;; @0062                               v82 = load.i64 notrap aligned region4 v25+80
 ;; @0062                               store notrap aligned region2 v82, v68+8
 ;; @0062                               v85 = load.i64 notrap aligned region2 v27
-;; @0062                               store notrap aligned region1 v85, v25+24
+;; @0062                               store notrap aligned region1 v85, v25+32
 ;; @0062                               v86 = load.i64 notrap aligned region2 v27+8
-;; @0062                               store notrap aligned region4 v86, v25+72
+;; @0062                               store notrap aligned region4 v86, v25+80
 ;; @0062                               v88 = load.i64 notrap aligned region2 v68+72
 ;; @0062                               jump block8
 ;;
@@ -290,9 +290,9 @@
 ;;
 ;;                                 block6:
 ;; @0062                               v102 = load.i64 notrap aligned region2 v27
-;; @0062                               store notrap aligned region1 v102, v25+24
+;; @0062                               store notrap aligned region1 v102, v25+32
 ;; @0062                               v103 = load.i64 notrap aligned region2 v27+8
-;; @0062                               store notrap aligned region4 v103, v25+72
+;; @0062                               store notrap aligned region4 v103, v25+80
 ;; @0062                               v106 = iconst.i32 4
 ;;                                     v144 = iconst.i64 16
 ;;                                     v145 = iadd.i64 v68, v144  ; v144 = 16
diff --git a/tests/disas/stack-switching/resume-suspend.wat b/tests/disas/stack-switching/resume-suspend.wat
index e5b18c0926ba..11513389a1f8 100644
--- a/tests/disas/stack-switching/resume-suspend.wat
+++ b/tests/disas/stack-switching/resume-suspend.wat
@@ -24,19 +24,19 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
-;;     region2 = 67108952 "VMStoreContext+0x58"
+;;     region1 = 67108896 "VMStoreContext+0x20"
+;;     region2 = 67108960 "VMStoreContext+0x60"
 ;;     region3 = 1073741824 "VMContRef+0x0"
 ;;     region4 = 1140850688 "ContinuationStackMemory+0x0"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
 ;; @003b                               v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003b                               v5 = load.i64 notrap aligned region2 v4+88
-;; @003b                               v6 = load.i64 notrap aligned region2 v4+96
+;; @003b                               v5 = load.i64 notrap aligned region2 v4+96
+;; @003b                               v6 = load.i64 notrap aligned region2 v4+104
 ;; @003b                               v9 = iconst.i64 1
 ;; @003b                               v13 = iconst.i64 24
 ;; @003b                               v17 = iconst.i32 0
@@ -112,14 +112,14 @@
 ;; function u0:1(i64 vmctx, i64) tail {
 ;;     ss0 = explicit_slot 8, align = 256
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1073741824 "VMContRef+0x0"
-;;     region3 = 67108952 "VMStoreContext+0x58"
-;;     region4 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108960 "VMStoreContext+0x60"
+;;     region4 = 67108944 "VMStoreContext+0x50"
 ;;     region5 = 1140850688 "ContinuationStackMemory+0x0"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:6 sig0
@@ -153,15 +153,15 @@
 ;; @004e                               store notrap aligned region2 v29, v134+72
 ;; @004e                               v30 = load.i64 notrap aligned region2 v134+64
 ;; @004e                               v31 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004e                               v32 = load.i64 notrap aligned region3 v31+88
-;; @004e                               v33 = load.i64 notrap aligned region3 v31+96
+;; @004e                               v32 = load.i64 notrap aligned region3 v31+96
+;; @004e                               v33 = load.i64 notrap aligned region3 v31+104
 ;; @004e                               store notrap aligned region2 v32, v30+48
 ;; @004e                               store notrap aligned region2 v33, v30+56
 ;; @0040                               v2 = iconst.i64 0
 ;; @004e                               store notrap aligned region2 v2, v134+64  ; v2 = 0
 ;; @004e                               v35 = iconst.i64 2
-;; @004e                               store notrap aligned region3 v35, v31+88  ; v35 = 2
-;; @004e                               store notrap aligned region3 v134, v31+96
+;; @004e                               store notrap aligned region3 v35, v31+96  ; v35 = 2
+;; @004e                               store notrap aligned region3 v134, v31+104
 ;; @004e                               v39 = iconst.i32 1
 ;; @004e                               v40 = iconst.i64 16
 ;; @004e                               v41 = iadd v134, v40  ; v40 = 16
@@ -169,14 +169,14 @@
 ;; @004e                               v42 = iconst.i32 2
 ;; @004e                               v44 = iadd v33, v40  ; v40 = 16
 ;; @004e                               store notrap aligned region2 v42, v44  ; v42 = 2
-;; @004e                               v48 = load.i64 notrap aligned region4 v31+72
+;; @004e                               v48 = load.i64 notrap aligned region4 v31+80
 ;; @004e                               store notrap aligned region2 v48, v33+8
-;; @004e                               v49 = load.i64 notrap aligned region1 v31+24
+;; @004e                               v49 = load.i64 notrap aligned region1 v31+32
 ;; @004e                               store notrap aligned region2 v49, v33
 ;; @004e                               v52 = load.i64 notrap aligned region2 v134
-;; @004e                               store notrap aligned region1 v52, v31+24
+;; @004e                               store notrap aligned region1 v52, v31+32
 ;; @004e                               v53 = load.i64 notrap aligned region2 v134+8
-;; @004e                               store notrap aligned region4 v53, v31+72
+;; @004e                               store notrap aligned region4 v53, v31+80
 ;; @004e                               v54 = iconst.i64 24
 ;; @004e                               v55 = iadd v33, v54  ; v54 = 24
 ;; @004e                               store notrap aligned region2 v39, v55+4  ; v39 = 1
@@ -194,10 +194,10 @@
 ;; @004e                               v70 = iadd v68, v69  ; v69 = -24
 ;;                                     v138 = iconst.i64 0x0001_0000_0000
 ;; @004e                               v71 = stack_switch v70, v70, v138  ; v138 = 0x0001_0000_0000
-;; @004e                               v73 = load.i64 notrap aligned region3 v31+88
-;; @004e                               v74 = load.i64 notrap aligned region3 v31+96
-;; @004e                               store notrap aligned region3 v32, v31+88
-;; @004e                               store notrap aligned region3 v33, v31+96
+;; @004e                               v73 = load.i64 notrap aligned region3 v31+96
+;; @004e                               v74 = load.i64 notrap aligned region3 v31+104
+;; @004e                               store notrap aligned region3 v32, v31+96
+;; @004e                               store notrap aligned region3 v33, v31+104
 ;; @004e                               store notrap aligned region2 v39, v44  ; v39 = 1
 ;;                                     v141 = iconst.i32 0
 ;; @004e                               store notrap aligned region2 v141, v55  ; v141 = 0
@@ -209,12 +209,12 @@
 ;; @004e                               brif v83, block5, block4
 ;;
 ;;                                 block5:
-;; @004e                               v88 = load.i64 notrap aligned region4 v31+72
+;; @004e                               v88 = load.i64 notrap aligned region4 v31+80
 ;; @004e                               store notrap aligned region2 v88, v74+8
 ;; @004e                               v91 = load.i64 notrap aligned region2 v33
-;; @004e                               store notrap aligned region1 v91, v31+24
+;; @004e                               store notrap aligned region1 v91, v31+32
 ;; @004e                               v92 = load.i64 notrap aligned region2 v33+8
-;; @004e                               store notrap aligned region4 v92, v31+72
+;; @004e                               store notrap aligned region4 v92, v31+80
 ;; @004e                               v94 = load.i64 notrap aligned region2 v74+72
 ;; @004e                               jump block6
 ;;
@@ -240,9 +240,9 @@
 ;;
 ;;                                 block4:
 ;; @004e                               v107 = load.i64 notrap aligned region2 v33
-;; @004e                               store notrap aligned region1 v107, v31+24
+;; @004e                               store notrap aligned region1 v107, v31+32
 ;; @004e                               v108 = load.i64 notrap aligned region2 v33+8
-;; @004e                               store notrap aligned region4 v108, v31+72
+;; @004e                               store notrap aligned region4 v108, v31+80
 ;; @004e                               v111 = iconst.i32 4
 ;;                                     v142 = iconst.i64 16
 ;;                                     v143 = iadd.i64 v74, v142  ; v142 = 16
diff --git a/tests/disas/stack-switching/symmetric-switch.wat b/tests/disas/stack-switching/symmetric-switch.wat
index 9c8ed3408c24..aa62087c2ac1 100644
--- a/tests/disas/stack-switching/symmetric-switch.wat
+++ b/tests/disas/stack-switching/symmetric-switch.wat
@@ -28,15 +28,15 @@
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     ss0 = explicit_slot 24, align = 256
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1073741824 "VMContRef+0x0"
-;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region3 = 67108960 "VMStoreContext+0x60"
 ;;     region4 = 1140850688 "ContinuationStackMemory+0x0"
-;;     region5 = 67108936 "VMStoreContext+0x48"
+;;     region5 = 67108944 "VMStoreContext+0x50"
 ;;     region6 = 1543503872 "Stack(ss0)"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:6 sig0
@@ -72,8 +72,8 @@
 ;; @003e                               v23 = iconst.i64 48
 ;; @003e                               v24 = iadd v0, v23  ; v23 = 48
 ;; @003e                               v25 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003e                               v26 = load.i64 notrap aligned region3 v25+88
-;; @003e                               v27 = load.i64 notrap aligned region3 v25+96
+;; @003e                               v26 = load.i64 notrap aligned region3 v25+96
+;; @003e                               v27 = load.i64 notrap aligned region3 v25+104
 ;; @003e                               jump block2(v26, v27)
 ;;
 ;;                                 block2(v28: i64, v29: i64):
@@ -126,7 +126,7 @@
 ;; @003e                               v58 = load.i64 notrap aligned readonly can_move region0 v0+8
 ;; @003e                               v59 = iconst.i64 0
 ;; @003e                               v60 = iadd v52, v59  ; v59 = 0
-;; @003e                               v61 = load.i64 notrap aligned region5 v58+72
+;; @003e                               v61 = load.i64 notrap aligned region5 v58+80
 ;; @003e                               store notrap aligned region2 v61, v60+8
 ;; @003e                               v62 = load.i64 notrap aligned region2 v27+72
 ;; @003e                               v63 = uextend.i128 v27
@@ -185,14 +185,14 @@
 ;; @003e                               store.i64 notrap aligned region2 v33, v102+56
 ;; @003e                               v103 = iconst.i64 2
 ;; @003e                               v104 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @003e                               store notrap aligned region3 v103, v104+88  ; v103 = 2
-;; @003e                               store.i64 notrap aligned region3 v14, v104+96
+;; @003e                               store notrap aligned region3 v103, v104+96  ; v103 = 2
+;; @003e                               store.i64 notrap aligned region3 v14, v104+104
 ;; @003e                               v105 = iconst.i64 0
 ;; @003e                               v106 = iadd v98, v105  ; v105 = 0
 ;; @003e                               v107 = load.i64 notrap aligned region2 v106
-;; @003e                               store notrap aligned region1 v107, v58+24
+;; @003e                               store notrap aligned region1 v107, v58+32
 ;; @003e                               v108 = load.i64 notrap aligned region2 v106+8
-;; @003e                               store notrap aligned region5 v108, v58+72
+;; @003e                               store notrap aligned region5 v108, v58+80
 ;; @003e                               v109 = iconst.i64 80
 ;; @003e                               v110 = iadd.i64 v29, v109  ; v109 = 80
 ;; @003e                               v111 = load.i64 notrap aligned region2 v110
@@ -237,10 +237,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i128) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i128):
@@ -253,14 +253,14 @@
 ;; function u0:2(i64 vmctx, i64) tail {
 ;;     ss0 = explicit_slot 8, align = 256
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1073741824 "VMContRef+0x0"
-;;     region3 = 67108952 "VMStoreContext+0x58"
-;;     region4 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108960 "VMStoreContext+0x60"
+;;     region4 = 67108944 "VMStoreContext+0x50"
 ;;     region5 = 1140850688 "ContinuationStackMemory+0x0"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail
 ;;     fn0 = colocated u805306368:6 sig0
@@ -298,16 +298,16 @@
 ;; @004b                               store notrap aligned region2 v22, v14+72
 ;; @004b                               v23 = load.i64 notrap aligned region2 v14+64
 ;; @004b                               v24 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004b                               v25 = load.i64 notrap aligned region3 v24+88
-;; @004b                               v26 = load.i64 notrap aligned region3 v24+96
+;; @004b                               v25 = load.i64 notrap aligned region3 v24+96
+;; @004b                               v26 = load.i64 notrap aligned region3 v24+104
 ;; @004b                               store notrap aligned region2 v25, v23+48
 ;; @004b                               store notrap aligned region2 v26, v23+56
 ;; @004b                               v27 = iconst.i64 0
 ;; @004b                               store notrap aligned region2 v27, v14+64  ; v27 = 0
 ;; @004b                               v28 = iconst.i64 2
 ;; @004b                               v29 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004b                               store notrap aligned region3 v28, v29+88  ; v28 = 2
-;; @004b                               store notrap aligned region3 v14, v29+96
+;; @004b                               store notrap aligned region3 v28, v29+96  ; v28 = 2
+;; @004b                               store notrap aligned region3 v14, v29+104
 ;; @004b                               v30 = iconst.i64 0
 ;; @004b                               v31 = iadd v14, v30  ; v30 = 0
 ;; @004b                               v32 = iconst.i32 1
@@ -321,16 +321,16 @@
 ;; @004b                               v38 = load.i64 notrap aligned readonly can_move region0 v0+8
 ;; @004b                               v39 = iconst.i64 0
 ;; @004b                               v40 = iadd v26, v39  ; v39 = 0
-;; @004b                               v41 = load.i64 notrap aligned region4 v38+72
+;; @004b                               v41 = load.i64 notrap aligned region4 v38+80
 ;; @004b                               store notrap aligned region2 v41, v40+8
-;; @004b                               v42 = load.i64 notrap aligned region1 v38+24
+;; @004b                               v42 = load.i64 notrap aligned region1 v38+32
 ;; @004b                               store notrap aligned region2 v42, v40
 ;; @004b                               v43 = iconst.i64 0
 ;; @004b                               v44 = iadd v31, v43  ; v43 = 0
 ;; @004b                               v45 = load.i64 notrap aligned region2 v44
-;; @004b                               store notrap aligned region1 v45, v38+24
+;; @004b                               store notrap aligned region1 v45, v38+32
 ;; @004b                               v46 = load.i64 notrap aligned region2 v44+8
-;; @004b                               store notrap aligned region4 v46, v38+72
+;; @004b                               store notrap aligned region4 v46, v38+80
 ;; @004b                               v47 = iconst.i64 24
 ;; @004b                               v48 = iadd v26, v47  ; v47 = 24
 ;; @004b                               v49 = iconst.i32 1
@@ -355,11 +355,11 @@
 ;; @004b                               v63 = iadd v61, v62  ; v62 = -24
 ;; @004b                               v64 = stack_switch v63, v63, v58
 ;; @004b                               v65 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004b                               v66 = load.i64 notrap aligned region3 v65+88
-;; @004b                               v67 = load.i64 notrap aligned region3 v65+96
+;; @004b                               v66 = load.i64 notrap aligned region3 v65+96
+;; @004b                               v67 = load.i64 notrap aligned region3 v65+104
 ;; @004b                               v68 = load.i64 notrap aligned readonly can_move region0 v0+8
-;; @004b                               store notrap aligned region3 v25, v68+88
-;; @004b                               store notrap aligned region3 v26, v68+96
+;; @004b                               store notrap aligned region3 v25, v68+96
+;; @004b                               store notrap aligned region3 v26, v68+104
 ;; @004b                               v69 = iconst.i32 1
 ;; @004b                               v70 = iconst.i64 16
 ;; @004b                               v71 = iadd v26, v70  ; v70 = 16
@@ -380,14 +380,14 @@
 ;; @004b                               v78 = iadd.i64 v67, v77  ; v77 = 0
 ;; @004b                               v79 = iconst.i64 0
 ;; @004b                               v80 = iadd v78, v79  ; v79 = 0
-;; @004b                               v81 = load.i64 notrap aligned region4 v38+72
+;; @004b                               v81 = load.i64 notrap aligned region4 v38+80
 ;; @004b                               store notrap aligned region2 v81, v80+8
 ;; @004b                               v82 = iconst.i64 0
 ;; @004b                               v83 = iadd.i64 v26, v82  ; v82 = 0
 ;; @004b                               v84 = load.i64 notrap aligned region2 v83
-;; @004b                               store notrap aligned region1 v84, v38+24
+;; @004b                               store notrap aligned region1 v84, v38+32
 ;; @004b                               v85 = load.i64 notrap aligned region2 v83+8
-;; @004b                               store notrap aligned region4 v85, v38+72
+;; @004b                               store notrap aligned region4 v85, v38+80
 ;; @004b                               v86 = ireduce.i32 v64
 ;; @004b                               v87 = load.i64 notrap aligned region2 v67+72
 ;; @004b                               v88 = uextend.i128 v67
@@ -408,9 +408,9 @@
 ;; @004b                               v94 = iconst.i64 0
 ;; @004b                               v95 = iadd.i64 v26, v94  ; v94 = 0
 ;; @004b                               v96 = load.i64 notrap aligned region2 v95
-;; @004b                               store notrap aligned region1 v96, v38+24
+;; @004b                               store notrap aligned region1 v96, v38+32
 ;; @004b                               v97 = load.i64 notrap aligned region2 v95+8
-;; @004b                               store notrap aligned region4 v97, v38+72
+;; @004b                               store notrap aligned region4 v97, v38+80
 ;; @004b                               v98 = iconst.i64 0
 ;; @004b                               v99 = iadd.i64 v67, v98  ; v98 = 0
 ;; @004b                               v100 = iconst.i32 4
diff --git a/tests/disas/startup-data-active.wat b/tests/disas/startup-data-active.wat
index 9f021ebcc897..1b2392a834b7 100644
--- a/tests/disas/startup-data-active.wat
+++ b/tests/disas/startup-data-active.wat
@@ -10,10 +10,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -23,11 +23,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -36,7 +36,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/startup-elem-active.wat b/tests/disas/startup-elem-active.wat
index 4b802eee4480..5f4aa173e806 100644
--- a/tests/disas/startup-elem-active.wat
+++ b/tests/disas/startup-elem-active.wat
@@ -14,10 +14,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -27,11 +27,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -40,7 +40,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/startup-global.wat b/tests/disas/startup-global.wat
index b669c9874b39..65a2205abf5e 100644
--- a/tests/disas/startup-global.wat
+++ b/tests/disas/startup-global.wat
@@ -7,10 +7,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -20,11 +20,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -33,7 +33,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/startup-passive-segment.wat b/tests/disas/startup-passive-segment.wat
index e9921259cffa..2ad6e6b9537e 100644
--- a/tests/disas/startup-passive-segment.wat
+++ b/tests/disas/startup-passive-segment.wat
@@ -8,10 +8,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -21,11 +21,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -34,7 +34,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/startup-start.wat b/tests/disas/startup-start.wat
index b6aed467e079..622c2f91351a 100644
--- a/tests/disas/startup-start.wat
+++ b/tests/disas/startup-start.wat
@@ -8,10 +8,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -21,11 +21,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -34,7 +34,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/startup-table-initial-value.wat b/tests/disas/startup-table-initial-value.wat
index 3db39fac9976..5b80d37c6a85 100644
--- a/tests/disas/startup-table-initial-value.wat
+++ b/tests/disas/startup-table-initial-value.wat
@@ -8,10 +8,10 @@
 )
 ;; function u2415919104:1(i64 vmctx, i64, i64, i64) -> i8 system_v {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108936 "VMStoreContext+0x48"
-;;     region2 = 67108928 "VMStoreContext+0x40"
-;;     region3 = 67108944 "VMStoreContext+0x50"
-;;     region4 = 67109000 "VMStoreContext+0x88"
+;;     region1 = 67108944 "VMStoreContext+0x50"
+;;     region2 = 67108936 "VMStoreContext+0x48"
+;;     region3 = 67108952 "VMStoreContext+0x58"
+;;     region4 = 67109008 "VMStoreContext+0x90"
 ;;     sig0 = (i64 vmctx, i64) tail
 ;;     fn0 = colocated u2415919104:0 sig0
 ;;
@@ -21,11 +21,11 @@
 ;; block1:
 ;;     v5 = get_frame_pointer.i64 
 ;;     v4 = load.i64 notrap aligned readonly can_move region0 v0+8
-;;     store notrap aligned region1 v5, v4+72
+;;     store notrap aligned region1 v5, v4+80
 ;;     v6 = get_stack_pointer.i64 
-;;     store notrap aligned region2 v6, v4+64
+;;     store notrap aligned region2 v6, v4+72
 ;;     v7 = get_exception_handler_address.i64 block1, 0
-;;     store notrap aligned region3 v7, v4+80
+;;     store notrap aligned region3 v7, v4+88
 ;;     try_call fn0(v0, v1), sig0, block2, [ default: block3 ]
 ;;
 ;; block2:
@@ -34,7 +34,7 @@
 ;;
 ;; block3:
 ;;     v9 = iconst.i64 1
-;;     store notrap aligned region4 v9, v4+136  ; v9 = 1
+;;     store notrap aligned region4 v9, v4+144  ; v9 = 1
 ;;     v10 = iconst.i8 0
 ;;     return v10  ; v10 = 0
 ;; }
diff --git a/tests/disas/sub-global.wat b/tests/disas/sub-global.wat
index 3f59df759618..6833ecde2c3f 100644
--- a/tests/disas/sub-global.wat
+++ b/tests/disas/sub-global.wat
@@ -14,11 +14,11 @@
 
 ;; function u0:0(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/table-copy.wat b/tests/disas/table-copy.wat
index 415701e48140..356efe0114c2 100644
--- a/tests/disas/table-copy.wat
+++ b/tests/disas/table-copy.wat
@@ -25,10 +25,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
@@ -40,10 +40,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
@@ -55,10 +55,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
@@ -70,14 +70,14 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 1342177280 "VMTableImport+0x0"
 ;;     region3 = 671088640 "VMTableDefinition+0x0"
 ;;     region4 = 671088648 "VMTableDefinition+0x8"
 ;;     region5 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig0
 ;;     stack_limit = gv2
@@ -210,14 +210,14 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 1342177280 "VMTableImport+0x0"
 ;;     region4 = 671088648 "VMTableDefinition+0x8"
 ;;     region5 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig0
 ;;     stack_limit = gv2
diff --git a/tests/disas/table-get-fixed-size.wat b/tests/disas/table-get-fixed-size.wat
index 743547223726..df733389f9d7 100644
--- a/tests/disas/table-get-fixed-size.wat
+++ b/tests/disas/table-get-fixed-size.wat
@@ -17,12 +17,12 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -45,12 +45,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/table-get.wat b/tests/disas/table-get.wat
index 968a1f7c5b23..cfddb7d8e513 100644
--- a/tests/disas/table-get.wat
+++ b/tests/disas/table-get.wat
@@ -16,13 +16,13 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -46,13 +46,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
diff --git a/tests/disas/table-set-fixed-size.wat b/tests/disas/table-set-fixed-size.wat
index 445c3dadc890..40b63f879bb6 100644
--- a/tests/disas/table-set-fixed-size.wat
+++ b/tests/disas/table-set-fixed-size.wat
@@ -18,12 +18,12 @@
     table.set 0))
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -46,12 +46,12 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/table-set.wat b/tests/disas/table-set.wat
index bd5bbfa58eb1..c07e2d0a798c 100644
--- a/tests/disas/table-set.wat
+++ b/tests/disas/table-set.wat
@@ -18,13 +18,13 @@
 
 ;; function u0:0(i64 vmctx, i64, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
@@ -48,13 +48,13 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 671088648 "VMTableDefinition+0x8"
 ;;     region4 = 268435456 "PublicTable"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
diff --git a/tests/disas/trunc.wat b/tests/disas/trunc.wat
index 250b13dcb04d..8dc5918ca855 100644
--- a/tests/disas/trunc.wat
+++ b/tests/disas/trunc.wat
@@ -14,7 +14,7 @@
 ;;       movq    %rbx, 0x10(%rsp)
 ;;       movq    8(%rdi), %rax
 ;;       movq    %rdi, %rbx
-;;       movq    0x18(%rax), %rax
+;;       movq    0x20(%rax), %rax
 ;;       movq    %rsp, %rcx
 ;;       cmpq    %rax, %rcx
 ;;       jb      0x118
diff --git a/tests/disas/trunc32.wat b/tests/disas/trunc32.wat
index dc903bde9925..0fd0e9449048 100644
--- a/tests/disas/trunc32.wat
+++ b/tests/disas/trunc32.wat
@@ -15,7 +15,7 @@
 ;;       movdqu  %xmm0, (%rsp)
 ;;       movq    8(%rdi), %rax
 ;;       movq    %rdi, %rbx
-;;       movq    0x18(%rax), %rax
+;;       movq    0x20(%rax), %rax
 ;;       movq    %rsp, %rcx
 ;;       cmpq    %rax, %rcx
 ;;       jb      0x10d
diff --git a/tests/disas/typed-funcrefs-eager-init.wat b/tests/disas/typed-funcrefs-eager-init.wat
index 3e50095a6f67..cb46046ed373 100644
--- a/tests/disas/typed-funcrefs-eager-init.wat
+++ b/tests/disas/typed-funcrefs-eager-init.wat
@@ -115,10 +115,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
@@ -130,14 +130,14 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 1610612744 "VMFuncRef+0x8"
 ;;     region5 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
@@ -164,14 +164,14 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 1610612744 "VMFuncRef+0x8"
 ;;     region5 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
@@ -198,14 +198,14 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     region3 = 1610612744 "VMFuncRef+0x8"
 ;;     region4 = 1610612760 "VMFuncRef+0x18"
 ;;     region5 = 469762049 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/typed-funcrefs.wat b/tests/disas/typed-funcrefs.wat
index 9c5cee2932f4..9931868512d3 100644
--- a/tests/disas/typed-funcrefs.wat
+++ b/tests/disas/typed-funcrefs.wat
@@ -115,10 +115,10 @@
 
 ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
@@ -130,14 +130,14 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 1610612744 "VMFuncRef+0x8"
 ;;     region5 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     sig1 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     fn0 = colocated u805306368:7 sig0
@@ -188,14 +188,14 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 671088640 "VMTableDefinition+0x0"
 ;;     region3 = 335544320 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))"
 ;;     region4 = 1610612744 "VMFuncRef+0x8"
 ;;     region5 = 1610612760 "VMFuncRef+0x18"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
 ;;     fn0 = colocated u805306368:7 sig1
@@ -246,14 +246,14 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     region2 = 469762048 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))"
 ;;     region3 = 1610612744 "VMFuncRef+0x8"
 ;;     region4 = 1610612760 "VMFuncRef+0x18"
 ;;     region5 = 469762049 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/unreachable_code.wat b/tests/disas/unreachable_code.wat
index 1556f1cb68ac..636afabde8b5 100644
--- a/tests/disas/unreachable_code.wat
+++ b/tests/disas/unreachable_code.wat
@@ -80,10 +80,10 @@
 
 ;; function u0:0(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -92,10 +92,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -107,10 +107,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64) -> i32 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
@@ -141,10 +141,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64) tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64):
diff --git a/tests/disas/winch/aarch64/br/as_br_if_cond.wat b/tests/disas/winch/aarch64/br/as_br_if_cond.wat
index 8d46136e0b4d..1a21e3bdcdcc 100644
--- a/tests/disas/winch/aarch64/br/as_br_if_cond.wat
+++ b/tests/disas/winch/aarch64/br/as_br_if_cond.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/as_br_value.wat b/tests/disas/winch/aarch64/br/as_br_value.wat
index 72e6df5065a0..0ad8a6737102 100644
--- a/tests/disas/winch/aarch64/br/as_br_value.wat
+++ b/tests/disas/winch/aarch64/br/as_br_value.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/as_if_cond.wat b/tests/disas/winch/aarch64/br/as_if_cond.wat
index 44d670b477e7..58ee784043ad 100644
--- a/tests/disas/winch/aarch64/br/as_if_cond.wat
+++ b/tests/disas/winch/aarch64/br/as_if_cond.wat
@@ -16,7 +16,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/as_if_else.wat b/tests/disas/winch/aarch64/br/as_if_else.wat
index b7e1de9b2d5f..44147afbac02 100644
--- a/tests/disas/winch/aarch64/br/as_if_else.wat
+++ b/tests/disas/winch/aarch64/br/as_if_else.wat
@@ -16,7 +16,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/as_if_then.wat b/tests/disas/winch/aarch64/br/as_if_then.wat
index ecabc3fcd661..6f9f8f2f8ccd 100644
--- a/tests/disas/winch/aarch64/br/as_if_then.wat
+++ b/tests/disas/winch/aarch64/br/as_if_then.wat
@@ -16,7 +16,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/as_loop_first.wat b/tests/disas/winch/aarch64/br/as_loop_first.wat
index d0c8d30b011e..150532991c84 100644
--- a/tests/disas/winch/aarch64/br/as_loop_first.wat
+++ b/tests/disas/winch/aarch64/br/as_loop_first.wat
@@ -12,7 +12,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br/br_jump.wat b/tests/disas/winch/aarch64/br/br_jump.wat
index 40056f3035e5..c03274b47ee3 100644
--- a/tests/disas/winch/aarch64/br/br_jump.wat
+++ b/tests/disas/winch/aarch64/br/br_jump.wat
@@ -19,7 +19,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat b/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat
index 00689f506a5a..dbaabeb848e1 100644
--- a/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat
+++ b/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_if/as_br_value.wat b/tests/disas/winch/aarch64/br_if/as_br_value.wat
index d3ee7a3b71a4..c7360deef9ed 100644
--- a/tests/disas/winch/aarch64/br_if/as_br_value.wat
+++ b/tests/disas/winch/aarch64/br_if/as_br_value.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_if/as_if_cond.wat b/tests/disas/winch/aarch64/br_if/as_if_cond.wat
index 3e9ee06905fb..a7d967923261 100644
--- a/tests/disas/winch/aarch64/br_if/as_if_cond.wat
+++ b/tests/disas/winch/aarch64/br_if/as_if_cond.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_if/as_local_set_value.wat b/tests/disas/winch/aarch64/br_if/as_local_set_value.wat
index 80c5e5ba614e..3aae1b41bb9e 100644
--- a/tests/disas/winch/aarch64/br_if/as_local_set_value.wat
+++ b/tests/disas/winch/aarch64/br_if/as_local_set_value.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_table/large.wat b/tests/disas/winch/aarch64/br_table/large.wat
index db6294d60a57..422a6c7092ee 100644
--- a/tests/disas/winch/aarch64/br_table/large.wat
+++ b/tests/disas/winch/aarch64/br_table/large.wat
@@ -744,7 +744,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat b/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat
index a1a5c7d414a8..036fb900ebd1 100644
--- a/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat
+++ b/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat
@@ -24,7 +24,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call/multi.wat b/tests/disas/winch/aarch64/call/multi.wat
index 1a1b374d738f..14417fce226f 100644
--- a/tests/disas/winch/aarch64/call/multi.wat
+++ b/tests/disas/winch/aarch64/call/multi.wat
@@ -16,7 +16,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x1c
 ;;       add     x16, x16, x17
@@ -52,7 +52,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call/params.wat b/tests/disas/winch/aarch64/call/params.wat
index 57059a49bb1d..ef8c9c77c63b 100644
--- a/tests/disas/winch/aarch64/call/params.wat
+++ b/tests/disas/winch/aarch64/call/params.wat
@@ -43,7 +43,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x40
 ;;       add     x16, x16, x17
@@ -129,7 +129,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x28
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call/recursive.wat b/tests/disas/winch/aarch64/call/recursive.wat
index d713786075dc..8977a1840691 100644
--- a/tests/disas/winch/aarch64/call/recursive.wat
+++ b/tests/disas/winch/aarch64/call/recursive.wat
@@ -30,7 +30,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call/reg_on_stack.wat b/tests/disas/winch/aarch64/call/reg_on_stack.wat
index 03613f710d7c..936616d65169 100644
--- a/tests/disas/winch/aarch64/call/reg_on_stack.wat
+++ b/tests/disas/winch/aarch64/call/reg_on_stack.wat
@@ -19,7 +19,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x24
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call/simple.wat b/tests/disas/winch/aarch64/call/simple.wat
index 6f52dda4cbed..6f8d3b3e2b29 100644
--- a/tests/disas/winch/aarch64/call/simple.wat
+++ b/tests/disas/winch/aarch64/call/simple.wat
@@ -21,7 +21,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
@@ -62,7 +62,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call_indirect/call_indirect.wat b/tests/disas/winch/aarch64/call_indirect/call_indirect.wat
index 6c26d057461e..0c3f0eff30a8 100644
--- a/tests/disas/winch/aarch64/call_indirect/call_indirect.wat
+++ b/tests/disas/winch/aarch64/call_indirect/call_indirect.wat
@@ -35,7 +35,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x30
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/call_indirect/local_arg.wat b/tests/disas/winch/aarch64/call_indirect/local_arg.wat
index 1675b9bbd6b7..094ee49762b7 100644
--- a/tests/disas/winch/aarch64/call_indirect/local_arg.wat
+++ b/tests/disas/winch/aarch64/call_indirect/local_arg.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
@@ -49,7 +49,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x24
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat b/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat
index 9d2a161b8f14..998aae1ae0bc 100644
--- a/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat
+++ b/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat b/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat
index 6875c44f080a..0538ce1b1cd6 100644
--- a/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat
+++ b/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_add/const.wat b/tests/disas/winch/aarch64/f32_add/const.wat
index 096f49cdaca8..200c3cee897c 100644
--- a/tests/disas/winch/aarch64/f32_add/const.wat
+++ b/tests/disas/winch/aarch64/f32_add/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_add/locals.wat b/tests/disas/winch/aarch64/f32_add/locals.wat
index c6e23e846228..98f828d375cc 100644
--- a/tests/disas/winch/aarch64/f32_add/locals.wat
+++ b/tests/disas/winch/aarch64/f32_add/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_add/params.wat b/tests/disas/winch/aarch64/f32_add/params.wat
index 583a48201284..39652abad01b 100644
--- a/tests/disas/winch/aarch64/f32_add/params.wat
+++ b/tests/disas/winch/aarch64/f32_add/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat
index c98f8a60d5ca..23f3e66bcc1f 100644
--- a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat
+++ b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat
index c530c0e10c79..e0eb8d82426d 100644
--- a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat
+++ b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_s/const.wat b/tests/disas/winch/aarch64/f32_convert_i32_s/const.wat
index dcae741e5103..8848c5a03a44 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_s/const.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_s/locals.wat b/tests/disas/winch/aarch64/f32_convert_i32_s/locals.wat
index c6307af7eaba..094871120d0b 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_s/locals.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_s/params.wat b/tests/disas/winch/aarch64/f32_convert_i32_s/params.wat
index 4998fcef86bf..48b6e1f727b7 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_s/params.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_s/spilled.wat b/tests/disas/winch/aarch64/f32_convert_i32_s/spilled.wat
index c50161116d73..5a4fd376a03a 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_s/spilled.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_s/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x14
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_u/const.wat b/tests/disas/winch/aarch64/f32_convert_i32_u/const.wat
index c622ecea7fdf..4d6f64e4b298 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_u/const.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_u/locals.wat b/tests/disas/winch/aarch64/f32_convert_i32_u/locals.wat
index 6aaa61d736ce..d06009344409 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_u/locals.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_u/params.wat b/tests/disas/winch/aarch64/f32_convert_i32_u/params.wat
index 940790bad971..bc1ccbf27a17 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_u/params.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i32_u/spilled.wat b/tests/disas/winch/aarch64/f32_convert_i32_u/spilled.wat
index 75e5044d71e7..5ccc35cf77aa 100644
--- a/tests/disas/winch/aarch64/f32_convert_i32_u/spilled.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i32_u/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x14
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_s/const.wat b/tests/disas/winch/aarch64/f32_convert_i64_s/const.wat
index fd716bcbcc02..9150e00e7292 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_s/const.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_s/locals.wat b/tests/disas/winch/aarch64/f32_convert_i64_s/locals.wat
index 7f77f57771b7..06f772b8efc3 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_s/locals.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_s/params.wat b/tests/disas/winch/aarch64/f32_convert_i64_s/params.wat
index 954c0da57580..9217856df7a1 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_s/params.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_s/spilled.wat b/tests/disas/winch/aarch64/f32_convert_i64_s/spilled.wat
index a673c1943084..893867bad5cc 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_s/spilled.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_s/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x14
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_u/const.wat b/tests/disas/winch/aarch64/f32_convert_i64_u/const.wat
index 98c9bb288179..5080d6ca27b9 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_u/const.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_u/locals.wat b/tests/disas/winch/aarch64/f32_convert_i64_u/locals.wat
index 6407746ccacd..8fdd6e6c2b5b 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_u/locals.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_u/params.wat b/tests/disas/winch/aarch64/f32_convert_i64_u/params.wat
index 3f6f8f4ba78a..c93c13cc110c 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_u/params.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_convert_i64_u/spilled.wat b/tests/disas/winch/aarch64/f32_convert_i64_u/spilled.wat
index a467e73ed79a..80151ae4e603 100644
--- a/tests/disas/winch/aarch64/f32_convert_i64_u/spilled.wat
+++ b/tests/disas/winch/aarch64/f32_convert_i64_u/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x14
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_copysign/const.wat b/tests/disas/winch/aarch64/f32_copysign/const.wat
index 2b6be49090cc..218f80219418 100644
--- a/tests/disas/winch/aarch64/f32_copysign/const.wat
+++ b/tests/disas/winch/aarch64/f32_copysign/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_copysign/locals.wat b/tests/disas/winch/aarch64/f32_copysign/locals.wat
index cebebe9edeac..6cf2fa68ca8e 100644
--- a/tests/disas/winch/aarch64/f32_copysign/locals.wat
+++ b/tests/disas/winch/aarch64/f32_copysign/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_copysign/params.wat b/tests/disas/winch/aarch64/f32_copysign/params.wat
index 70b9e7af710f..bfefbed6e38e 100644
--- a/tests/disas/winch/aarch64/f32_copysign/params.wat
+++ b/tests/disas/winch/aarch64/f32_copysign/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/const.wat b/tests/disas/winch/aarch64/f32_demote_f64/const.wat
index bbf125770100..fbf99083a5d8 100644
--- a/tests/disas/winch/aarch64/f32_demote_f64/const.wat
+++ b/tests/disas/winch/aarch64/f32_demote_f64/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/locals.wat b/tests/disas/winch/aarch64/f32_demote_f64/locals.wat
index 6f95c5929185..fc5636d3e232 100644
--- a/tests/disas/winch/aarch64/f32_demote_f64/locals.wat
+++ b/tests/disas/winch/aarch64/f32_demote_f64/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/params.wat b/tests/disas/winch/aarch64/f32_demote_f64/params.wat
index bc0ba8cb8bb1..68afca3f9e35 100644
--- a/tests/disas/winch/aarch64/f32_demote_f64/params.wat
+++ b/tests/disas/winch/aarch64/f32_demote_f64/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_div/const.wat b/tests/disas/winch/aarch64/f32_div/const.wat
index 16521dde4a19..b48827853407 100644
--- a/tests/disas/winch/aarch64/f32_div/const.wat
+++ b/tests/disas/winch/aarch64/f32_div/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_div/locals.wat b/tests/disas/winch/aarch64/f32_div/locals.wat
index 4b9e22a00186..a87b7fac9014 100644
--- a/tests/disas/winch/aarch64/f32_div/locals.wat
+++ b/tests/disas/winch/aarch64/f32_div/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_div/params.wat b/tests/disas/winch/aarch64/f32_div/params.wat
index cd43241bcb0a..a03286172a51 100644
--- a/tests/disas/winch/aarch64/f32_div/params.wat
+++ b/tests/disas/winch/aarch64/f32_div/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_eq/const.wat b/tests/disas/winch/aarch64/f32_eq/const.wat
index 96a66814cb33..d37dd5b9bec0 100644
--- a/tests/disas/winch/aarch64/f32_eq/const.wat
+++ b/tests/disas/winch/aarch64/f32_eq/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_eq/locals.wat b/tests/disas/winch/aarch64/f32_eq/locals.wat
index 201d7afaae9a..eeac45d61f5e 100644
--- a/tests/disas/winch/aarch64/f32_eq/locals.wat
+++ b/tests/disas/winch/aarch64/f32_eq/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_eq/params.wat b/tests/disas/winch/aarch64/f32_eq/params.wat
index 8cd0c1e946ae..2585c8ef64e5 100644
--- a/tests/disas/winch/aarch64/f32_eq/params.wat
+++ b/tests/disas/winch/aarch64/f32_eq/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat b/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat
index a9612ce9a31a..65ad37ba0165 100644
--- a/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat
+++ b/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat b/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat
index ae5c252f166f..f3d247e5ff0d 100644
--- a/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat
+++ b/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ge/const.wat b/tests/disas/winch/aarch64/f32_ge/const.wat
index 3dc916b0d6e5..b9b61a36e371 100644
--- a/tests/disas/winch/aarch64/f32_ge/const.wat
+++ b/tests/disas/winch/aarch64/f32_ge/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ge/locals.wat b/tests/disas/winch/aarch64/f32_ge/locals.wat
index 4fbbd855dcb8..af672fc901b2 100644
--- a/tests/disas/winch/aarch64/f32_ge/locals.wat
+++ b/tests/disas/winch/aarch64/f32_ge/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ge/params.wat b/tests/disas/winch/aarch64/f32_ge/params.wat
index 401d3aa21fcb..f0f46cd77226 100644
--- a/tests/disas/winch/aarch64/f32_ge/params.wat
+++ b/tests/disas/winch/aarch64/f32_ge/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_gt/const.wat b/tests/disas/winch/aarch64/f32_gt/const.wat
index 532d4fd41531..bc2dba83cbe0 100644
--- a/tests/disas/winch/aarch64/f32_gt/const.wat
+++ b/tests/disas/winch/aarch64/f32_gt/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_gt/locals.wat b/tests/disas/winch/aarch64/f32_gt/locals.wat
index 3ef05a250c79..85eeca45eeca 100644
--- a/tests/disas/winch/aarch64/f32_gt/locals.wat
+++ b/tests/disas/winch/aarch64/f32_gt/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_gt/params.wat b/tests/disas/winch/aarch64/f32_gt/params.wat
index dd4d3252e0a7..e5c7713c9a72 100644
--- a/tests/disas/winch/aarch64/f32_gt/params.wat
+++ b/tests/disas/winch/aarch64/f32_gt/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_le/const.wat b/tests/disas/winch/aarch64/f32_le/const.wat
index 8ccb709af9eb..8c043923bc97 100644
--- a/tests/disas/winch/aarch64/f32_le/const.wat
+++ b/tests/disas/winch/aarch64/f32_le/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_le/locals.wat b/tests/disas/winch/aarch64/f32_le/locals.wat
index 7fcb1357eb82..dbe38c7aa908 100644
--- a/tests/disas/winch/aarch64/f32_le/locals.wat
+++ b/tests/disas/winch/aarch64/f32_le/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_le/params.wat b/tests/disas/winch/aarch64/f32_le/params.wat
index 7b9eda32ffde..97794691a8be 100644
--- a/tests/disas/winch/aarch64/f32_le/params.wat
+++ b/tests/disas/winch/aarch64/f32_le/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_lt/const.wat b/tests/disas/winch/aarch64/f32_lt/const.wat
index 01c14db4f5a9..31567fde07e8 100644
--- a/tests/disas/winch/aarch64/f32_lt/const.wat
+++ b/tests/disas/winch/aarch64/f32_lt/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_lt/locals.wat b/tests/disas/winch/aarch64/f32_lt/locals.wat
index 49a3bc284221..c3608025fc98 100644
--- a/tests/disas/winch/aarch64/f32_lt/locals.wat
+++ b/tests/disas/winch/aarch64/f32_lt/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_lt/params.wat b/tests/disas/winch/aarch64/f32_lt/params.wat
index 8978204fd6cc..40e4a1572a78 100644
--- a/tests/disas/winch/aarch64/f32_lt/params.wat
+++ b/tests/disas/winch/aarch64/f32_lt/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_max/const.wat b/tests/disas/winch/aarch64/f32_max/const.wat
index 4ebacc5d4993..e4329f132c33 100644
--- a/tests/disas/winch/aarch64/f32_max/const.wat
+++ b/tests/disas/winch/aarch64/f32_max/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_max/locals.wat b/tests/disas/winch/aarch64/f32_max/locals.wat
index 01b27944a8f0..db5f42f0a436 100644
--- a/tests/disas/winch/aarch64/f32_max/locals.wat
+++ b/tests/disas/winch/aarch64/f32_max/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_max/params.wat b/tests/disas/winch/aarch64/f32_max/params.wat
index 43ddb1ff8aa8..15b19780679a 100644
--- a/tests/disas/winch/aarch64/f32_max/params.wat
+++ b/tests/disas/winch/aarch64/f32_max/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_min/const.wat b/tests/disas/winch/aarch64/f32_min/const.wat
index 9ed3f633f7d9..bb734520ef4d 100644
--- a/tests/disas/winch/aarch64/f32_min/const.wat
+++ b/tests/disas/winch/aarch64/f32_min/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_min/locals.wat b/tests/disas/winch/aarch64/f32_min/locals.wat
index 501af0172d51..5252ae8bb87a 100644
--- a/tests/disas/winch/aarch64/f32_min/locals.wat
+++ b/tests/disas/winch/aarch64/f32_min/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_min/params.wat b/tests/disas/winch/aarch64/f32_min/params.wat
index 431aab5e3c30..c89e8fa80b78 100644
--- a/tests/disas/winch/aarch64/f32_min/params.wat
+++ b/tests/disas/winch/aarch64/f32_min/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_mul/const.wat b/tests/disas/winch/aarch64/f32_mul/const.wat
index 327778051982..acf5a27d84af 100644
--- a/tests/disas/winch/aarch64/f32_mul/const.wat
+++ b/tests/disas/winch/aarch64/f32_mul/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_mul/locals.wat b/tests/disas/winch/aarch64/f32_mul/locals.wat
index d53ca907d575..f868e2365089 100644
--- a/tests/disas/winch/aarch64/f32_mul/locals.wat
+++ b/tests/disas/winch/aarch64/f32_mul/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_mul/params.wat b/tests/disas/winch/aarch64/f32_mul/params.wat
index 95d23aa5424e..26d556587256 100644
--- a/tests/disas/winch/aarch64/f32_mul/params.wat
+++ b/tests/disas/winch/aarch64/f32_mul/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ne/const.wat b/tests/disas/winch/aarch64/f32_ne/const.wat
index 960239db165b..2323e46f6545 100644
--- a/tests/disas/winch/aarch64/f32_ne/const.wat
+++ b/tests/disas/winch/aarch64/f32_ne/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ne/locals.wat b/tests/disas/winch/aarch64/f32_ne/locals.wat
index 8c7caad60f69..ca77e2f54998 100644
--- a/tests/disas/winch/aarch64/f32_ne/locals.wat
+++ b/tests/disas/winch/aarch64/f32_ne/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_ne/params.wat b/tests/disas/winch/aarch64/f32_ne/params.wat
index 1549611313d8..cd37cf031520 100644
--- a/tests/disas/winch/aarch64/f32_ne/params.wat
+++ b/tests/disas/winch/aarch64/f32_ne/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat
index 47cfd003ac6b..a4e7fa66acfe 100644
--- a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat
+++ b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat
index 1f8ce5266974..e9730fe2d926 100644
--- a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat
+++ b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat b/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat
index 3abb0983cede..f17566e5eaa0 100644
--- a/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat
+++ b/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat b/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat
index 98d666ce51fa..913169e8e14b 100644
--- a/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat
+++ b/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_reinterpret_i32/const.wat b/tests/disas/winch/aarch64/f32_reinterpret_i32/const.wat
index a7e5e955e395..9404fe11fa89 100644
--- a/tests/disas/winch/aarch64/f32_reinterpret_i32/const.wat
+++ b/tests/disas/winch/aarch64/f32_reinterpret_i32/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_reinterpret_i32/locals.wat b/tests/disas/winch/aarch64/f32_reinterpret_i32/locals.wat
index 09734dcd0025..9821bf16b6c3 100644
--- a/tests/disas/winch/aarch64/f32_reinterpret_i32/locals.wat
+++ b/tests/disas/winch/aarch64/f32_reinterpret_i32/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_reinterpret_i32/params.wat b/tests/disas/winch/aarch64/f32_reinterpret_i32/params.wat
index 813da6256ff6..ed183863cbb7 100644
--- a/tests/disas/winch/aarch64/f32_reinterpret_i32/params.wat
+++ b/tests/disas/winch/aarch64/f32_reinterpret_i32/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_reinterpret_i32/ret_int.wat b/tests/disas/winch/aarch64/f32_reinterpret_i32/ret_int.wat
index 29afcac03651..b4cb1c3867f3 100644
--- a/tests/disas/winch/aarch64/f32_reinterpret_i32/ret_int.wat
+++ b/tests/disas/winch/aarch64/f32_reinterpret_i32/ret_int.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_reinterpret_i32/spilled.wat b/tests/disas/winch/aarch64/f32_reinterpret_i32/spilled.wat
index 2099f8655caa..989faf01ffaf 100644
--- a/tests/disas/winch/aarch64/f32_reinterpret_i32/spilled.wat
+++ b/tests/disas/winch/aarch64/f32_reinterpret_i32/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x14
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat
index 67d9947a219c..cd99404ff9c3 100644
--- a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat
+++ b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat
index 8c88e3a7cea0..3d41d9e6d010 100644
--- a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat
+++ b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_sub/const.wat b/tests/disas/winch/aarch64/f32_sub/const.wat
index 3fc7625c3605..a4ab3eee4d95 100644
--- a/tests/disas/winch/aarch64/f32_sub/const.wat
+++ b/tests/disas/winch/aarch64/f32_sub/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_sub/locals.wat b/tests/disas/winch/aarch64/f32_sub/locals.wat
index 373467c5d30c..92207f9e9278 100644
--- a/tests/disas/winch/aarch64/f32_sub/locals.wat
+++ b/tests/disas/winch/aarch64/f32_sub/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_sub/params.wat b/tests/disas/winch/aarch64/f32_sub/params.wat
index 520643382254..6f0fa980ffd8 100644
--- a/tests/disas/winch/aarch64/f32_sub/params.wat
+++ b/tests/disas/winch/aarch64/f32_sub/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat
index daaee7092f7d..05fa0c2fb92c 100644
--- a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat
+++ b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat
index b03a19c081a5..1e4e1fa2733b 100644
--- a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat
+++ b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat b/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat
index 9792a95c5af3..f17ba51877e5 100644
--- a/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat
+++ b/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat b/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat
index f2e051a45a6c..1ed918e7d654 100644
--- a/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat
+++ b/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_add/const.wat b/tests/disas/winch/aarch64/f64_add/const.wat
index 0ed6394ec686..18200491d1d0 100644
--- a/tests/disas/winch/aarch64/f64_add/const.wat
+++ b/tests/disas/winch/aarch64/f64_add/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_add/locals.wat b/tests/disas/winch/aarch64/f64_add/locals.wat
index 620d9ce58b4f..79a875c91bac 100644
--- a/tests/disas/winch/aarch64/f64_add/locals.wat
+++ b/tests/disas/winch/aarch64/f64_add/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_add/params.wat b/tests/disas/winch/aarch64/f64_add/params.wat
index 21d6d03ed49a..b54e9038c31b 100644
--- a/tests/disas/winch/aarch64/f64_add/params.wat
+++ b/tests/disas/winch/aarch64/f64_add/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat
index 1d7d0aae6332..a1c9c316de86 100644
--- a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat
+++ b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat
index d1ddac645deb..da175d8fcb32 100644
--- a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat
+++ b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_s/const.wat b/tests/disas/winch/aarch64/f64_convert_i32_s/const.wat
index 6c76fa678584..cafc34451754 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_s/const.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_s/locals.wat b/tests/disas/winch/aarch64/f64_convert_i32_s/locals.wat
index d1600d2ec7dd..ade4ccccafb9 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_s/locals.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_s/params.wat b/tests/disas/winch/aarch64/f64_convert_i32_s/params.wat
index 041d206c475a..67556261d3f6 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_s/params.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_s/spilled.wat b/tests/disas/winch/aarch64/f64_convert_i32_s/spilled.wat
index 233dfb8052de..3cab772e3cfc 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_s/spilled.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_s/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_u/const.wat b/tests/disas/winch/aarch64/f64_convert_i32_u/const.wat
index b52416de6b30..709e21e83251 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_u/const.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_u/locals.wat b/tests/disas/winch/aarch64/f64_convert_i32_u/locals.wat
index 88971d97eab9..d4c43294426f 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_u/locals.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_u/params.wat b/tests/disas/winch/aarch64/f64_convert_i32_u/params.wat
index fd4e590373e2..f80c9d85dc92 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_u/params.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i32_u/spilled.wat b/tests/disas/winch/aarch64/f64_convert_i32_u/spilled.wat
index 190d98ae85a9..35db0184bb38 100644
--- a/tests/disas/winch/aarch64/f64_convert_i32_u/spilled.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i32_u/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_s/const.wat b/tests/disas/winch/aarch64/f64_convert_i64_s/const.wat
index de40b30a6d08..f25e52f10f1b 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_s/const.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_s/locals.wat b/tests/disas/winch/aarch64/f64_convert_i64_s/locals.wat
index 021e8299107a..1f872e6fe65e 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_s/locals.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_s/params.wat b/tests/disas/winch/aarch64/f64_convert_i64_s/params.wat
index e9bc0ed72d0b..4798b201a3d0 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_s/params.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_s/spilled.wat b/tests/disas/winch/aarch64/f64_convert_i64_s/spilled.wat
index 54f7bc1b8366..af32fd4241d3 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_s/spilled.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_s/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_u/const.wat b/tests/disas/winch/aarch64/f64_convert_i64_u/const.wat
index 4af6592df9ba..2de089f3cd31 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_u/const.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_u/locals.wat b/tests/disas/winch/aarch64/f64_convert_i64_u/locals.wat
index 85d296dbc424..bd5e48cb5441 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_u/locals.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_u/params.wat b/tests/disas/winch/aarch64/f64_convert_i64_u/params.wat
index 010d968995ff..9c6167153cc5 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_u/params.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_convert_i64_u/spilled.wat b/tests/disas/winch/aarch64/f64_convert_i64_u/spilled.wat
index ca07d8285724..4bffdf25bd71 100644
--- a/tests/disas/winch/aarch64/f64_convert_i64_u/spilled.wat
+++ b/tests/disas/winch/aarch64/f64_convert_i64_u/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_copysign/const.wat b/tests/disas/winch/aarch64/f64_copysign/const.wat
index 0a6bfc5ef6df..dfdcc0a9ebcf 100644
--- a/tests/disas/winch/aarch64/f64_copysign/const.wat
+++ b/tests/disas/winch/aarch64/f64_copysign/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_copysign/locals.wat b/tests/disas/winch/aarch64/f64_copysign/locals.wat
index 0463aed39591..f3c30cba10b6 100644
--- a/tests/disas/winch/aarch64/f64_copysign/locals.wat
+++ b/tests/disas/winch/aarch64/f64_copysign/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_copysign/params.wat b/tests/disas/winch/aarch64/f64_copysign/params.wat
index d88d76ef5294..dd7daf0138fc 100644
--- a/tests/disas/winch/aarch64/f64_copysign/params.wat
+++ b/tests/disas/winch/aarch64/f64_copysign/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_div/const.wat b/tests/disas/winch/aarch64/f64_div/const.wat
index ddd392fdd511..f4990074cb78 100644
--- a/tests/disas/winch/aarch64/f64_div/const.wat
+++ b/tests/disas/winch/aarch64/f64_div/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_div/locals.wat b/tests/disas/winch/aarch64/f64_div/locals.wat
index b3b406df1be3..485cf91051ca 100644
--- a/tests/disas/winch/aarch64/f64_div/locals.wat
+++ b/tests/disas/winch/aarch64/f64_div/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_div/params.wat b/tests/disas/winch/aarch64/f64_div/params.wat
index b1caca7e804a..79d0e95490bf 100644
--- a/tests/disas/winch/aarch64/f64_div/params.wat
+++ b/tests/disas/winch/aarch64/f64_div/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_eq/const.wat b/tests/disas/winch/aarch64/f64_eq/const.wat
index 1b379602d877..f05a247a3a3b 100644
--- a/tests/disas/winch/aarch64/f64_eq/const.wat
+++ b/tests/disas/winch/aarch64/f64_eq/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_eq/locals.wat b/tests/disas/winch/aarch64/f64_eq/locals.wat
index 46346c7a58e7..6e712adcfd35 100644
--- a/tests/disas/winch/aarch64/f64_eq/locals.wat
+++ b/tests/disas/winch/aarch64/f64_eq/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_eq/params.wat b/tests/disas/winch/aarch64/f64_eq/params.wat
index 586b0d71a981..6e35ac0fb18e 100644
--- a/tests/disas/winch/aarch64/f64_eq/params.wat
+++ b/tests/disas/winch/aarch64/f64_eq/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat b/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat
index 56b459a84f75..0b2f8f841672 100644
--- a/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat
+++ b/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat b/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat
index e78461c49046..ff828424d85c 100644
--- a/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat
+++ b/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ge/const.wat b/tests/disas/winch/aarch64/f64_ge/const.wat
index e1dc98d6cbcb..cec85039b804 100644
--- a/tests/disas/winch/aarch64/f64_ge/const.wat
+++ b/tests/disas/winch/aarch64/f64_ge/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ge/locals.wat b/tests/disas/winch/aarch64/f64_ge/locals.wat
index f3696ae0d3ae..777ad3043d5d 100644
--- a/tests/disas/winch/aarch64/f64_ge/locals.wat
+++ b/tests/disas/winch/aarch64/f64_ge/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ge/params.wat b/tests/disas/winch/aarch64/f64_ge/params.wat
index dacc7420fd01..5697ef947339 100644
--- a/tests/disas/winch/aarch64/f64_ge/params.wat
+++ b/tests/disas/winch/aarch64/f64_ge/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_gt/const.wat b/tests/disas/winch/aarch64/f64_gt/const.wat
index 3d320c4b0598..52801dae1ff5 100644
--- a/tests/disas/winch/aarch64/f64_gt/const.wat
+++ b/tests/disas/winch/aarch64/f64_gt/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_gt/locals.wat b/tests/disas/winch/aarch64/f64_gt/locals.wat
index 9e209a6549a2..620c3ae69df5 100644
--- a/tests/disas/winch/aarch64/f64_gt/locals.wat
+++ b/tests/disas/winch/aarch64/f64_gt/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_gt/params.wat b/tests/disas/winch/aarch64/f64_gt/params.wat
index b3f8160fcc01..7ae67aa90b24 100644
--- a/tests/disas/winch/aarch64/f64_gt/params.wat
+++ b/tests/disas/winch/aarch64/f64_gt/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_le/const.wat b/tests/disas/winch/aarch64/f64_le/const.wat
index 8bcbb1fb20f3..96452b8e0a6a 100644
--- a/tests/disas/winch/aarch64/f64_le/const.wat
+++ b/tests/disas/winch/aarch64/f64_le/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_le/locals.wat b/tests/disas/winch/aarch64/f64_le/locals.wat
index b89875d35dfc..641768fe393e 100644
--- a/tests/disas/winch/aarch64/f64_le/locals.wat
+++ b/tests/disas/winch/aarch64/f64_le/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_le/params.wat b/tests/disas/winch/aarch64/f64_le/params.wat
index 2d69fddf1e06..bef2e44b33e2 100644
--- a/tests/disas/winch/aarch64/f64_le/params.wat
+++ b/tests/disas/winch/aarch64/f64_le/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_lt/const.wat b/tests/disas/winch/aarch64/f64_lt/const.wat
index 44a8daa4f10e..20706c761117 100644
--- a/tests/disas/winch/aarch64/f64_lt/const.wat
+++ b/tests/disas/winch/aarch64/f64_lt/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_lt/locals.wat b/tests/disas/winch/aarch64/f64_lt/locals.wat
index a952a487d672..2c1c70e3c049 100644
--- a/tests/disas/winch/aarch64/f64_lt/locals.wat
+++ b/tests/disas/winch/aarch64/f64_lt/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_lt/params.wat b/tests/disas/winch/aarch64/f64_lt/params.wat
index b340ca8a0977..b4867a339f9c 100644
--- a/tests/disas/winch/aarch64/f64_lt/params.wat
+++ b/tests/disas/winch/aarch64/f64_lt/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_max/const.wat b/tests/disas/winch/aarch64/f64_max/const.wat
index 986837db124d..c0ee2a657618 100644
--- a/tests/disas/winch/aarch64/f64_max/const.wat
+++ b/tests/disas/winch/aarch64/f64_max/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_max/locals.wat b/tests/disas/winch/aarch64/f64_max/locals.wat
index 02bd375155bf..b83bd372135c 100644
--- a/tests/disas/winch/aarch64/f64_max/locals.wat
+++ b/tests/disas/winch/aarch64/f64_max/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_max/params.wat b/tests/disas/winch/aarch64/f64_max/params.wat
index 8239e837dd9c..89bf388d8d7e 100644
--- a/tests/disas/winch/aarch64/f64_max/params.wat
+++ b/tests/disas/winch/aarch64/f64_max/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_min/const.wat b/tests/disas/winch/aarch64/f64_min/const.wat
index 3ba2e570ae07..1c82bf3a0a44 100644
--- a/tests/disas/winch/aarch64/f64_min/const.wat
+++ b/tests/disas/winch/aarch64/f64_min/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_min/locals.wat b/tests/disas/winch/aarch64/f64_min/locals.wat
index efb0335ede8f..39fe77875f7b 100644
--- a/tests/disas/winch/aarch64/f64_min/locals.wat
+++ b/tests/disas/winch/aarch64/f64_min/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_min/params.wat b/tests/disas/winch/aarch64/f64_min/params.wat
index 2cfa51a9c6de..ea0847fcb725 100644
--- a/tests/disas/winch/aarch64/f64_min/params.wat
+++ b/tests/disas/winch/aarch64/f64_min/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_mul/const.wat b/tests/disas/winch/aarch64/f64_mul/const.wat
index 10d78f853001..0714e8a0f7be 100644
--- a/tests/disas/winch/aarch64/f64_mul/const.wat
+++ b/tests/disas/winch/aarch64/f64_mul/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_mul/locals.wat b/tests/disas/winch/aarch64/f64_mul/locals.wat
index 37ff8737dc4a..ea474245bd62 100644
--- a/tests/disas/winch/aarch64/f64_mul/locals.wat
+++ b/tests/disas/winch/aarch64/f64_mul/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_mul/params.wat b/tests/disas/winch/aarch64/f64_mul/params.wat
index 0ce42d306edf..6876acbe1091 100644
--- a/tests/disas/winch/aarch64/f64_mul/params.wat
+++ b/tests/disas/winch/aarch64/f64_mul/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ne/const.wat b/tests/disas/winch/aarch64/f64_ne/const.wat
index e56349c91299..b55719ca08fe 100644
--- a/tests/disas/winch/aarch64/f64_ne/const.wat
+++ b/tests/disas/winch/aarch64/f64_ne/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ne/locals.wat b/tests/disas/winch/aarch64/f64_ne/locals.wat
index 88c5c0e4bb2c..1c64391e99cc 100644
--- a/tests/disas/winch/aarch64/f64_ne/locals.wat
+++ b/tests/disas/winch/aarch64/f64_ne/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_ne/params.wat b/tests/disas/winch/aarch64/f64_ne/params.wat
index eecab095f893..d413a0281e81 100644
--- a/tests/disas/winch/aarch64/f64_ne/params.wat
+++ b/tests/disas/winch/aarch64/f64_ne/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat
index c282451517b2..23d44d94c660 100644
--- a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat
+++ b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat
index 1eb236acce6e..303065eb8dae 100644
--- a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat
+++ b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat b/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat
index a5dadf03e04f..f2e05ae2faa0 100644
--- a/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat
+++ b/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat b/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat
index e5246c601820..eac82416a8ac 100644
--- a/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat
+++ b/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/const.wat b/tests/disas/winch/aarch64/f64_promote_f32/const.wat
index 3881c9e8ac2e..d2b9e884681c 100644
--- a/tests/disas/winch/aarch64/f64_promote_f32/const.wat
+++ b/tests/disas/winch/aarch64/f64_promote_f32/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/locals.wat b/tests/disas/winch/aarch64/f64_promote_f32/locals.wat
index 7bdcebc84d40..3cb1fd657c6d 100644
--- a/tests/disas/winch/aarch64/f64_promote_f32/locals.wat
+++ b/tests/disas/winch/aarch64/f64_promote_f32/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/params.wat b/tests/disas/winch/aarch64/f64_promote_f32/params.wat
index c4ccee90006c..edc38c68995c 100644
--- a/tests/disas/winch/aarch64/f64_promote_f32/params.wat
+++ b/tests/disas/winch/aarch64/f64_promote_f32/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_reinterpret_i64/const.wat b/tests/disas/winch/aarch64/f64_reinterpret_i64/const.wat
index f4b345caf680..d8f741c6d035 100644
--- a/tests/disas/winch/aarch64/f64_reinterpret_i64/const.wat
+++ b/tests/disas/winch/aarch64/f64_reinterpret_i64/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_reinterpret_i64/locals.wat b/tests/disas/winch/aarch64/f64_reinterpret_i64/locals.wat
index cac0bf330a54..f88d2fdbd2a3 100644
--- a/tests/disas/winch/aarch64/f64_reinterpret_i64/locals.wat
+++ b/tests/disas/winch/aarch64/f64_reinterpret_i64/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_reinterpret_i64/params.wat b/tests/disas/winch/aarch64/f64_reinterpret_i64/params.wat
index 81fb3d2ec7d2..9ed4f760eb8d 100644
--- a/tests/disas/winch/aarch64/f64_reinterpret_i64/params.wat
+++ b/tests/disas/winch/aarch64/f64_reinterpret_i64/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_reinterpret_i64/ret_int.wat b/tests/disas/winch/aarch64/f64_reinterpret_i64/ret_int.wat
index 2b0a0e1c1755..ed121becfcba 100644
--- a/tests/disas/winch/aarch64/f64_reinterpret_i64/ret_int.wat
+++ b/tests/disas/winch/aarch64/f64_reinterpret_i64/ret_int.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_reinterpret_i64/spilled.wat b/tests/disas/winch/aarch64/f64_reinterpret_i64/spilled.wat
index eafdbe54d154..59209ae17991 100644
--- a/tests/disas/winch/aarch64/f64_reinterpret_i64/spilled.wat
+++ b/tests/disas/winch/aarch64/f64_reinterpret_i64/spilled.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat
index 4f6717f4e792..eaaa75eb7dfb 100644
--- a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat
+++ b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat
index 2eb0e3f979a5..e77e927c6662 100644
--- a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat
+++ b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_sub/const.wat b/tests/disas/winch/aarch64/f64_sub/const.wat
index 43764f1e42a6..5a400a98af72 100644
--- a/tests/disas/winch/aarch64/f64_sub/const.wat
+++ b/tests/disas/winch/aarch64/f64_sub/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_sub/locals.wat b/tests/disas/winch/aarch64/f64_sub/locals.wat
index 2cd82c431aa6..6cad9ea878b5 100644
--- a/tests/disas/winch/aarch64/f64_sub/locals.wat
+++ b/tests/disas/winch/aarch64/f64_sub/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_sub/params.wat b/tests/disas/winch/aarch64/f64_sub/params.wat
index 5657bb44f1f2..099c48014cf4 100644
--- a/tests/disas/winch/aarch64/f64_sub/params.wat
+++ b/tests/disas/winch/aarch64/f64_sub/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat
index d8b8d62ec3cc..869042bfda74 100644
--- a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat
+++ b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat
index 5f5dd911d9db..61bc31f2eaab 100644
--- a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat
+++ b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/const.wat b/tests/disas/winch/aarch64/i32_add/const.wat
index b818dc665004..850ea9d41e04 100644
--- a/tests/disas/winch/aarch64/i32_add/const.wat
+++ b/tests/disas/winch/aarch64/i32_add/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/locals.wat b/tests/disas/winch/aarch64/i32_add/locals.wat
index 948f4257a2ca..6ffda692ea26 100644
--- a/tests/disas/winch/aarch64/i32_add/locals.wat
+++ b/tests/disas/winch/aarch64/i32_add/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/max.wat b/tests/disas/winch/aarch64/i32_add/max.wat
index 8ab1e4f5e6b9..f338322f98d3 100644
--- a/tests/disas/winch/aarch64/i32_add/max.wat
+++ b/tests/disas/winch/aarch64/i32_add/max.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/max_one.wat b/tests/disas/winch/aarch64/i32_add/max_one.wat
index 2043ea0cce27..7386e161a80d 100644
--- a/tests/disas/winch/aarch64/i32_add/max_one.wat
+++ b/tests/disas/winch/aarch64/i32_add/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/mixed.wat b/tests/disas/winch/aarch64/i32_add/mixed.wat
index da1852e2c831..31f26bbfb236 100644
--- a/tests/disas/winch/aarch64/i32_add/mixed.wat
+++ b/tests/disas/winch/aarch64/i32_add/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/params.wat b/tests/disas/winch/aarch64/i32_add/params.wat
index 64ef1faf186f..9422d47f2078 100644
--- a/tests/disas/winch/aarch64/i32_add/params.wat
+++ b/tests/disas/winch/aarch64/i32_add/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/signed.wat b/tests/disas/winch/aarch64/i32_add/signed.wat
index 578a0f781e04..9ef372db31cc 100644
--- a/tests/disas/winch/aarch64/i32_add/signed.wat
+++ b/tests/disas/winch/aarch64/i32_add/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat
index be7d40d9291d..b0041870baa4 100644
--- a/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_and/const.wat b/tests/disas/winch/aarch64/i32_and/const.wat
index 7b6644259968..5c2e28fc831b 100644
--- a/tests/disas/winch/aarch64/i32_and/const.wat
+++ b/tests/disas/winch/aarch64/i32_and/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_and/locals.wat b/tests/disas/winch/aarch64/i32_and/locals.wat
index 22fce6062fe8..bffdf1153003 100644
--- a/tests/disas/winch/aarch64/i32_and/locals.wat
+++ b/tests/disas/winch/aarch64/i32_and/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_and/params.wat b/tests/disas/winch/aarch64/i32_and/params.wat
index 228fb33b06cc..10dfd756a82a 100644
--- a/tests/disas/winch/aarch64/i32_and/params.wat
+++ b/tests/disas/winch/aarch64/i32_and/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_clz/const.wat b/tests/disas/winch/aarch64/i32_clz/const.wat
index 19f4c5e25198..fdf808d73f62 100644
--- a/tests/disas/winch/aarch64/i32_clz/const.wat
+++ b/tests/disas/winch/aarch64/i32_clz/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_clz/locals.wat b/tests/disas/winch/aarch64/i32_clz/locals.wat
index dab258c6e527..12f566ec1575 100644
--- a/tests/disas/winch/aarch64/i32_clz/locals.wat
+++ b/tests/disas/winch/aarch64/i32_clz/locals.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_clz/params.wat b/tests/disas/winch/aarch64/i32_clz/params.wat
index 76a16d2c1c98..761bfc82d752 100644
--- a/tests/disas/winch/aarch64/i32_clz/params.wat
+++ b/tests/disas/winch/aarch64/i32_clz/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ctz/const.wat b/tests/disas/winch/aarch64/i32_ctz/const.wat
index b6d3df3556a0..a259e1b87a82 100644
--- a/tests/disas/winch/aarch64/i32_ctz/const.wat
+++ b/tests/disas/winch/aarch64/i32_ctz/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ctz/locals.wat b/tests/disas/winch/aarch64/i32_ctz/locals.wat
index 746bca8dac6c..0b5c8ac903d2 100644
--- a/tests/disas/winch/aarch64/i32_ctz/locals.wat
+++ b/tests/disas/winch/aarch64/i32_ctz/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ctz/params.wat b/tests/disas/winch/aarch64/i32_ctz/params.wat
index 5408c7dd608f..42ab30f97fc7 100644
--- a/tests/disas/winch/aarch64/i32_ctz/params.wat
+++ b/tests/disas/winch/aarch64/i32_ctz/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divs/const.wat b/tests/disas/winch/aarch64/i32_divs/const.wat
index d7d6de80429b..a5d51e001de4 100644
--- a/tests/disas/winch/aarch64/i32_divs/const.wat
+++ b/tests/disas/winch/aarch64/i32_divs/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divs/one_zero.wat b/tests/disas/winch/aarch64/i32_divs/one_zero.wat
index 986b6ed8f53f..213ad4102093 100644
--- a/tests/disas/winch/aarch64/i32_divs/one_zero.wat
+++ b/tests/disas/winch/aarch64/i32_divs/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divs/overflow.wat b/tests/disas/winch/aarch64/i32_divs/overflow.wat
index 91744ea04be4..69b49015f525 100644
--- a/tests/disas/winch/aarch64/i32_divs/overflow.wat
+++ b/tests/disas/winch/aarch64/i32_divs/overflow.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divs/params.wat b/tests/disas/winch/aarch64/i32_divs/params.wat
index d58e4ab24e8c..d46d10997324 100644
--- a/tests/disas/winch/aarch64/i32_divs/params.wat
+++ b/tests/disas/winch/aarch64/i32_divs/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divs/zero_zero.wat b/tests/disas/winch/aarch64/i32_divs/zero_zero.wat
index e9b30c18cf84..02fd38d6ac17 100644
--- a/tests/disas/winch/aarch64/i32_divs/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i32_divs/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divu/const.wat b/tests/disas/winch/aarch64/i32_divu/const.wat
index f19bd88e8716..45e91b865d15 100644
--- a/tests/disas/winch/aarch64/i32_divu/const.wat
+++ b/tests/disas/winch/aarch64/i32_divu/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divu/one_zero.wat b/tests/disas/winch/aarch64/i32_divu/one_zero.wat
index ad3c8d786bb3..4807a6bb7072 100644
--- a/tests/disas/winch/aarch64/i32_divu/one_zero.wat
+++ b/tests/disas/winch/aarch64/i32_divu/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divu/params.wat b/tests/disas/winch/aarch64/i32_divu/params.wat
index a986893baa5f..193fe021ca0e 100644
--- a/tests/disas/winch/aarch64/i32_divu/params.wat
+++ b/tests/disas/winch/aarch64/i32_divu/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divu/signed.wat b/tests/disas/winch/aarch64/i32_divu/signed.wat
index 15513afb7453..4126c4bbbbd3 100644
--- a/tests/disas/winch/aarch64/i32_divu/signed.wat
+++ b/tests/disas/winch/aarch64/i32_divu/signed.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_divu/zero_zero.wat b/tests/disas/winch/aarch64/i32_divu/zero_zero.wat
index 91ca43118386..8df7fd3a9640 100644
--- a/tests/disas/winch/aarch64/i32_divu/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i32_divu/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_eq/const.wat b/tests/disas/winch/aarch64/i32_eq/const.wat
index 174064af6b1d..a01670c09da4 100644
--- a/tests/disas/winch/aarch64/i32_eq/const.wat
+++ b/tests/disas/winch/aarch64/i32_eq/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_eq/locals.wat b/tests/disas/winch/aarch64/i32_eq/locals.wat
index cbd022a15560..d7ff24453fa3 100644
--- a/tests/disas/winch/aarch64/i32_eq/locals.wat
+++ b/tests/disas/winch/aarch64/i32_eq/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_eq/params.wat b/tests/disas/winch/aarch64/i32_eq/params.wat
index 0ca2158f1616..3a98585c5eb7 100644
--- a/tests/disas/winch/aarch64/i32_eq/params.wat
+++ b/tests/disas/winch/aarch64/i32_eq/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/const.wat b/tests/disas/winch/aarch64/i32_extend_16_s/const.wat
index 172d2771761d..5f78de2e7044 100644
--- a/tests/disas/winch/aarch64/i32_extend_16_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat b/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat
index 39fedc860126..ff0a692eb03c 100644
--- a/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/params.wat b/tests/disas/winch/aarch64/i32_extend_16_s/params.wat
index 35da9a6d780b..a80ff794f4f2 100644
--- a/tests/disas/winch/aarch64/i32_extend_16_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/const.wat b/tests/disas/winch/aarch64/i32_extend_8_s/const.wat
index f49906a76e26..b3f2e42f702a 100644
--- a/tests/disas/winch/aarch64/i32_extend_8_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat b/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat
index 653de9cae5e7..d3ec905c942a 100644
--- a/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/params.wat b/tests/disas/winch/aarch64/i32_extend_8_s/params.wat
index 73d8c7e594c3..de9b75589565 100644
--- a/tests/disas/winch/aarch64/i32_extend_8_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_s/const.wat b/tests/disas/winch/aarch64/i32_ge_s/const.wat
index 125f424ec015..b5060d5dee68 100644
--- a/tests/disas/winch/aarch64/i32_ge_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_ge_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_s/locals.wat b/tests/disas/winch/aarch64/i32_ge_s/locals.wat
index e618662f0580..cb725c5e73f2 100644
--- a/tests/disas/winch/aarch64/i32_ge_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_ge_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_s/params.wat b/tests/disas/winch/aarch64/i32_ge_s/params.wat
index 648460c7a3d5..6ebd7e3cb8b6 100644
--- a/tests/disas/winch/aarch64/i32_ge_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_ge_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_u/const.wat b/tests/disas/winch/aarch64/i32_ge_u/const.wat
index ce894fe37f2a..ce7d54bdce16 100644
--- a/tests/disas/winch/aarch64/i32_ge_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_ge_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_u/locals.wat b/tests/disas/winch/aarch64/i32_ge_u/locals.wat
index d889e9faef89..77f9af041437 100644
--- a/tests/disas/winch/aarch64/i32_ge_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_ge_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ge_u/params.wat b/tests/disas/winch/aarch64/i32_ge_u/params.wat
index a168efc0e4b9..3db94bc06e70 100644
--- a/tests/disas/winch/aarch64/i32_ge_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_ge_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_s/const.wat b/tests/disas/winch/aarch64/i32_gt_s/const.wat
index f003b5d7c1bf..3ff6079ffd2a 100644
--- a/tests/disas/winch/aarch64/i32_gt_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_gt_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_s/locals.wat b/tests/disas/winch/aarch64/i32_gt_s/locals.wat
index 4db4749d3132..62df4bde1288 100644
--- a/tests/disas/winch/aarch64/i32_gt_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_gt_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_s/params.wat b/tests/disas/winch/aarch64/i32_gt_s/params.wat
index 54ee2c1d3b10..1aafc9f4d751 100644
--- a/tests/disas/winch/aarch64/i32_gt_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_gt_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_u/const.wat b/tests/disas/winch/aarch64/i32_gt_u/const.wat
index 64f57ffb0096..276a7211be6e 100644
--- a/tests/disas/winch/aarch64/i32_gt_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_gt_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_u/locals.wat b/tests/disas/winch/aarch64/i32_gt_u/locals.wat
index 34385e628cdd..819dafe22763 100644
--- a/tests/disas/winch/aarch64/i32_gt_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_gt_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_gt_u/params.wat b/tests/disas/winch/aarch64/i32_gt_u/params.wat
index b35087953ff0..b2a47d431831 100644
--- a/tests/disas/winch/aarch64/i32_gt_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_gt_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_s/const.wat b/tests/disas/winch/aarch64/i32_le_s/const.wat
index 86bca45b51ca..e8d6cb441273 100644
--- a/tests/disas/winch/aarch64/i32_le_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_le_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_s/locals.wat b/tests/disas/winch/aarch64/i32_le_s/locals.wat
index 22b4603ada89..3437a6e96adc 100644
--- a/tests/disas/winch/aarch64/i32_le_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_le_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_s/params.wat b/tests/disas/winch/aarch64/i32_le_s/params.wat
index 5cfe3d6c183d..8aafe1a9edf8 100644
--- a/tests/disas/winch/aarch64/i32_le_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_le_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_u/const.wat b/tests/disas/winch/aarch64/i32_le_u/const.wat
index 3f7706d800bd..64d05a939cb1 100644
--- a/tests/disas/winch/aarch64/i32_le_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_le_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_u/locals.wat b/tests/disas/winch/aarch64/i32_le_u/locals.wat
index 06c4c2baae2e..a5b6027b2ec6 100644
--- a/tests/disas/winch/aarch64/i32_le_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_le_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_le_u/params.wat b/tests/disas/winch/aarch64/i32_le_u/params.wat
index 5d4889f851d0..e90d3eb5425d 100644
--- a/tests/disas/winch/aarch64/i32_le_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_le_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_s/const.wat b/tests/disas/winch/aarch64/i32_lt_s/const.wat
index 0e24c40f9353..70f692014eb8 100644
--- a/tests/disas/winch/aarch64/i32_lt_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_lt_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_s/locals.wat b/tests/disas/winch/aarch64/i32_lt_s/locals.wat
index 2cd007707fa1..d9fae47c1f3a 100644
--- a/tests/disas/winch/aarch64/i32_lt_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_lt_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_s/params.wat b/tests/disas/winch/aarch64/i32_lt_s/params.wat
index 8bf50528209c..a6b68da25e58 100644
--- a/tests/disas/winch/aarch64/i32_lt_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_lt_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_u/const.wat b/tests/disas/winch/aarch64/i32_lt_u/const.wat
index 5b2de7d7c735..6ba44007340d 100644
--- a/tests/disas/winch/aarch64/i32_lt_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_lt_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_u/locals.wat b/tests/disas/winch/aarch64/i32_lt_u/locals.wat
index 3f232ca98b39..82bc206f4eb6 100644
--- a/tests/disas/winch/aarch64/i32_lt_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_lt_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_lt_u/params.wat b/tests/disas/winch/aarch64/i32_lt_u/params.wat
index 61caa6632a42..7b8e68a4e2b1 100644
--- a/tests/disas/winch/aarch64/i32_lt_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_lt_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/const.wat b/tests/disas/winch/aarch64/i32_mul/const.wat
index a40aa56040ff..3f110c95685b 100644
--- a/tests/disas/winch/aarch64/i32_mul/const.wat
+++ b/tests/disas/winch/aarch64/i32_mul/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/locals.wat b/tests/disas/winch/aarch64/i32_mul/locals.wat
index e3e22249df1d..7dc2794efc6b 100644
--- a/tests/disas/winch/aarch64/i32_mul/locals.wat
+++ b/tests/disas/winch/aarch64/i32_mul/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/max.wat b/tests/disas/winch/aarch64/i32_mul/max.wat
index ad3b5f45c367..836c5c77d840 100644
--- a/tests/disas/winch/aarch64/i32_mul/max.wat
+++ b/tests/disas/winch/aarch64/i32_mul/max.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/max_one.wat b/tests/disas/winch/aarch64/i32_mul/max_one.wat
index 701c9b2c3ec2..06ec5c574b5f 100644
--- a/tests/disas/winch/aarch64/i32_mul/max_one.wat
+++ b/tests/disas/winch/aarch64/i32_mul/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/mixed.wat b/tests/disas/winch/aarch64/i32_mul/mixed.wat
index b2756397e5af..565c6df872ad 100644
--- a/tests/disas/winch/aarch64/i32_mul/mixed.wat
+++ b/tests/disas/winch/aarch64/i32_mul/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/params.wat b/tests/disas/winch/aarch64/i32_mul/params.wat
index d38cf6acace1..8898e50b4337 100644
--- a/tests/disas/winch/aarch64/i32_mul/params.wat
+++ b/tests/disas/winch/aarch64/i32_mul/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/signed.wat b/tests/disas/winch/aarch64/i32_mul/signed.wat
index 39ab946b1e95..721e09b4b8ef 100644
--- a/tests/disas/winch/aarch64/i32_mul/signed.wat
+++ b/tests/disas/winch/aarch64/i32_mul/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat
index 5034b297d9d9..1eb9119ec736 100644
--- a/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ne/const.wat b/tests/disas/winch/aarch64/i32_ne/const.wat
index 4ceab8b282ff..2aa681553ef7 100644
--- a/tests/disas/winch/aarch64/i32_ne/const.wat
+++ b/tests/disas/winch/aarch64/i32_ne/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ne/locals.wat b/tests/disas/winch/aarch64/i32_ne/locals.wat
index 21cfe665b950..4c01337d5b2c 100644
--- a/tests/disas/winch/aarch64/i32_ne/locals.wat
+++ b/tests/disas/winch/aarch64/i32_ne/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_ne/params.wat b/tests/disas/winch/aarch64/i32_ne/params.wat
index 982489f2351e..4cb4dad04c02 100644
--- a/tests/disas/winch/aarch64/i32_ne/params.wat
+++ b/tests/disas/winch/aarch64/i32_ne/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_or/const.wat b/tests/disas/winch/aarch64/i32_or/const.wat
index 9f74da68b5d5..28daf45d0f3a 100644
--- a/tests/disas/winch/aarch64/i32_or/const.wat
+++ b/tests/disas/winch/aarch64/i32_or/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_or/locals.wat b/tests/disas/winch/aarch64/i32_or/locals.wat
index 934786a33a35..e1739ca0d559 100644
--- a/tests/disas/winch/aarch64/i32_or/locals.wat
+++ b/tests/disas/winch/aarch64/i32_or/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_or/params.wat b/tests/disas/winch/aarch64/i32_or/params.wat
index 5a4c090c96dd..c74a75af5fd9 100644
--- a/tests/disas/winch/aarch64/i32_or/params.wat
+++ b/tests/disas/winch/aarch64/i32_or/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_popcnt/const.wat b/tests/disas/winch/aarch64/i32_popcnt/const.wat
index 2c609efff8d2..c8bf19416b62 100644
--- a/tests/disas/winch/aarch64/i32_popcnt/const.wat
+++ b/tests/disas/winch/aarch64/i32_popcnt/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_popcnt/reg.wat b/tests/disas/winch/aarch64/i32_popcnt/reg.wat
index 6631c371178e..865187d8240b 100644
--- a/tests/disas/winch/aarch64/i32_popcnt/reg.wat
+++ b/tests/disas/winch/aarch64/i32_popcnt/reg.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_reinterpret_f32/const.wat b/tests/disas/winch/aarch64/i32_reinterpret_f32/const.wat
index 364f6163bd3e..318ed76f766b 100644
--- a/tests/disas/winch/aarch64/i32_reinterpret_f32/const.wat
+++ b/tests/disas/winch/aarch64/i32_reinterpret_f32/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_reinterpret_f32/locals.wat b/tests/disas/winch/aarch64/i32_reinterpret_f32/locals.wat
index 511875ba423d..51967500d2d7 100644
--- a/tests/disas/winch/aarch64/i32_reinterpret_f32/locals.wat
+++ b/tests/disas/winch/aarch64/i32_reinterpret_f32/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_reinterpret_f32/params.wat b/tests/disas/winch/aarch64/i32_reinterpret_f32/params.wat
index fdf112c88a50..35c4671591d2 100644
--- a/tests/disas/winch/aarch64/i32_reinterpret_f32/params.wat
+++ b/tests/disas/winch/aarch64/i32_reinterpret_f32/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_reinterpret_f32/ret_float.wat b/tests/disas/winch/aarch64/i32_reinterpret_f32/ret_float.wat
index a02aa83e94df..00d54c8be690 100644
--- a/tests/disas/winch/aarch64/i32_reinterpret_f32/ret_float.wat
+++ b/tests/disas/winch/aarch64/i32_reinterpret_f32/ret_float.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rems/const.wat b/tests/disas/winch/aarch64/i32_rems/const.wat
index 1dd55207fcca..7cb12bd72bb6 100644
--- a/tests/disas/winch/aarch64/i32_rems/const.wat
+++ b/tests/disas/winch/aarch64/i32_rems/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rems/one_zero.wat b/tests/disas/winch/aarch64/i32_rems/one_zero.wat
index 7c1ab97178d9..c68d801478cd 100644
--- a/tests/disas/winch/aarch64/i32_rems/one_zero.wat
+++ b/tests/disas/winch/aarch64/i32_rems/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rems/overflow.wat b/tests/disas/winch/aarch64/i32_rems/overflow.wat
index 7f3b4b955caf..790625f6a627 100644
--- a/tests/disas/winch/aarch64/i32_rems/overflow.wat
+++ b/tests/disas/winch/aarch64/i32_rems/overflow.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rems/params.wat b/tests/disas/winch/aarch64/i32_rems/params.wat
index a2403cabf6f7..785005f19f29 100644
--- a/tests/disas/winch/aarch64/i32_rems/params.wat
+++ b/tests/disas/winch/aarch64/i32_rems/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rems/zero_zero.wat b/tests/disas/winch/aarch64/i32_rems/zero_zero.wat
index 38916079c777..fb0d882a0a93 100644
--- a/tests/disas/winch/aarch64/i32_rems/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i32_rems/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_remu/const.wat b/tests/disas/winch/aarch64/i32_remu/const.wat
index 4f2783da093b..a27361fa4c7a 100644
--- a/tests/disas/winch/aarch64/i32_remu/const.wat
+++ b/tests/disas/winch/aarch64/i32_remu/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_remu/one_zero.wat b/tests/disas/winch/aarch64/i32_remu/one_zero.wat
index d66318f60ce4..9b2bf5874376 100644
--- a/tests/disas/winch/aarch64/i32_remu/one_zero.wat
+++ b/tests/disas/winch/aarch64/i32_remu/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_remu/params.wat b/tests/disas/winch/aarch64/i32_remu/params.wat
index 87609c018457..84928e5ae524 100644
--- a/tests/disas/winch/aarch64/i32_remu/params.wat
+++ b/tests/disas/winch/aarch64/i32_remu/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_remu/signed.wat b/tests/disas/winch/aarch64/i32_remu/signed.wat
index 2683617cbba6..0a082fc3fc94 100644
--- a/tests/disas/winch/aarch64/i32_remu/signed.wat
+++ b/tests/disas/winch/aarch64/i32_remu/signed.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_remu/zero_zero.wat b/tests/disas/winch/aarch64/i32_remu/zero_zero.wat
index 27fdeaa8d410..990d77cb6c02 100644
--- a/tests/disas/winch/aarch64/i32_remu/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i32_remu/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotl/16_const.wat b/tests/disas/winch/aarch64/i32_rotl/16_const.wat
index eb9925098aaf..37326d321236 100644
--- a/tests/disas/winch/aarch64/i32_rotl/16_const.wat
+++ b/tests/disas/winch/aarch64/i32_rotl/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotl/8_const.wat b/tests/disas/winch/aarch64/i32_rotl/8_const.wat
index acf94f9699b0..3eabf9d1d886 100644
--- a/tests/disas/winch/aarch64/i32_rotl/8_const.wat
+++ b/tests/disas/winch/aarch64/i32_rotl/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotl/locals.wat b/tests/disas/winch/aarch64/i32_rotl/locals.wat
index c233229cbd7d..cd5a4c80e859 100644
--- a/tests/disas/winch/aarch64/i32_rotl/locals.wat
+++ b/tests/disas/winch/aarch64/i32_rotl/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotl/params.wat b/tests/disas/winch/aarch64/i32_rotl/params.wat
index f06ebd411a5f..7f212faeb703 100644
--- a/tests/disas/winch/aarch64/i32_rotl/params.wat
+++ b/tests/disas/winch/aarch64/i32_rotl/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotr/16_const.wat b/tests/disas/winch/aarch64/i32_rotr/16_const.wat
index 0638eff7d80f..be3d47e0ced6 100644
--- a/tests/disas/winch/aarch64/i32_rotr/16_const.wat
+++ b/tests/disas/winch/aarch64/i32_rotr/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotr/8_const.wat b/tests/disas/winch/aarch64/i32_rotr/8_const.wat
index 5a67801eab09..3d580d0cd747 100644
--- a/tests/disas/winch/aarch64/i32_rotr/8_const.wat
+++ b/tests/disas/winch/aarch64/i32_rotr/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotr/locals.wat b/tests/disas/winch/aarch64/i32_rotr/locals.wat
index 2fdda7198e67..487dcaa45a93 100644
--- a/tests/disas/winch/aarch64/i32_rotr/locals.wat
+++ b/tests/disas/winch/aarch64/i32_rotr/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_rotr/params.wat b/tests/disas/winch/aarch64/i32_rotr/params.wat
index 4cec175bd2da..b5ab427e9a46 100644
--- a/tests/disas/winch/aarch64/i32_rotr/params.wat
+++ b/tests/disas/winch/aarch64/i32_rotr/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shl/16_const.wat b/tests/disas/winch/aarch64/i32_shl/16_const.wat
index e6218ae600a8..c514707df08f 100644
--- a/tests/disas/winch/aarch64/i32_shl/16_const.wat
+++ b/tests/disas/winch/aarch64/i32_shl/16_const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shl/8_const.wat b/tests/disas/winch/aarch64/i32_shl/8_const.wat
index 46fc30821ed4..6a8f76d38631 100644
--- a/tests/disas/winch/aarch64/i32_shl/8_const.wat
+++ b/tests/disas/winch/aarch64/i32_shl/8_const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shl/imm.wat b/tests/disas/winch/aarch64/i32_shl/imm.wat
index e461a086920b..30be6f54b853 100644
--- a/tests/disas/winch/aarch64/i32_shl/imm.wat
+++ b/tests/disas/winch/aarch64/i32_shl/imm.wat
@@ -20,7 +20,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shl/locals.wat b/tests/disas/winch/aarch64/i32_shl/locals.wat
index b92bdbdfe66f..7b65ad835d14 100644
--- a/tests/disas/winch/aarch64/i32_shl/locals.wat
+++ b/tests/disas/winch/aarch64/i32_shl/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shl/params.wat b/tests/disas/winch/aarch64/i32_shl/params.wat
index 0a20f2009f97..eca9ed5ceb68 100644
--- a/tests/disas/winch/aarch64/i32_shl/params.wat
+++ b/tests/disas/winch/aarch64/i32_shl/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_s/16_const.wat b/tests/disas/winch/aarch64/i32_shr_s/16_const.wat
index cf3223f52915..472f47f6bdee 100644
--- a/tests/disas/winch/aarch64/i32_shr_s/16_const.wat
+++ b/tests/disas/winch/aarch64/i32_shr_s/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_s/8_const.wat b/tests/disas/winch/aarch64/i32_shr_s/8_const.wat
index a81030e56c58..fbeb94489232 100644
--- a/tests/disas/winch/aarch64/i32_shr_s/8_const.wat
+++ b/tests/disas/winch/aarch64/i32_shr_s/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_s/locals.wat b/tests/disas/winch/aarch64/i32_shr_s/locals.wat
index 51592348138a..d50fea4970cc 100644
--- a/tests/disas/winch/aarch64/i32_shr_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_shr_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_s/params.wat b/tests/disas/winch/aarch64/i32_shr_s/params.wat
index 00fe4e4dd9eb..28582df73e6c 100644
--- a/tests/disas/winch/aarch64/i32_shr_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_shr_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_u/16_const.wat b/tests/disas/winch/aarch64/i32_shr_u/16_const.wat
index 8120023842a4..9b20de2f4fde 100644
--- a/tests/disas/winch/aarch64/i32_shr_u/16_const.wat
+++ b/tests/disas/winch/aarch64/i32_shr_u/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_u/8_const.wat b/tests/disas/winch/aarch64/i32_shr_u/8_const.wat
index 76c9f16a9bf6..dfdde7e4b83f 100644
--- a/tests/disas/winch/aarch64/i32_shr_u/8_const.wat
+++ b/tests/disas/winch/aarch64/i32_shr_u/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_u/locals.wat b/tests/disas/winch/aarch64/i32_shr_u/locals.wat
index e571020dd13d..3ab51ab791cc 100644
--- a/tests/disas/winch/aarch64/i32_shr_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_shr_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_shr_u/params.wat b/tests/disas/winch/aarch64/i32_shr_u/params.wat
index 3ea69adf6d1c..2c322c104f0d 100644
--- a/tests/disas/winch/aarch64/i32_shr_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_shr_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/const.wat b/tests/disas/winch/aarch64/i32_sub/const.wat
index 170e593b67a6..a96fa6aa29ae 100644
--- a/tests/disas/winch/aarch64/i32_sub/const.wat
+++ b/tests/disas/winch/aarch64/i32_sub/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/locals.wat b/tests/disas/winch/aarch64/i32_sub/locals.wat
index e5de81a13710..e812acd76a80 100644
--- a/tests/disas/winch/aarch64/i32_sub/locals.wat
+++ b/tests/disas/winch/aarch64/i32_sub/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/max.wat b/tests/disas/winch/aarch64/i32_sub/max.wat
index a92e72c2619e..86b4f7389cf0 100644
--- a/tests/disas/winch/aarch64/i32_sub/max.wat
+++ b/tests/disas/winch/aarch64/i32_sub/max.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/max_one.wat b/tests/disas/winch/aarch64/i32_sub/max_one.wat
index b77e8af2899c..24aecbf04f07 100644
--- a/tests/disas/winch/aarch64/i32_sub/max_one.wat
+++ b/tests/disas/winch/aarch64/i32_sub/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/mixed.wat b/tests/disas/winch/aarch64/i32_sub/mixed.wat
index fd88d2d64f04..2aa6ee199949 100644
--- a/tests/disas/winch/aarch64/i32_sub/mixed.wat
+++ b/tests/disas/winch/aarch64/i32_sub/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/params.wat b/tests/disas/winch/aarch64/i32_sub/params.wat
index f237534dd1f7..c54eb0bee489 100644
--- a/tests/disas/winch/aarch64/i32_sub/params.wat
+++ b/tests/disas/winch/aarch64/i32_sub/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/signed.wat b/tests/disas/winch/aarch64/i32_sub/signed.wat
index beb0c2f2bdd8..3249654ec3b8 100644
--- a/tests/disas/winch/aarch64/i32_sub/signed.wat
+++ b/tests/disas/winch/aarch64/i32_sub/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat
index 4dcb3291f386..5480cc68e38a 100644
--- a/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_s/const.wat b/tests/disas/winch/aarch64/i32_trunc_f32_s/const.wat
index 4f4d735a2f41..facc9a6e1622 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_s/locals.wat b/tests/disas/winch/aarch64/i32_trunc_f32_s/locals.wat
index 13688e2bb331..84977f199dc2 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_s/params.wat b/tests/disas/winch/aarch64/i32_trunc_f32_s/params.wat
index 952bfc6c5644..cb9680876311 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_u/const.wat b/tests/disas/winch/aarch64/i32_trunc_f32_u/const.wat
index 763c3cd0b556..0d9611ce5f54 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_u/locals.wat b/tests/disas/winch/aarch64/i32_trunc_f32_u/locals.wat
index 6bca16f17b30..836899d5970e 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f32_u/params.wat b/tests/disas/winch/aarch64/i32_trunc_f32_u/params.wat
index 50b2af51fe75..cd25adf7f87a 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f32_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f32_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_s/const.wat b/tests/disas/winch/aarch64/i32_trunc_f64_s/const.wat
index 4ef07ae7696c..61ef04b4af93 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_s/const.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_s/locals.wat b/tests/disas/winch/aarch64/i32_trunc_f64_s/locals.wat
index 755fc6da3434..754501d19603 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_s/locals.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_s/params.wat b/tests/disas/winch/aarch64/i32_trunc_f64_s/params.wat
index 70fdf4ae9561..13eae0d3d260 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_s/params.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_u/const.wat b/tests/disas/winch/aarch64/i32_trunc_f64_u/const.wat
index c5837b131135..485fd522a5ae 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_u/const.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_u/locals.wat b/tests/disas/winch/aarch64/i32_trunc_f64_u/locals.wat
index e33cd9aa88ef..ec33a21df0ef 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_u/locals.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_trunc_f64_u/params.wat b/tests/disas/winch/aarch64/i32_trunc_f64_u/params.wat
index b76a63b5f0dd..1fab94827575 100644
--- a/tests/disas/winch/aarch64/i32_trunc_f64_u/params.wat
+++ b/tests/disas/winch/aarch64/i32_trunc_f64_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/const.wat b/tests/disas/winch/aarch64/i32_wrap_i64/const.wat
index b3a645b86942..99a845a2c672 100644
--- a/tests/disas/winch/aarch64/i32_wrap_i64/const.wat
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat b/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat
index 366d9eb2320d..ed5821b56aca 100644
--- a/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/params.wat b/tests/disas/winch/aarch64/i32_wrap_i64/params.wat
index e82beea4ce04..3231f2d9cd68 100644
--- a/tests/disas/winch/aarch64/i32_wrap_i64/params.wat
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_xor/const.wat b/tests/disas/winch/aarch64/i32_xor/const.wat
index 28a1a9246279..58c62c3c0368 100644
--- a/tests/disas/winch/aarch64/i32_xor/const.wat
+++ b/tests/disas/winch/aarch64/i32_xor/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_xor/locals.wat b/tests/disas/winch/aarch64/i32_xor/locals.wat
index bcf4a18a0a38..9d80c9159033 100644
--- a/tests/disas/winch/aarch64/i32_xor/locals.wat
+++ b/tests/disas/winch/aarch64/i32_xor/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i32_xor/params.wat b/tests/disas/winch/aarch64/i32_xor/params.wat
index 043b2f5ee0ce..83696f581477 100644
--- a/tests/disas/winch/aarch64/i32_xor/params.wat
+++ b/tests/disas/winch/aarch64/i32_xor/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/const.wat b/tests/disas/winch/aarch64/i64_add/const.wat
index 102d30ecd4b6..41752786c4b2 100644
--- a/tests/disas/winch/aarch64/i64_add/const.wat
+++ b/tests/disas/winch/aarch64/i64_add/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/locals.wat b/tests/disas/winch/aarch64/i64_add/locals.wat
index 11b9197d8d84..b2a361db13c3 100644
--- a/tests/disas/winch/aarch64/i64_add/locals.wat
+++ b/tests/disas/winch/aarch64/i64_add/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/max.wat b/tests/disas/winch/aarch64/i64_add/max.wat
index 60f084557ced..6006837ee22c 100644
--- a/tests/disas/winch/aarch64/i64_add/max.wat
+++ b/tests/disas/winch/aarch64/i64_add/max.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/max_one.wat b/tests/disas/winch/aarch64/i64_add/max_one.wat
index f7db38aa158a..329340ae9fac 100644
--- a/tests/disas/winch/aarch64/i64_add/max_one.wat
+++ b/tests/disas/winch/aarch64/i64_add/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/mixed.wat b/tests/disas/winch/aarch64/i64_add/mixed.wat
index 923a4fbd37e8..ee3d6c9c8781 100644
--- a/tests/disas/winch/aarch64/i64_add/mixed.wat
+++ b/tests/disas/winch/aarch64/i64_add/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/params.wat b/tests/disas/winch/aarch64/i64_add/params.wat
index 9de34de365fb..9f17658c14a6 100644
--- a/tests/disas/winch/aarch64/i64_add/params.wat
+++ b/tests/disas/winch/aarch64/i64_add/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/signed.wat b/tests/disas/winch/aarch64/i64_add/signed.wat
index 89f6eff45ea0..dbd5808e4778 100644
--- a/tests/disas/winch/aarch64/i64_add/signed.wat
+++ b/tests/disas/winch/aarch64/i64_add/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat
index 5bff617a7d8c..ad99207beddb 100644
--- a/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add128/const.wat b/tests/disas/winch/aarch64/i64_add128/const.wat
index 81d9bc78e882..bce7dc40ef8c 100644
--- a/tests/disas/winch/aarch64/i64_add128/const.wat
+++ b/tests/disas/winch/aarch64/i64_add128/const.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add128/locals.wat b/tests/disas/winch/aarch64/i64_add128/locals.wat
index aa4c1031284d..317a9375401e 100644
--- a/tests/disas/winch/aarch64/i64_add128/locals.wat
+++ b/tests/disas/winch/aarch64/i64_add128/locals.wat
@@ -31,7 +31,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x40
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_add128/params.wat b/tests/disas/winch/aarch64/i64_add128/params.wat
index 5c1a3cfa262b..414fcf5131e5 100644
--- a/tests/disas/winch/aarch64/i64_add128/params.wat
+++ b/tests/disas/winch/aarch64/i64_add128/params.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x40
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_and/32_const.wat b/tests/disas/winch/aarch64/i64_and/32_const.wat
index 701317a5ff11..5ac0c57fc9df 100644
--- a/tests/disas/winch/aarch64/i64_and/32_const.wat
+++ b/tests/disas/winch/aarch64/i64_and/32_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_and/64_const.wat b/tests/disas/winch/aarch64/i64_and/64_const.wat
index 0936cc9eea14..6835ec14dad0 100644
--- a/tests/disas/winch/aarch64/i64_and/64_const.wat
+++ b/tests/disas/winch/aarch64/i64_and/64_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_and/locals.wat b/tests/disas/winch/aarch64/i64_and/locals.wat
index d52dd6c837d0..23e7665bccf4 100644
--- a/tests/disas/winch/aarch64/i64_and/locals.wat
+++ b/tests/disas/winch/aarch64/i64_and/locals.wat
@@ -22,7 +22,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_and/params.wat b/tests/disas/winch/aarch64/i64_and/params.wat
index 45510bcfd580..61297af16db1 100644
--- a/tests/disas/winch/aarch64/i64_and/params.wat
+++ b/tests/disas/winch/aarch64/i64_and/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_clz/const.wat b/tests/disas/winch/aarch64/i64_clz/const.wat
index 572c33c53549..79bf03464168 100644
--- a/tests/disas/winch/aarch64/i64_clz/const.wat
+++ b/tests/disas/winch/aarch64/i64_clz/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_clz/locals.wat b/tests/disas/winch/aarch64/i64_clz/locals.wat
index af061a5d651e..3e5f955c2af4 100644
--- a/tests/disas/winch/aarch64/i64_clz/locals.wat
+++ b/tests/disas/winch/aarch64/i64_clz/locals.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_clz/params.wat b/tests/disas/winch/aarch64/i64_clz/params.wat
index daa41809c894..1ac61debeded 100644
--- a/tests/disas/winch/aarch64/i64_clz/params.wat
+++ b/tests/disas/winch/aarch64/i64_clz/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ctz/const.wat b/tests/disas/winch/aarch64/i64_ctz/const.wat
index 4ba0dc2c5f25..7f30bf94cee5 100644
--- a/tests/disas/winch/aarch64/i64_ctz/const.wat
+++ b/tests/disas/winch/aarch64/i64_ctz/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ctz/locals.wat b/tests/disas/winch/aarch64/i64_ctz/locals.wat
index ff500a861fba..e4143f7c6f19 100644
--- a/tests/disas/winch/aarch64/i64_ctz/locals.wat
+++ b/tests/disas/winch/aarch64/i64_ctz/locals.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ctz/params.wat b/tests/disas/winch/aarch64/i64_ctz/params.wat
index f0d1be9317d5..d9362b1834e2 100644
--- a/tests/disas/winch/aarch64/i64_ctz/params.wat
+++ b/tests/disas/winch/aarch64/i64_ctz/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divs/const.wat b/tests/disas/winch/aarch64/i64_divs/const.wat
index a473f0bf3f70..5732d4c170c2 100644
--- a/tests/disas/winch/aarch64/i64_divs/const.wat
+++ b/tests/disas/winch/aarch64/i64_divs/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divs/one_zero.wat b/tests/disas/winch/aarch64/i64_divs/one_zero.wat
index db2e8b8eda4b..41c3edefaa6a 100644
--- a/tests/disas/winch/aarch64/i64_divs/one_zero.wat
+++ b/tests/disas/winch/aarch64/i64_divs/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divs/overflow.wat b/tests/disas/winch/aarch64/i64_divs/overflow.wat
index 1c42d8b3d886..190e8cb999c5 100644
--- a/tests/disas/winch/aarch64/i64_divs/overflow.wat
+++ b/tests/disas/winch/aarch64/i64_divs/overflow.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divs/params.wat b/tests/disas/winch/aarch64/i64_divs/params.wat
index ab5e3cb5b55f..9fadad6a52e9 100644
--- a/tests/disas/winch/aarch64/i64_divs/params.wat
+++ b/tests/disas/winch/aarch64/i64_divs/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divs/zero_zero.wat b/tests/disas/winch/aarch64/i64_divs/zero_zero.wat
index dafbd375db1d..09e0c9689e22 100644
--- a/tests/disas/winch/aarch64/i64_divs/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i64_divs/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divu/const.wat b/tests/disas/winch/aarch64/i64_divu/const.wat
index 57f9fbe9a63e..a87a1ca95cfc 100644
--- a/tests/disas/winch/aarch64/i64_divu/const.wat
+++ b/tests/disas/winch/aarch64/i64_divu/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divu/one_zero.wat b/tests/disas/winch/aarch64/i64_divu/one_zero.wat
index 531df6c98860..5603cb4abec8 100644
--- a/tests/disas/winch/aarch64/i64_divu/one_zero.wat
+++ b/tests/disas/winch/aarch64/i64_divu/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divu/params.wat b/tests/disas/winch/aarch64/i64_divu/params.wat
index b193a3c18ee2..46e0394b8350 100644
--- a/tests/disas/winch/aarch64/i64_divu/params.wat
+++ b/tests/disas/winch/aarch64/i64_divu/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divu/signed.wat b/tests/disas/winch/aarch64/i64_divu/signed.wat
index 9fbb9cdfb917..9c17b4dca313 100644
--- a/tests/disas/winch/aarch64/i64_divu/signed.wat
+++ b/tests/disas/winch/aarch64/i64_divu/signed.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_divu/zero_zero.wat b/tests/disas/winch/aarch64/i64_divu/zero_zero.wat
index 5491c7148314..d8df3e5a1ae7 100644
--- a/tests/disas/winch/aarch64/i64_divu/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i64_divu/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_eq/const.wat b/tests/disas/winch/aarch64/i64_eq/const.wat
index f7b1aa30f83b..a61112783ec5 100644
--- a/tests/disas/winch/aarch64/i64_eq/const.wat
+++ b/tests/disas/winch/aarch64/i64_eq/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_eq/locals.wat b/tests/disas/winch/aarch64/i64_eq/locals.wat
index 8e928d05d7bd..d2f8457c7934 100644
--- a/tests/disas/winch/aarch64/i64_eq/locals.wat
+++ b/tests/disas/winch/aarch64/i64_eq/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_eq/params.wat b/tests/disas/winch/aarch64/i64_eq/params.wat
index 8653b96ec83b..96a11e514cc5 100644
--- a/tests/disas/winch/aarch64/i64_eq/params.wat
+++ b/tests/disas/winch/aarch64/i64_eq/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/const.wat b/tests/disas/winch/aarch64/i64_extend_16_s/const.wat
index 3487fd32d4f8..c44435ad43fc 100644
--- a/tests/disas/winch/aarch64/i64_extend_16_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat
index 8e5b25d09efc..bf0681272176 100644
--- a/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/params.wat b/tests/disas/winch/aarch64/i64_extend_16_s/params.wat
index cf9b62565fc8..f1b807050976 100644
--- a/tests/disas/winch/aarch64/i64_extend_16_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/const.wat b/tests/disas/winch/aarch64/i64_extend_32_s/const.wat
index 4d002c467655..84a1b5614585 100644
--- a/tests/disas/winch/aarch64/i64_extend_32_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat
index 47ceb283ee71..dc3ce46959bd 100644
--- a/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/params.wat b/tests/disas/winch/aarch64/i64_extend_32_s/params.wat
index a5d2276ae38a..cf469d35488e 100644
--- a/tests/disas/winch/aarch64/i64_extend_32_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/const.wat b/tests/disas/winch/aarch64/i64_extend_8_s/const.wat
index a46396f9c984..de99ebc803f3 100644
--- a/tests/disas/winch/aarch64/i64_extend_8_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat
index 98e65d44be7b..99e1a593b77a 100644
--- a/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/params.wat b/tests/disas/winch/aarch64/i64_extend_8_s/params.wat
index 790e61809c8f..9d0009a8ec2a 100644
--- a/tests/disas/winch/aarch64/i64_extend_8_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat
index 4f1d25699683..57098ec88c32 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat
index 0b5cacb67b35..145a52facc0e 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat
index df4690a40bdd..5919c9df5a39 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat
index 2bf439af39be..d46daeb6eb66 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat
index 000c8fcf2d9b..7ecd64177444 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat
index d4f8cca15eb4..b8b6ff53c748 100644
--- a/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_s/const.wat b/tests/disas/winch/aarch64/i64_ge_s/const.wat
index ddba54890181..6433d073cba2 100644
--- a/tests/disas/winch/aarch64/i64_ge_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_ge_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_s/locals.wat b/tests/disas/winch/aarch64/i64_ge_s/locals.wat
index 8d12f808f9d2..c869c0b24b35 100644
--- a/tests/disas/winch/aarch64/i64_ge_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_ge_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_s/params.wat b/tests/disas/winch/aarch64/i64_ge_s/params.wat
index 7943a27543a3..2f63fe16d164 100644
--- a/tests/disas/winch/aarch64/i64_ge_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_ge_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_u/const.wat b/tests/disas/winch/aarch64/i64_ge_u/const.wat
index 335541feb548..4ecef87abe36 100644
--- a/tests/disas/winch/aarch64/i64_ge_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_ge_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_u/locals.wat b/tests/disas/winch/aarch64/i64_ge_u/locals.wat
index 024bb2f3d682..81da578c44aa 100644
--- a/tests/disas/winch/aarch64/i64_ge_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_ge_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ge_u/params.wat b/tests/disas/winch/aarch64/i64_ge_u/params.wat
index d1b3dbae91e5..67ce3ef044fc 100644
--- a/tests/disas/winch/aarch64/i64_ge_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_ge_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_s/const.wat b/tests/disas/winch/aarch64/i64_gt_s/const.wat
index 9299ea60b6c0..e5fef630e0a9 100644
--- a/tests/disas/winch/aarch64/i64_gt_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_gt_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_s/locals.wat b/tests/disas/winch/aarch64/i64_gt_s/locals.wat
index 10fcff1406ab..a02297de1866 100644
--- a/tests/disas/winch/aarch64/i64_gt_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_gt_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_s/params.wat b/tests/disas/winch/aarch64/i64_gt_s/params.wat
index 309e9a4973f4..5b116fcc6a05 100644
--- a/tests/disas/winch/aarch64/i64_gt_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_gt_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_u/const.wat b/tests/disas/winch/aarch64/i64_gt_u/const.wat
index 5d475e8f57c0..8d92669455f8 100644
--- a/tests/disas/winch/aarch64/i64_gt_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_gt_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_u/locals.wat b/tests/disas/winch/aarch64/i64_gt_u/locals.wat
index ec10a5845a70..ac5abf78c849 100644
--- a/tests/disas/winch/aarch64/i64_gt_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_gt_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_gt_u/params.wat b/tests/disas/winch/aarch64/i64_gt_u/params.wat
index 8175904e6165..6cba031e04e1 100644
--- a/tests/disas/winch/aarch64/i64_gt_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_gt_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_s/const.wat b/tests/disas/winch/aarch64/i64_le_s/const.wat
index 37927ff9c845..c2509b9296fa 100644
--- a/tests/disas/winch/aarch64/i64_le_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_le_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_s/locals.wat b/tests/disas/winch/aarch64/i64_le_s/locals.wat
index b56de390deff..6c9527cc12aa 100644
--- a/tests/disas/winch/aarch64/i64_le_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_le_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_s/params.wat b/tests/disas/winch/aarch64/i64_le_s/params.wat
index 4627650a9dc2..8847dad9a077 100644
--- a/tests/disas/winch/aarch64/i64_le_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_le_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_u/const.wat b/tests/disas/winch/aarch64/i64_le_u/const.wat
index c20894d8286b..da6f67ff3467 100644
--- a/tests/disas/winch/aarch64/i64_le_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_le_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_u/locals.wat b/tests/disas/winch/aarch64/i64_le_u/locals.wat
index 5ae9fc75e214..8101207b1f37 100644
--- a/tests/disas/winch/aarch64/i64_le_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_le_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_le_u/params.wat b/tests/disas/winch/aarch64/i64_le_u/params.wat
index 0fed7f35b854..5894c06ea323 100644
--- a/tests/disas/winch/aarch64/i64_le_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_le_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_s/const.wat b/tests/disas/winch/aarch64/i64_lt_s/const.wat
index e5d3e902f208..6721878da427 100644
--- a/tests/disas/winch/aarch64/i64_lt_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_lt_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_s/locals.wat b/tests/disas/winch/aarch64/i64_lt_s/locals.wat
index 0698084a8384..114d64e2efe5 100644
--- a/tests/disas/winch/aarch64/i64_lt_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_lt_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_s/params.wat b/tests/disas/winch/aarch64/i64_lt_s/params.wat
index 03d54d22d128..4e54a8e5bcb5 100644
--- a/tests/disas/winch/aarch64/i64_lt_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_lt_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_u/const.wat b/tests/disas/winch/aarch64/i64_lt_u/const.wat
index 402498df338d..432ce639878b 100644
--- a/tests/disas/winch/aarch64/i64_lt_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_lt_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_u/locals.wat b/tests/disas/winch/aarch64/i64_lt_u/locals.wat
index 7eda9a772bcf..55f68efee960 100644
--- a/tests/disas/winch/aarch64/i64_lt_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_lt_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_lt_u/params.wat b/tests/disas/winch/aarch64/i64_lt_u/params.wat
index 232cc9eb0bec..8ff7e01c3082 100644
--- a/tests/disas/winch/aarch64/i64_lt_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_lt_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/const.wat b/tests/disas/winch/aarch64/i64_mul/const.wat
index 12a7d9f945d0..4598e2ad1bb4 100644
--- a/tests/disas/winch/aarch64/i64_mul/const.wat
+++ b/tests/disas/winch/aarch64/i64_mul/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/locals.wat b/tests/disas/winch/aarch64/i64_mul/locals.wat
index de6ad80030a5..d8f31d2f5129 100644
--- a/tests/disas/winch/aarch64/i64_mul/locals.wat
+++ b/tests/disas/winch/aarch64/i64_mul/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/max.wat b/tests/disas/winch/aarch64/i64_mul/max.wat
index 865d07733c3f..b8d9cce32dbf 100644
--- a/tests/disas/winch/aarch64/i64_mul/max.wat
+++ b/tests/disas/winch/aarch64/i64_mul/max.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/max_one.wat b/tests/disas/winch/aarch64/i64_mul/max_one.wat
index 7fc0d1c6d5c5..0db867dfe02a 100644
--- a/tests/disas/winch/aarch64/i64_mul/max_one.wat
+++ b/tests/disas/winch/aarch64/i64_mul/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/mixed.wat b/tests/disas/winch/aarch64/i64_mul/mixed.wat
index 60fd1cb98de4..a6cda1c67286 100644
--- a/tests/disas/winch/aarch64/i64_mul/mixed.wat
+++ b/tests/disas/winch/aarch64/i64_mul/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/params.wat b/tests/disas/winch/aarch64/i64_mul/params.wat
index 771250cac37c..dcb17c172176 100644
--- a/tests/disas/winch/aarch64/i64_mul/params.wat
+++ b/tests/disas/winch/aarch64/i64_mul/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/signed.wat b/tests/disas/winch/aarch64/i64_mul/signed.wat
index 7fdbf9957afb..7ca899044add 100644
--- a/tests/disas/winch/aarch64/i64_mul/signed.wat
+++ b/tests/disas/winch/aarch64/i64_mul/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat
index 584e92226178..30d26c51659d 100644
--- a/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_s/const.wat b/tests/disas/winch/aarch64/i64_mul_wide_s/const.wat
index 75ef79057f5d..0cc5e4d9e090 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_s/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_s/locals.wat b/tests/disas/winch/aarch64/i64_mul_wide_s/locals.wat
index 762d188cbeb9..b13f521fc45a 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x30
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_s/params.wat b/tests/disas/winch/aarch64/i64_mul_wide_s/params.wat
index 8eebdf5d9d68..76b3f12f80dd 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_s/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x30
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_u/const.wat b/tests/disas/winch/aarch64/i64_mul_wide_u/const.wat
index 209d9b965fd6..f99072a8b304 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_u/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_u/locals.wat b/tests/disas/winch/aarch64/i64_mul_wide_u/locals.wat
index 727f970fa1e2..8316008779d3 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x30
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_mul_wide_u/params.wat b/tests/disas/winch/aarch64/i64_mul_wide_u/params.wat
index 6b859e8564a5..bfc1a17cf9a0 100644
--- a/tests/disas/winch/aarch64/i64_mul_wide_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_mul_wide_u/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x30
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ne/const.wat b/tests/disas/winch/aarch64/i64_ne/const.wat
index a7adea92523c..d73ffd92d57e 100644
--- a/tests/disas/winch/aarch64/i64_ne/const.wat
+++ b/tests/disas/winch/aarch64/i64_ne/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ne/locals.wat b/tests/disas/winch/aarch64/i64_ne/locals.wat
index 7ea216c42653..3ddee6d78b90 100644
--- a/tests/disas/winch/aarch64/i64_ne/locals.wat
+++ b/tests/disas/winch/aarch64/i64_ne/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_ne/params.wat b/tests/disas/winch/aarch64/i64_ne/params.wat
index a53e0350ba1a..f7fbb44818f0 100644
--- a/tests/disas/winch/aarch64/i64_ne/params.wat
+++ b/tests/disas/winch/aarch64/i64_ne/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_or/32_const.wat b/tests/disas/winch/aarch64/i64_or/32_const.wat
index a114f3be7a09..561b8bdebe29 100644
--- a/tests/disas/winch/aarch64/i64_or/32_const.wat
+++ b/tests/disas/winch/aarch64/i64_or/32_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_or/64_const.wat b/tests/disas/winch/aarch64/i64_or/64_const.wat
index a03d45ba5889..1172ac1bca47 100644
--- a/tests/disas/winch/aarch64/i64_or/64_const.wat
+++ b/tests/disas/winch/aarch64/i64_or/64_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_or/locals.wat b/tests/disas/winch/aarch64/i64_or/locals.wat
index 7d97918638dc..fec29f908436 100644
--- a/tests/disas/winch/aarch64/i64_or/locals.wat
+++ b/tests/disas/winch/aarch64/i64_or/locals.wat
@@ -22,7 +22,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_or/params.wat b/tests/disas/winch/aarch64/i64_or/params.wat
index 345f9f27334b..9fdc7378a0eb 100644
--- a/tests/disas/winch/aarch64/i64_or/params.wat
+++ b/tests/disas/winch/aarch64/i64_or/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_popcnt/const.wat b/tests/disas/winch/aarch64/i64_popcnt/const.wat
index 48004afb7f85..4a5ae61d7ddd 100644
--- a/tests/disas/winch/aarch64/i64_popcnt/const.wat
+++ b/tests/disas/winch/aarch64/i64_popcnt/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_popcnt/reg.wat b/tests/disas/winch/aarch64/i64_popcnt/reg.wat
index 4e9b62e897f0..7380831f1fb1 100644
--- a/tests/disas/winch/aarch64/i64_popcnt/reg.wat
+++ b/tests/disas/winch/aarch64/i64_popcnt/reg.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_reinterpret_f64/const.wat b/tests/disas/winch/aarch64/i64_reinterpret_f64/const.wat
index 0decd85f733a..7788f71e8ce2 100644
--- a/tests/disas/winch/aarch64/i64_reinterpret_f64/const.wat
+++ b/tests/disas/winch/aarch64/i64_reinterpret_f64/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_reinterpret_f64/locals.wat b/tests/disas/winch/aarch64/i64_reinterpret_f64/locals.wat
index e904bd3d6998..e939d8fc3454 100644
--- a/tests/disas/winch/aarch64/i64_reinterpret_f64/locals.wat
+++ b/tests/disas/winch/aarch64/i64_reinterpret_f64/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_reinterpret_f64/params.wat b/tests/disas/winch/aarch64/i64_reinterpret_f64/params.wat
index e27d91ff99a1..8224d440c1e0 100644
--- a/tests/disas/winch/aarch64/i64_reinterpret_f64/params.wat
+++ b/tests/disas/winch/aarch64/i64_reinterpret_f64/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_reinterpret_f64/ret_float.wat b/tests/disas/winch/aarch64/i64_reinterpret_f64/ret_float.wat
index cc487b589e5a..cffc570c3c6d 100644
--- a/tests/disas/winch/aarch64/i64_reinterpret_f64/ret_float.wat
+++ b/tests/disas/winch/aarch64/i64_reinterpret_f64/ret_float.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rems/const.wat b/tests/disas/winch/aarch64/i64_rems/const.wat
index 8eda0b34d9db..eda7eec84892 100644
--- a/tests/disas/winch/aarch64/i64_rems/const.wat
+++ b/tests/disas/winch/aarch64/i64_rems/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rems/one_zero.wat b/tests/disas/winch/aarch64/i64_rems/one_zero.wat
index 2588838c9656..902007939aec 100644
--- a/tests/disas/winch/aarch64/i64_rems/one_zero.wat
+++ b/tests/disas/winch/aarch64/i64_rems/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rems/overflow.wat b/tests/disas/winch/aarch64/i64_rems/overflow.wat
index 0eaddad5e895..dea39cd28221 100644
--- a/tests/disas/winch/aarch64/i64_rems/overflow.wat
+++ b/tests/disas/winch/aarch64/i64_rems/overflow.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rems/params.wat b/tests/disas/winch/aarch64/i64_rems/params.wat
index dbd7d098b634..4d67550c83fd 100644
--- a/tests/disas/winch/aarch64/i64_rems/params.wat
+++ b/tests/disas/winch/aarch64/i64_rems/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rems/zero_zero.wat b/tests/disas/winch/aarch64/i64_rems/zero_zero.wat
index 094b91cb88c4..7d708a077e18 100644
--- a/tests/disas/winch/aarch64/i64_rems/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i64_rems/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_remu/const.wat b/tests/disas/winch/aarch64/i64_remu/const.wat
index e3c10f5fee45..cf498bbd6505 100644
--- a/tests/disas/winch/aarch64/i64_remu/const.wat
+++ b/tests/disas/winch/aarch64/i64_remu/const.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_remu/one_zero.wat b/tests/disas/winch/aarch64/i64_remu/one_zero.wat
index 46f6ca87f65c..26a002fba281 100644
--- a/tests/disas/winch/aarch64/i64_remu/one_zero.wat
+++ b/tests/disas/winch/aarch64/i64_remu/one_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_remu/params.wat b/tests/disas/winch/aarch64/i64_remu/params.wat
index 228e28cacc91..97b911cb2746 100644
--- a/tests/disas/winch/aarch64/i64_remu/params.wat
+++ b/tests/disas/winch/aarch64/i64_remu/params.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_remu/signed.wat b/tests/disas/winch/aarch64/i64_remu/signed.wat
index 64c633319bbc..7a8d9ea3907c 100644
--- a/tests/disas/winch/aarch64/i64_remu/signed.wat
+++ b/tests/disas/winch/aarch64/i64_remu/signed.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_remu/zero_zero.wat b/tests/disas/winch/aarch64/i64_remu/zero_zero.wat
index e8b753d72cff..a23eff2bf267 100644
--- a/tests/disas/winch/aarch64/i64_remu/zero_zero.wat
+++ b/tests/disas/winch/aarch64/i64_remu/zero_zero.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotl/16_const.wat b/tests/disas/winch/aarch64/i64_rotl/16_const.wat
index 6ba4f1b2b4e2..02afc56ec5a2 100644
--- a/tests/disas/winch/aarch64/i64_rotl/16_const.wat
+++ b/tests/disas/winch/aarch64/i64_rotl/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotl/8_const.wat b/tests/disas/winch/aarch64/i64_rotl/8_const.wat
index e7c365fecfe6..e1511613c0da 100644
--- a/tests/disas/winch/aarch64/i64_rotl/8_const.wat
+++ b/tests/disas/winch/aarch64/i64_rotl/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotl/locals.wat b/tests/disas/winch/aarch64/i64_rotl/locals.wat
index afe7551560ad..bfabc426f20d 100644
--- a/tests/disas/winch/aarch64/i64_rotl/locals.wat
+++ b/tests/disas/winch/aarch64/i64_rotl/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotl/params.wat b/tests/disas/winch/aarch64/i64_rotl/params.wat
index 9af86f7f4b90..52d7b36745dd 100644
--- a/tests/disas/winch/aarch64/i64_rotl/params.wat
+++ b/tests/disas/winch/aarch64/i64_rotl/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotr/16_const.wat b/tests/disas/winch/aarch64/i64_rotr/16_const.wat
index 30615964a7ba..44e1ff4ab77a 100644
--- a/tests/disas/winch/aarch64/i64_rotr/16_const.wat
+++ b/tests/disas/winch/aarch64/i64_rotr/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotr/8_const.wat b/tests/disas/winch/aarch64/i64_rotr/8_const.wat
index e75e137821ef..63d3b08fbe58 100644
--- a/tests/disas/winch/aarch64/i64_rotr/8_const.wat
+++ b/tests/disas/winch/aarch64/i64_rotr/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotr/locals.wat b/tests/disas/winch/aarch64/i64_rotr/locals.wat
index 7814ee3ec5b3..d996a6356c7b 100644
--- a/tests/disas/winch/aarch64/i64_rotr/locals.wat
+++ b/tests/disas/winch/aarch64/i64_rotr/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_rotr/params.wat b/tests/disas/winch/aarch64/i64_rotr/params.wat
index acdae7783fbc..fe6b0b28dd50 100644
--- a/tests/disas/winch/aarch64/i64_rotr/params.wat
+++ b/tests/disas/winch/aarch64/i64_rotr/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shl/16_const.wat b/tests/disas/winch/aarch64/i64_shl/16_const.wat
index 7e2b7dca8c8f..7516139f8927 100644
--- a/tests/disas/winch/aarch64/i64_shl/16_const.wat
+++ b/tests/disas/winch/aarch64/i64_shl/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shl/8_const.wat b/tests/disas/winch/aarch64/i64_shl/8_const.wat
index 33624f6402c2..04811f9dc2ae 100644
--- a/tests/disas/winch/aarch64/i64_shl/8_const.wat
+++ b/tests/disas/winch/aarch64/i64_shl/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shl/imm.wat b/tests/disas/winch/aarch64/i64_shl/imm.wat
index 3ef058814b47..4e43963b78f5 100644
--- a/tests/disas/winch/aarch64/i64_shl/imm.wat
+++ b/tests/disas/winch/aarch64/i64_shl/imm.wat
@@ -20,7 +20,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shl/locals.wat b/tests/disas/winch/aarch64/i64_shl/locals.wat
index 5746339cd786..16055238b847 100644
--- a/tests/disas/winch/aarch64/i64_shl/locals.wat
+++ b/tests/disas/winch/aarch64/i64_shl/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shl/params.wat b/tests/disas/winch/aarch64/i64_shl/params.wat
index 948d8f63614e..a12d7a7e89bd 100644
--- a/tests/disas/winch/aarch64/i64_shl/params.wat
+++ b/tests/disas/winch/aarch64/i64_shl/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_s/16_const.wat b/tests/disas/winch/aarch64/i64_shr_s/16_const.wat
index 8b330a72355a..dcd3fd9c9cb9 100644
--- a/tests/disas/winch/aarch64/i64_shr_s/16_const.wat
+++ b/tests/disas/winch/aarch64/i64_shr_s/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_s/8_const.wat b/tests/disas/winch/aarch64/i64_shr_s/8_const.wat
index 5f71d5e50353..6ef9287d29a7 100644
--- a/tests/disas/winch/aarch64/i64_shr_s/8_const.wat
+++ b/tests/disas/winch/aarch64/i64_shr_s/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_s/locals.wat b/tests/disas/winch/aarch64/i64_shr_s/locals.wat
index 80c561af51cd..f5a18a096268 100644
--- a/tests/disas/winch/aarch64/i64_shr_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_shr_s/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_s/params.wat b/tests/disas/winch/aarch64/i64_shr_s/params.wat
index 26d365b09b1c..7142d056c6fc 100644
--- a/tests/disas/winch/aarch64/i64_shr_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_shr_s/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_u/16_const.wat b/tests/disas/winch/aarch64/i64_shr_u/16_const.wat
index 953059471da0..c4992d704ba1 100644
--- a/tests/disas/winch/aarch64/i64_shr_u/16_const.wat
+++ b/tests/disas/winch/aarch64/i64_shr_u/16_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_u/8_const.wat b/tests/disas/winch/aarch64/i64_shr_u/8_const.wat
index 05443b2058ca..8cf6369d9696 100644
--- a/tests/disas/winch/aarch64/i64_shr_u/8_const.wat
+++ b/tests/disas/winch/aarch64/i64_shr_u/8_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_u/locals.wat b/tests/disas/winch/aarch64/i64_shr_u/locals.wat
index 79c440498eaa..4449906d1a2e 100644
--- a/tests/disas/winch/aarch64/i64_shr_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_shr_u/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_shr_u/params.wat b/tests/disas/winch/aarch64/i64_shr_u/params.wat
index 171e66896a6e..0392cd8fe331 100644
--- a/tests/disas/winch/aarch64/i64_shr_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_shr_u/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/const.wat b/tests/disas/winch/aarch64/i64_sub/const.wat
index 506efd919c08..b335377de8aa 100644
--- a/tests/disas/winch/aarch64/i64_sub/const.wat
+++ b/tests/disas/winch/aarch64/i64_sub/const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/locals.wat b/tests/disas/winch/aarch64/i64_sub/locals.wat
index 31c1954fed50..0599c3a601d3 100644
--- a/tests/disas/winch/aarch64/i64_sub/locals.wat
+++ b/tests/disas/winch/aarch64/i64_sub/locals.wat
@@ -23,7 +23,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/max.wat b/tests/disas/winch/aarch64/i64_sub/max.wat
index eeb5eb55c762..affb2ebd226b 100644
--- a/tests/disas/winch/aarch64/i64_sub/max.wat
+++ b/tests/disas/winch/aarch64/i64_sub/max.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/max_one.wat b/tests/disas/winch/aarch64/i64_sub/max_one.wat
index bc35fbdc23c8..dc4b29794776 100644
--- a/tests/disas/winch/aarch64/i64_sub/max_one.wat
+++ b/tests/disas/winch/aarch64/i64_sub/max_one.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/mixed.wat b/tests/disas/winch/aarch64/i64_sub/mixed.wat
index 0b09e0a0982d..2d5566e7b221 100644
--- a/tests/disas/winch/aarch64/i64_sub/mixed.wat
+++ b/tests/disas/winch/aarch64/i64_sub/mixed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/params.wat b/tests/disas/winch/aarch64/i64_sub/params.wat
index f1c7957fd3f9..12a2fe3acbf5 100644
--- a/tests/disas/winch/aarch64/i64_sub/params.wat
+++ b/tests/disas/winch/aarch64/i64_sub/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/signed.wat b/tests/disas/winch/aarch64/i64_sub/signed.wat
index 8646e2d6e993..05429118ccfc 100644
--- a/tests/disas/winch/aarch64/i64_sub/signed.wat
+++ b/tests/disas/winch/aarch64/i64_sub/signed.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat
index 2616a22bef43..8ae6b5d5f512 100644
--- a/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat
+++ b/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub128/const.wat b/tests/disas/winch/aarch64/i64_sub128/const.wat
index f82c87a34e28..f411cd9cc637 100644
--- a/tests/disas/winch/aarch64/i64_sub128/const.wat
+++ b/tests/disas/winch/aarch64/i64_sub128/const.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub128/locals.wat b/tests/disas/winch/aarch64/i64_sub128/locals.wat
index c4c72772b77e..bad949d2e1bd 100644
--- a/tests/disas/winch/aarch64/i64_sub128/locals.wat
+++ b/tests/disas/winch/aarch64/i64_sub128/locals.wat
@@ -31,7 +31,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x40
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_sub128/params.wat b/tests/disas/winch/aarch64/i64_sub128/params.wat
index 4a1cd9e9db55..0c671196f267 100644
--- a/tests/disas/winch/aarch64/i64_sub128/params.wat
+++ b/tests/disas/winch/aarch64/i64_sub128/params.wat
@@ -17,7 +17,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x40
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_s/const.wat b/tests/disas/winch/aarch64/i64_trunc_f32_s/const.wat
index e14528b2e7f8..a3ec1ed295c2 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_s/locals.wat b/tests/disas/winch/aarch64/i64_trunc_f32_s/locals.wat
index 7d36d6007189..4b44f44f032e 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_s/params.wat b/tests/disas/winch/aarch64/i64_trunc_f32_s/params.wat
index d0372028e022..1e2b87572928 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_u/const.wat b/tests/disas/winch/aarch64/i64_trunc_f32_u/const.wat
index 1598802cb1e3..ca714d1f96b0 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_u/locals.wat b/tests/disas/winch/aarch64/i64_trunc_f32_u/locals.wat
index 08a8bd36592a..572e8e58ab23 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f32_u/params.wat b/tests/disas/winch/aarch64/i64_trunc_f32_u/params.wat
index c610c0f26f2b..c7af55872866 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f32_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f32_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_s/const.wat b/tests/disas/winch/aarch64/i64_trunc_f64_s/const.wat
index 29c8b6061f28..e2acbb0b2974 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_s/const.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_s/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_s/locals.wat b/tests/disas/winch/aarch64/i64_trunc_f64_s/locals.wat
index f1388b5ea588..34f5f9cc4d33 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_s/locals.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_s/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_s/params.wat b/tests/disas/winch/aarch64/i64_trunc_f64_s/params.wat
index d2b08fc6ed6c..0753a1fc9963 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_s/params.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_s/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_u/const.wat b/tests/disas/winch/aarch64/i64_trunc_f64_u/const.wat
index bbd70652f329..3613d5f2eefd 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_u/const.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_u/const.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_u/locals.wat b/tests/disas/winch/aarch64/i64_trunc_f64_u/locals.wat
index 57650d46e3d0..bae428c5bab5 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_u/locals.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_u/locals.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_trunc_f64_u/params.wat b/tests/disas/winch/aarch64/i64_trunc_f64_u/params.wat
index 9d90577e3798..5a38fcb755c8 100644
--- a/tests/disas/winch/aarch64/i64_trunc_f64_u/params.wat
+++ b/tests/disas/winch/aarch64/i64_trunc_f64_u/params.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_xor/32_const.wat b/tests/disas/winch/aarch64/i64_xor/32_const.wat
index ad6a589ee6e8..ee9ec7054cbe 100644
--- a/tests/disas/winch/aarch64/i64_xor/32_const.wat
+++ b/tests/disas/winch/aarch64/i64_xor/32_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_xor/64_const.wat b/tests/disas/winch/aarch64/i64_xor/64_const.wat
index e4ebb3a367cd..d766023a0b9b 100644
--- a/tests/disas/winch/aarch64/i64_xor/64_const.wat
+++ b/tests/disas/winch/aarch64/i64_xor/64_const.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_xor/locals.wat b/tests/disas/winch/aarch64/i64_xor/locals.wat
index 1128d8a06351..c202b6931e0a 100644
--- a/tests/disas/winch/aarch64/i64_xor/locals.wat
+++ b/tests/disas/winch/aarch64/i64_xor/locals.wat
@@ -22,7 +22,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/i64_xor/params.wat b/tests/disas/winch/aarch64/i64_xor/params.wat
index a7f49ff93393..49ced84fee9b 100644
--- a/tests/disas/winch/aarch64/i64_xor/params.wat
+++ b/tests/disas/winch/aarch64/i64_xor/params.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/load/dynamic_heap.wat b/tests/disas/winch/aarch64/load/dynamic_heap.wat
index c827bd2c0148..556befd8230e 100644
--- a/tests/disas/winch/aarch64/load/dynamic_heap.wat
+++ b/tests/disas/winch/aarch64/load/dynamic_heap.wat
@@ -25,7 +25,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x28
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/load/f32.wat b/tests/disas/winch/aarch64/load/f32.wat
index 3ee254c03934..40bbf2ea7c9b 100644
--- a/tests/disas/winch/aarch64/load/f32.wat
+++ b/tests/disas/winch/aarch64/load/f32.wat
@@ -12,7 +12,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/load/f64.wat b/tests/disas/winch/aarch64/load/f64.wat
index 2062d38adee5..fc6fbc65f64e 100644
--- a/tests/disas/winch/aarch64/load/f64.wat
+++ b/tests/disas/winch/aarch64/load/f64.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/load/i32.wat b/tests/disas/winch/aarch64/load/i32.wat
index 9f5352c77b40..94d7ed03d100 100644
--- a/tests/disas/winch/aarch64/load/i32.wat
+++ b/tests/disas/winch/aarch64/load/i32.wat
@@ -12,7 +12,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/load/i64.wat b/tests/disas/winch/aarch64/load/i64.wat
index fdac97c76879..6e4142a19ba9 100644
--- a/tests/disas/winch/aarch64/load/i64.wat
+++ b/tests/disas/winch/aarch64/load/i64.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x18
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/memory_offsets/index.wat b/tests/disas/winch/aarch64/memory_offsets/index.wat
index a87638f4dcde..6f02a660d128 100644
--- a/tests/disas/winch/aarch64/memory_offsets/index.wat
+++ b/tests/disas/winch/aarch64/memory_offsets/index.wat
@@ -548,7 +548,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0xf10
 ;;       add     x16, x16, x17
@@ -1105,7 +1105,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x84
 ;;       add     x16, x16, x17
@@ -1222,7 +1222,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x84
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/nop/nop.wat b/tests/disas/winch/aarch64/nop/nop.wat
index e92726cacd6d..7b0839b3f7b7 100644
--- a/tests/disas/winch/aarch64/nop/nop.wat
+++ b/tests/disas/winch/aarch64/nop/nop.wat
@@ -12,7 +12,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/params/400_params.wat b/tests/disas/winch/aarch64/params/400_params.wat
index 5e72929bc690..4816fd2d418c 100644
--- a/tests/disas/winch/aarch64/params/400_params.wat
+++ b/tests/disas/winch/aarch64/params/400_params.wat
@@ -55,7 +55,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x28
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/params/multi_values.wat b/tests/disas/winch/aarch64/params/multi_values.wat
index dc7f8d1e1544..a2a7532f14bb 100644
--- a/tests/disas/winch/aarch64/params/multi_values.wat
+++ b/tests/disas/winch/aarch64/params/multi_values.wat
@@ -15,7 +15,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x1, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x34
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/store/dynamic_heap.wat b/tests/disas/winch/aarch64/store/dynamic_heap.wat
index fbdd29e2ccbf..baeb380c1c66 100644
--- a/tests/disas/winch/aarch64/store/dynamic_heap.wat
+++ b/tests/disas/winch/aarch64/store/dynamic_heap.wat
@@ -25,7 +25,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x20
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/store/f32.wat b/tests/disas/winch/aarch64/store/f32.wat
index bd1a0b2b2999..09c41237eeac 100644
--- a/tests/disas/winch/aarch64/store/f32.wat
+++ b/tests/disas/winch/aarch64/store/f32.wat
@@ -11,7 +11,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/store/f64.wat b/tests/disas/winch/aarch64/store/f64.wat
index 747d650d0fd6..50ad79f535a5 100644
--- a/tests/disas/winch/aarch64/store/f64.wat
+++ b/tests/disas/winch/aarch64/store/f64.wat
@@ -12,7 +12,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/store/i32.wat b/tests/disas/winch/aarch64/store/i32.wat
index ce49529717c2..76fbca167996 100644
--- a/tests/disas/winch/aarch64/store/i32.wat
+++ b/tests/disas/winch/aarch64/store/i32.wat
@@ -13,7 +13,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/aarch64/store/i64.wat b/tests/disas/winch/aarch64/store/i64.wat
index 900585b6e91e..25957ffede08 100644
--- a/tests/disas/winch/aarch64/store/i64.wat
+++ b/tests/disas/winch/aarch64/store/i64.wat
@@ -14,7 +14,7 @@
 ;;       str     x28, [sp, #-0x10]!
 ;;       mov     x28, sp
 ;;       ldur    x16, [x0, #8]
-;;       ldur    x16, [x16, #0x18]
+;;       ldur    x16, [x16, #0x20]
 ;;       mov     x17, #0
 ;;       movk    x17, #0x10
 ;;       add     x16, x16, x17
diff --git a/tests/disas/winch/x64/atomic/fence/fence.wat b/tests/disas/winch/x64/atomic/fence/fence.wat
index 9b4a4b038f7d..d15339164027 100644
--- a/tests/disas/winch/x64/atomic/fence/fence.wat
+++ b/tests/disas/winch/x64/atomic/fence/fence.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/atomic/load/i32_atomic_load.wat b/tests/disas/winch/x64/atomic/load/i32_atomic_load.wat
index fca088c46530..d76e2f1a5fc5 100644
--- a/tests/disas/winch/x64/atomic/load/i32_atomic_load.wat
+++ b/tests/disas/winch/x64/atomic/load/i32_atomic_load.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/atomic/load/i32_atomic_load16_u.wat b/tests/disas/winch/x64/atomic/load/i32_atomic_load16_u.wat
index 23c7a08f2a8f..63f5bdd75049 100644
--- a/tests/disas/winch/x64/atomic/load/i32_atomic_load16_u.wat
+++ b/tests/disas/winch/x64/atomic/load/i32_atomic_load16_u.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x63
diff --git a/tests/disas/winch/x64/atomic/load/i32_atomic_load8_u.wat b/tests/disas/winch/x64/atomic/load/i32_atomic_load8_u.wat
index 2a4454b864c2..098e1db24ed1 100644
--- a/tests/disas/winch/x64/atomic/load/i32_atomic_load8_u.wat
+++ b/tests/disas/winch/x64/atomic/load/i32_atomic_load8_u.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/atomic/load/i64_atomic_load.wat b/tests/disas/winch/x64/atomic/load/i64_atomic_load.wat
index 697736c04641..ee2101d2e513 100644
--- a/tests/disas/winch/x64/atomic/load/i64_atomic_load.wat
+++ b/tests/disas/winch/x64/atomic/load/i64_atomic_load.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/atomic/load/i64_atomic_load16_u.wat b/tests/disas/winch/x64/atomic/load/i64_atomic_load16_u.wat
index 133549a68b84..67fd8f36ed5a 100644
--- a/tests/disas/winch/x64/atomic/load/i64_atomic_load16_u.wat
+++ b/tests/disas/winch/x64/atomic/load/i64_atomic_load16_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/atomic/load/i64_atomic_load32_u.wat b/tests/disas/winch/x64/atomic/load/i64_atomic_load32_u.wat
index 70a7f10f307b..738df91b72d8 100644
--- a/tests/disas/winch/x64/atomic/load/i64_atomic_load32_u.wat
+++ b/tests/disas/winch/x64/atomic/load/i64_atomic_load32_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/atomic/load/i64_atomic_load8_u.wat b/tests/disas/winch/x64/atomic/load/i64_atomic_load8_u.wat
index 33ffb6d7e81b..b380d9c63bee 100644
--- a/tests/disas/winch/x64/atomic/load/i64_atomic_load8_u.wat
+++ b/tests/disas/winch/x64/atomic/load/i64_atomic_load8_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/atomic/load/large_offset.wat b/tests/disas/winch/x64/atomic/load/large_offset.wat
index 1654aba209da..beb8544c0939 100644
--- a/tests/disas/winch/x64/atomic/load/large_offset.wat
+++ b/tests/disas/winch/x64/atomic/load/large_offset.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9c
diff --git a/tests/disas/winch/x64/atomic/notify/notify.wat b/tests/disas/winch/x64/atomic/notify/notify.wat
index 98d426f5984e..5df49d0c573d 100644
--- a/tests/disas/winch/x64/atomic/notify/notify.wat
+++ b/tests/disas/winch/x64/atomic/notify/notify.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/atomic/notify/notify_offset.wat b/tests/disas/winch/x64/atomic/notify/notify_offset.wat
index 19e54fba9884..340fe55d51e6 100644
--- a/tests/disas/winch/x64/atomic/notify/notify_offset.wat
+++ b/tests/disas/winch/x64/atomic/notify/notify_offset.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw16_addu.wat b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw16_addu.wat
index cc0edf24a2e4..8acc36d08ef6 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw16_addu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw16_addu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6a
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw8_addu.wat b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw8_addu.wat
index a84a3ddaefd9..0e5d82e301fc 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw8_addu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw8_addu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw_add.wat b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw_add.wat
index abc3c93bd8c4..baa73e72a6a5 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw_add.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i32_atomic_rmw_add.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw16_addu.wat b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw16_addu.wat
index 52c9c73f40cf..f07f7bbd94f1 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw16_addu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw16_addu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw32_addu.wat b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw32_addu.wat
index 7ae8f457866b..fb2d6e194346 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw32_addu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw32_addu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw8_addu.wat b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw8_addu.wat
index 102171394539..c204acdc207b 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw8_addu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw8_addu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw_add.wat b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw_add.wat
index 0d78dcbbf21a..d2f0560573b7 100644
--- a/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw_add.wat
+++ b/tests/disas/winch/x64/atomic/rmw/add/i64_atomic_rmw_add.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw16_andu.wat b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw16_andu.wat
index 2216fe92bd4f..d707dd92123d 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw16_andu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw16_andu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8f
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw8_andu.wat b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw8_andu.wat
index 805b4be84cb6..073c788de509 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw8_andu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw8_andu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7a
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw_and.wat b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw_and.wat
index 9f7d6cac30ee..742852f80d0d 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw_and.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i32_atomic_rmw_and.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw16_andu.wat b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw16_andu.wat
index 2dd9023fba25..463f716be2e5 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw16_andu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw16_andu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7e
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw32_andu.wat b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw32_andu.wat
index ebeac1c6e077..01305e116791 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw32_andu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw32_andu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw8_andu.wat b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw8_andu.wat
index 0a6d9e215cb6..2f2e148c7bcf 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw8_andu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw8_andu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw_and.wat b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw_and.wat
index cbb085743c35..e5c026eee6ec 100644
--- a/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw_and.wat
+++ b/tests/disas/winch/x64/atomic/rmw/and/i64_atomic_rmw_and.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw16_cmpxchgu.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw16_cmpxchgu.wat
index bc8c92da9492..145ac6bb149c 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw16_cmpxchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw16_cmpxchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x97
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw8_cmpxchgu.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw8_cmpxchgu.wat
index 4bd5ff094b6c..8948f2fbeae3 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw8_cmpxchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw8_cmpxchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw_cmpxchg.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw_cmpxchg.wat
index d2e923d3fbbf..38bd9467833e 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw_cmpxchg.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i32_atomic_rmw_cmpxchg.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x93
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw16_cmpxchgu.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw16_cmpxchgu.wat
index c0cb871d2124..ab6c4598ba26 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw16_cmpxchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw16_cmpxchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x74
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu.wat
index a6c3a954e728..972685c038d8 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu_extend.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu_extend.wat
index 1221f51cda28..d32ab1f44e16 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu_extend.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw32_cmpxchgu_extend.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x76
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw8_cmpxchgu.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw8_cmpxchgu.wat
index 96898ac61b72..fcda3ba289fc 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw8_cmpxchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw8_cmpxchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5f
diff --git a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw_cmpxchg.wat b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw_cmpxchg.wat
index a1a39590babe..a3b05084393c 100644
--- a/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw_cmpxchg.wat
+++ b/tests/disas/winch/x64/atomic/rmw/cmpxchg/i64_atomic_rmw_cmpxchg.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x70
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw16_oru.wat b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw16_oru.wat
index 329eb5169e7f..a5ce38d2b248 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw16_oru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw16_oru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8f
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw8_oru.wat b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw8_oru.wat
index 59b2b5d1bd7d..d550f0e2e5bd 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw8_oru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw8_oru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7a
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw_or.wat b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw_or.wat
index 1472e2d27f46..7cd842998932 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw_or.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i32_atomic_rmw_or.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw16_oru.wat b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw16_oru.wat
index cb5c1ee3d6c0..82e78aecd219 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw16_oru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw16_oru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7e
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw32_oru.wat b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw32_oru.wat
index 56f38739df90..f90a9634ee37 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw32_oru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw32_oru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw8_oru.wat b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw8_oru.wat
index 78a1f3acf9ff..fd1ecbc01cb5 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw8_oru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw8_oru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw_or.wat b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw_or.wat
index c68efac93053..de6691bd63f2 100644
--- a/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw_or.wat
+++ b/tests/disas/winch/x64/atomic/rmw/or/i64_atomic_rmw_or.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw16_subu.wat b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw16_subu.wat
index bdb0064801b7..cf782445c01d 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw16_subu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw16_subu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6d
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw8_subu.wat b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw8_subu.wat
index e2b8981c78f1..d23b48f1a454 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw8_subu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw8_subu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw_sub.wat b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw_sub.wat
index 92c60396b4ce..45d2a93b3a65 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw_sub.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i32_atomic_rmw_sub.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw16_subu.wat b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw16_subu.wat
index cf0eace16faf..aa0ee2c33a97 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw16_subu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw16_subu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw32_subu.wat b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw32_subu.wat
index 889b0e3dfd3c..c29de012e019 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw32_subu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw32_subu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw8_subu.wat b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw8_subu.wat
index 3dccc0cffa14..96354dc1fd1e 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw8_subu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw8_subu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw_sub.wat b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw_sub.wat
index 1d7e8d2e2093..43474f070147 100644
--- a/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw_sub.wat
+++ b/tests/disas/winch/x64/atomic/rmw/sub/i64_atomic_rmw_sub.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6a
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw16_xchgu.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw16_xchgu.wat
index 5e3fed76ef09..3030a6df55f9 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw16_xchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw16_xchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw8_xchgu.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw8_xchgu.wat
index d8d3e86abc7f..77a4bc64f321 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw8_xchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw8_xchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw_xchg.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw_xchg.wat
index a243a60fbbee..f5c9dcef719b 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw_xchg.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i32_atomic_rmw_xchg.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw16_xchgu.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw16_xchgu.wat
index be1c50a0c4d8..dc1031d85d36 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw16_xchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw16_xchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw32_xchgu.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw32_xchgu.wat
index 87230d713330..8d2d55b18482 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw32_xchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw32_xchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw8_xchgu.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw8_xchgu.wat
index d3ee516b4fbb..c1effab70f3c 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw8_xchgu.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw8_xchgu.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw_xchg.wat b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw_xchg.wat
index 9af4d5c28fff..acab631267a0 100644
--- a/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw_xchg.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xchg/i64_atomic_rmw_xchg.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw16_xoru.wat b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw16_xoru.wat
index 2dd77dbff676..0dcb4a2372f4 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw16_xoru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw16_xoru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8f
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw8_xoru.wat b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw8_xoru.wat
index 5c9253842bce..21695ad9d3fb 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw8_xoru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw8_xoru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7a
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw_xor.wat b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw_xor.wat
index cf0e18bd0931..37a9ec4a5a98 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw_xor.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i32_atomic_rmw_xor.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw16_xoru.wat b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw16_xoru.wat
index d557a144e396..7b55fcdadd2b 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw16_xoru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw16_xoru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7e
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw32_xoru.wat b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw32_xoru.wat
index e86fb4dac9d8..667e43534996 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw32_xoru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw32_xoru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw8_xoru.wat b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw8_xoru.wat
index fc8fdb115c1c..0155573e17a5 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw8_xoru.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw8_xoru.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw_xor.wat b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw_xor.wat
index 5125257018f2..b33efc009f21 100644
--- a/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw_xor.wat
+++ b/tests/disas/winch/x64/atomic/rmw/xor/i64_atomic_rmw_xor.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/atomic/store/i32_atomic_store.wat b/tests/disas/winch/x64/atomic/store/i32_atomic_store.wat
index a900070a58c7..19a405ef8fd5 100644
--- a/tests/disas/winch/x64/atomic/store/i32_atomic_store.wat
+++ b/tests/disas/winch/x64/atomic/store/i32_atomic_store.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/atomic/store/i32_atomic_store16.wat b/tests/disas/winch/x64/atomic/store/i32_atomic_store16.wat
index b0462762f7c8..77ff4ee67177 100644
--- a/tests/disas/winch/x64/atomic/store/i32_atomic_store16.wat
+++ b/tests/disas/winch/x64/atomic/store/i32_atomic_store16.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/store/i32_atomic_store8.wat b/tests/disas/winch/x64/atomic/store/i32_atomic_store8.wat
index 18ff87528199..72b6c18ebe81 100644
--- a/tests/disas/winch/x64/atomic/store/i32_atomic_store8.wat
+++ b/tests/disas/winch/x64/atomic/store/i32_atomic_store8.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/atomic/store/i64_atomic_store.wat b/tests/disas/winch/x64/atomic/store/i64_atomic_store.wat
index 776e6e434bed..ee67f9cb2c08 100644
--- a/tests/disas/winch/x64/atomic/store/i64_atomic_store.wat
+++ b/tests/disas/winch/x64/atomic/store/i64_atomic_store.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/store/i64_atomic_store16.wat b/tests/disas/winch/x64/atomic/store/i64_atomic_store16.wat
index 4adc0c894a7d..a8b168cf6df4 100644
--- a/tests/disas/winch/x64/atomic/store/i64_atomic_store16.wat
+++ b/tests/disas/winch/x64/atomic/store/i64_atomic_store16.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/atomic/store/i64_atomic_store32.wat b/tests/disas/winch/x64/atomic/store/i64_atomic_store32.wat
index c8a7d91f62eb..788a8be49240 100644
--- a/tests/disas/winch/x64/atomic/store/i64_atomic_store32.wat
+++ b/tests/disas/winch/x64/atomic/store/i64_atomic_store32.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/atomic/store/i64_atomic_store8.wat b/tests/disas/winch/x64/atomic/store/i64_atomic_store8.wat
index a84bb1000752..88132ba6d1f3 100644
--- a/tests/disas/winch/x64/atomic/store/i64_atomic_store8.wat
+++ b/tests/disas/winch/x64/atomic/store/i64_atomic_store8.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/atomic/wait/wait32.wat b/tests/disas/winch/x64/atomic/wait/wait32.wat
index 3142b7dfc04c..e051e06b5ad1 100644
--- a/tests/disas/winch/x64/atomic/wait/wait32.wat
+++ b/tests/disas/winch/x64/atomic/wait/wait32.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/atomic/wait/wait32_offset.wat b/tests/disas/winch/x64/atomic/wait/wait32_offset.wat
index 97c31b9c885c..150d13047d54 100644
--- a/tests/disas/winch/x64/atomic/wait/wait32_offset.wat
+++ b/tests/disas/winch/x64/atomic/wait/wait32_offset.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x97
diff --git a/tests/disas/winch/x64/atomic/wait/wait64.wat b/tests/disas/winch/x64/atomic/wait/wait64.wat
index f9d488d6d5b9..627f74bb4b6e 100644
--- a/tests/disas/winch/x64/atomic/wait/wait64.wat
+++ b/tests/disas/winch/x64/atomic/wait/wait64.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/atomic/wait/wait64_offset.wat b/tests/disas/winch/x64/atomic/wait/wait64_offset.wat
index 584073f39ca0..f9addcc06a3d 100644
--- a/tests/disas/winch/x64/atomic/wait/wait64_offset.wat
+++ b/tests/disas/winch/x64/atomic/wait/wait64_offset.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8f
diff --git a/tests/disas/winch/x64/block/as_if_cond.wat b/tests/disas/winch/x64/block/as_if_cond.wat
index 3fbcc9e31c80..c9272c77b7da 100644
--- a/tests/disas/winch/x64/block/as_if_cond.wat
+++ b/tests/disas/winch/x64/block/as_if_cond.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/block/as_if_else.wat b/tests/disas/winch/x64/block/as_if_else.wat
index 2aa95c608954..c82c24635380 100644
--- a/tests/disas/winch/x64/block/as_if_else.wat
+++ b/tests/disas/winch/x64/block/as_if_else.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/block/as_if_then.wat b/tests/disas/winch/x64/block/as_if_then.wat
index 20406c39129a..38b60b437aac 100644
--- a/tests/disas/winch/x64/block/as_if_then.wat
+++ b/tests/disas/winch/x64/block/as_if_then.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/block/deep.wat b/tests/disas/winch/x64/block/deep.wat
index 0b47440b568a..24cec0800d38 100644
--- a/tests/disas/winch/x64/block/deep.wat
+++ b/tests/disas/winch/x64/block/deep.wat
@@ -49,7 +49,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -66,7 +66,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/block/empty.wat b/tests/disas/winch/x64/block/empty.wat
index 0d720cba1278..0609483e8113 100644
--- a/tests/disas/winch/x64/block/empty.wat
+++ b/tests/disas/winch/x64/block/empty.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/block/get_and_set.wat b/tests/disas/winch/x64/block/get_and_set.wat
index 4e3068cd1fd8..931894d56a4f 100644
--- a/tests/disas/winch/x64/block/get_and_set.wat
+++ b/tests/disas/winch/x64/block/get_and_set.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/block/get_and_tee.wat b/tests/disas/winch/x64/block/get_and_tee.wat
index f9bdf3385292..914b77ede0e9 100644
--- a/tests/disas/winch/x64/block/get_and_tee.wat
+++ b/tests/disas/winch/x64/block/get_and_tee.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/block/issue-10613.wat b/tests/disas/winch/x64/block/issue-10613.wat
index 3e953da4af66..00fb506dc6ae 100644
--- a/tests/disas/winch/x64/block/issue-10613.wat
+++ b/tests/disas/winch/x64/block/issue-10613.wat
@@ -24,7 +24,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x40, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x108
@@ -87,7 +87,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x28, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x16f
@@ -118,7 +118,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x28, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x1df
diff --git a/tests/disas/winch/x64/block/nested.wat b/tests/disas/winch/x64/block/nested.wat
index c01545d8ed80..f55c4f9b9fa1 100644
--- a/tests/disas/winch/x64/block/nested.wat
+++ b/tests/disas/winch/x64/block/nested.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9d
diff --git a/tests/disas/winch/x64/block/singular.wat b/tests/disas/winch/x64/block/singular.wat
index c8a552377556..d762476b8992 100644
--- a/tests/disas/winch/x64/block/singular.wat
+++ b/tests/disas/winch/x64/block/singular.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/block/with_local_float.wat b/tests/disas/winch/x64/block/with_local_float.wat
index 0d6ea1391061..3c0554e656e7 100644
--- a/tests/disas/winch/x64/block/with_local_float.wat
+++ b/tests/disas/winch/x64/block/with_local_float.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5f
diff --git a/tests/disas/winch/x64/br/as_block_first.wat b/tests/disas/winch/x64/br/as_block_first.wat
index 36d7900e6ad0..5f1bacd62c39 100644
--- a/tests/disas/winch/x64/br/as_block_first.wat
+++ b/tests/disas/winch/x64/br/as_block_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/br/as_block_last.wat b/tests/disas/winch/x64/br/as_block_last.wat
index db65d326e751..65ee615f3d4b 100644
--- a/tests/disas/winch/x64/br/as_block_last.wat
+++ b/tests/disas/winch/x64/br/as_block_last.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/br/as_block_mid.wat b/tests/disas/winch/x64/br/as_block_mid.wat
index 4243546498ec..440a2bc598a6 100644
--- a/tests/disas/winch/x64/br/as_block_mid.wat
+++ b/tests/disas/winch/x64/br/as_block_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/br/as_block_value.wat b/tests/disas/winch/x64/br/as_block_value.wat
index 3e620e63f354..7f032c86e5b6 100644
--- a/tests/disas/winch/x64/br/as_block_value.wat
+++ b/tests/disas/winch/x64/br/as_block_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_br_if_cond.wat b/tests/disas/winch/x64/br/as_br_if_cond.wat
index 0006dc805923..1ae3f8ef93d1 100644
--- a/tests/disas/winch/x64/br/as_br_if_cond.wat
+++ b/tests/disas/winch/x64/br/as_br_if_cond.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
diff --git a/tests/disas/winch/x64/br/as_br_value.wat b/tests/disas/winch/x64/br/as_br_value.wat
index 056b2d4e31d5..31dd046a7bf0 100644
--- a/tests/disas/winch/x64/br/as_br_value.wat
+++ b/tests/disas/winch/x64/br/as_br_value.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/br/as_call_all.wat b/tests/disas/winch/x64/br/as_call_all.wat
index 833e9b37aefd..e983b5f17a93 100644
--- a/tests/disas/winch/x64/br/as_call_all.wat
+++ b/tests/disas/winch/x64/br/as_call_all.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_call_first.wat b/tests/disas/winch/x64/br/as_call_first.wat
index 6052c055dfd0..1fb6c256ace8 100644
--- a/tests/disas/winch/x64/br/as_call_first.wat
+++ b/tests/disas/winch/x64/br/as_call_first.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -34,7 +34,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_call_last.wat b/tests/disas/winch/x64/br/as_call_last.wat
index 2923d1ab5bf5..15d9432b63b0 100644
--- a/tests/disas/winch/x64/br/as_call_last.wat
+++ b/tests/disas/winch/x64/br/as_call_last.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -33,7 +33,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_call_mid.wat b/tests/disas/winch/x64/br/as_call_mid.wat
index b6aadf073fb8..a415c4527b73 100644
--- a/tests/disas/winch/x64/br/as_call_mid.wat
+++ b/tests/disas/winch/x64/br/as_call_mid.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -34,7 +34,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_if_cond.wat b/tests/disas/winch/x64/br/as_if_cond.wat
index 541112e12bc8..aace09aa4d70 100644
--- a/tests/disas/winch/x64/br/as_if_cond.wat
+++ b/tests/disas/winch/x64/br/as_if_cond.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/br/as_if_else.wat b/tests/disas/winch/x64/br/as_if_else.wat
index 4f5f9828e5ae..1b2157bec62c 100644
--- a/tests/disas/winch/x64/br/as_if_else.wat
+++ b/tests/disas/winch/x64/br/as_if_else.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/br/as_if_then.wat b/tests/disas/winch/x64/br/as_if_then.wat
index 353aae158f94..a1ca7e37680a 100644
--- a/tests/disas/winch/x64/br/as_if_then.wat
+++ b/tests/disas/winch/x64/br/as_if_then.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/br/as_loop_first.wat b/tests/disas/winch/x64/br/as_loop_first.wat
index de9d125410bc..d901fdeaa91f 100644
--- a/tests/disas/winch/x64/br/as_loop_first.wat
+++ b/tests/disas/winch/x64/br/as_loop_first.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/br/as_loop_last.wat b/tests/disas/winch/x64/br/as_loop_last.wat
index 8e9097717c23..0564ada18ba3 100644
--- a/tests/disas/winch/x64/br/as_loop_last.wat
+++ b/tests/disas/winch/x64/br/as_loop_last.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/as_loop_mid.wat b/tests/disas/winch/x64/br/as_loop_mid.wat
index a709808c15e4..88c52dbc2719 100644
--- a/tests/disas/winch/x64/br/as_loop_mid.wat
+++ b/tests/disas/winch/x64/br/as_loop_mid.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/br/br_jump.wat b/tests/disas/winch/x64/br/br_jump.wat
index 720c996853c4..ce207ceafcc6 100644
--- a/tests/disas/winch/x64/br/br_jump.wat
+++ b/tests/disas/winch/x64/br/br_jump.wat
@@ -17,7 +17,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x28, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/br_if/as_block_last.wat b/tests/disas/winch/x64/br_if/as_block_last.wat
index 52f99f1dad2e..fa44fed18b73 100644
--- a/tests/disas/winch/x64/br_if/as_block_last.wat
+++ b/tests/disas/winch/x64/br_if/as_block_last.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa9
diff --git a/tests/disas/winch/x64/br_if/as_block_last_value.wat b/tests/disas/winch/x64/br_if/as_block_last_value.wat
index ca20f699e911..d801aeab1c67 100644
--- a/tests/disas/winch/x64/br_if/as_block_last_value.wat
+++ b/tests/disas/winch/x64/br_if/as_block_last_value.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xae
diff --git a/tests/disas/winch/x64/br_if/as_br_if_cond.wat b/tests/disas/winch/x64/br_if/as_br_if_cond.wat
index af94f4b14e4f..db7780250859 100644
--- a/tests/disas/winch/x64/br_if/as_br_if_cond.wat
+++ b/tests/disas/winch/x64/br_if/as_br_if_cond.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x52
diff --git a/tests/disas/winch/x64/br_if/as_br_value.wat b/tests/disas/winch/x64/br_if/as_br_value.wat
index 92cc7f5baa38..e736620bad42 100644
--- a/tests/disas/winch/x64/br_if/as_br_value.wat
+++ b/tests/disas/winch/x64/br_if/as_br_value.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/br_if/as_call_first.wat b/tests/disas/winch/x64/br_if/as_call_first.wat
index 6eca24863bfa..0fb6b3844309 100644
--- a/tests/disas/winch/x64/br_if/as_call_first.wat
+++ b/tests/disas/winch/x64/br_if/as_call_first.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -35,7 +35,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xd8
diff --git a/tests/disas/winch/x64/br_if/as_call_last.wat b/tests/disas/winch/x64/br_if/as_call_last.wat
index 42294ab378bf..8dab29aaa78b 100644
--- a/tests/disas/winch/x64/br_if/as_call_last.wat
+++ b/tests/disas/winch/x64/br_if/as_call_last.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -35,7 +35,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xd8
diff --git a/tests/disas/winch/x64/br_if/as_call_mid.wat b/tests/disas/winch/x64/br_if/as_call_mid.wat
index d2c4cbffcd2b..533418683450 100644
--- a/tests/disas/winch/x64/br_if/as_call_mid.wat
+++ b/tests/disas/winch/x64/br_if/as_call_mid.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -35,7 +35,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xd8
diff --git a/tests/disas/winch/x64/br_if/as_if_cond.wat b/tests/disas/winch/x64/br_if/as_if_cond.wat
index e1b26ce0533a..9583e326fcef 100644
--- a/tests/disas/winch/x64/br_if/as_if_cond.wat
+++ b/tests/disas/winch/x64/br_if/as_if_cond.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/br_if/as_if_else.wat b/tests/disas/winch/x64/br_if/as_if_else.wat
index 4ce0489447bb..92d65216e384 100644
--- a/tests/disas/winch/x64/br_if/as_if_else.wat
+++ b/tests/disas/winch/x64/br_if/as_if_else.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xae
diff --git a/tests/disas/winch/x64/br_if/as_if_then.wat b/tests/disas/winch/x64/br_if/as_if_then.wat
index 822d3338d42d..eeb97765d5ca 100644
--- a/tests/disas/winch/x64/br_if/as_if_then.wat
+++ b/tests/disas/winch/x64/br_if/as_if_then.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xae
diff --git a/tests/disas/winch/x64/br_if/as_local_set_value.wat b/tests/disas/winch/x64/br_if/as_local_set_value.wat
index bb8dc207952b..16fed463568e 100644
--- a/tests/disas/winch/x64/br_if/as_local_set_value.wat
+++ b/tests/disas/winch/x64/br_if/as_local_set_value.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x62
diff --git a/tests/disas/winch/x64/br_if/as_loop_last.wat b/tests/disas/winch/x64/br_if/as_loop_last.wat
index b352d1496b84..640dfe9e7e87 100644
--- a/tests/disas/winch/x64/br_if/as_loop_last.wat
+++ b/tests/disas/winch/x64/br_if/as_loop_last.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x99
diff --git a/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat b/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat
index 25d2ced3137a..13511e8e94cb 100644
--- a/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat
+++ b/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat
@@ -41,7 +41,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x58, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x130
diff --git a/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat b/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat
index 498f165a8ff2..335fe723c6d4 100644
--- a/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat
+++ b/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8b
@@ -50,7 +50,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xcd
diff --git a/tests/disas/winch/x64/br_table/ensure_sp_state.wat b/tests/disas/winch/x64/br_table/ensure_sp_state.wat
index 30724bb8170f..d25b640d748c 100644
--- a/tests/disas/winch/x64/br_table/ensure_sp_state.wat
+++ b/tests/disas/winch/x64/br_table/ensure_sp_state.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/br_table/large.wat b/tests/disas/winch/x64/br_table/large.wat
index b1e2103c274b..4722b9b738d9 100644
--- a/tests/disas/winch/x64/br_table/large.wat
+++ b/tests/disas/winch/x64/br_table/large.wat
@@ -742,7 +742,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x1810b
diff --git a/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat b/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat
index a830f74dfc51..2a06dd55ce99 100644
--- a/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat
+++ b/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat
@@ -22,7 +22,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa6
diff --git a/tests/disas/winch/x64/br_table/stack_handling.wat b/tests/disas/winch/x64/br_table/stack_handling.wat
index 3d6638041044..5b57605edfd6 100644
--- a/tests/disas/winch/x64/br_table/stack_handling.wat
+++ b/tests/disas/winch/x64/br_table/stack_handling.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x91
diff --git a/tests/disas/winch/x64/br_table/use-innermost-frame.wat b/tests/disas/winch/x64/br_table/use-innermost-frame.wat
index c29aaa5d5fe6..2b7c31069f40 100644
--- a/tests/disas/winch/x64/br_table/use-innermost-frame.wat
+++ b/tests/disas/winch/x64/br_table/use-innermost-frame.wat
@@ -1946,7 +1946,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x161
@@ -2023,7 +2023,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x980, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a84
@@ -2419,7 +2419,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4bf1
diff --git a/tests/disas/winch/x64/call/multi.wat b/tests/disas/winch/x64/call/multi.wat
index 13d97b4b634b..24d1c0d7862d 100644
--- a/tests/disas/winch/x64/call/multi.wat
+++ b/tests/disas/winch/x64/call/multi.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
@@ -39,7 +39,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xd9
diff --git a/tests/disas/winch/x64/call/params.wat b/tests/disas/winch/x64/call/params.wat
index 87dc038ac545..267631ce0737 100644
--- a/tests/disas/winch/x64/call/params.wat
+++ b/tests/disas/winch/x64/call/params.wat
@@ -40,7 +40,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x60, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x182
@@ -123,7 +123,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x20a
diff --git a/tests/disas/winch/x64/call/recursive.wat b/tests/disas/winch/x64/call/recursive.wat
index 4eb4b2e0671e..c014bf50e32a 100644
--- a/tests/disas/winch/x64/call/recursive.wat
+++ b/tests/disas/winch/x64/call/recursive.wat
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xee
diff --git a/tests/disas/winch/x64/call/reg_on_stack.wat b/tests/disas/winch/x64/call/reg_on_stack.wat
index 2a644271e709..ad96f8a90a93 100644
--- a/tests/disas/winch/x64/call/reg_on_stack.wat
+++ b/tests/disas/winch/x64/call/reg_on_stack.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xd1
diff --git a/tests/disas/winch/x64/call/simple.wat b/tests/disas/winch/x64/call/simple.wat
index 4e63ec0aa585..890430998f4a 100644
--- a/tests/disas/winch/x64/call/simple.wat
+++ b/tests/disas/winch/x64/call/simple.wat
@@ -18,7 +18,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x28, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x97
@@ -55,7 +55,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xee
diff --git a/tests/disas/winch/x64/call_indirect/call_indirect.wat b/tests/disas/winch/x64/call_indirect/call_indirect.wat
index 17fa2ad96a78..6875d1cf6989 100644
--- a/tests/disas/winch/x64/call_indirect/call_indirect.wat
+++ b/tests/disas/winch/x64/call_indirect/call_indirect.wat
@@ -34,7 +34,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x22b
diff --git a/tests/disas/winch/x64/call_indirect/local_arg.wat b/tests/disas/winch/x64/call_indirect/local_arg.wat
index 10858f12f67d..077f529bf2c8 100644
--- a/tests/disas/winch/x64/call_indirect/local_arg.wat
+++ b/tests/disas/winch/x64/call_indirect/local_arg.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
@@ -39,7 +39,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x157
diff --git a/tests/disas/winch/x64/epoch/func.wat b/tests/disas/winch/x64/epoch/func.wat
index 061edd761b4f..15660a1eba35 100644
--- a/tests/disas/winch/x64/epoch/func.wat
+++ b/tests/disas/winch/x64/epoch/func.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/epoch/loop.wat b/tests/disas/winch/x64/epoch/loop.wat
index 3701d1ed48ad..b2514a389cc6 100644
--- a/tests/disas/winch/x64/epoch/loop.wat
+++ b/tests/disas/winch/x64/epoch/loop.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x87
diff --git a/tests/disas/winch/x64/f32_abs/f32_abs_const.wat b/tests/disas/winch/x64/f32_abs/f32_abs_const.wat
index e59aea929d5e..71f1eeaf510e 100644
--- a/tests/disas/winch/x64/f32_abs/f32_abs_const.wat
+++ b/tests/disas/winch/x64/f32_abs/f32_abs_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_abs/f32_abs_param.wat b/tests/disas/winch/x64/f32_abs/f32_abs_param.wat
index 42c16cd68476..dfa0ee3e60b1 100644
--- a/tests/disas/winch/x64/f32_abs/f32_abs_param.wat
+++ b/tests/disas/winch/x64/f32_abs/f32_abs_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f32_add/const.wat b/tests/disas/winch/x64/f32_add/const.wat
index e270cace1cd7..6427bd5e76bc 100644
--- a/tests/disas/winch/x64/f32_add/const.wat
+++ b/tests/disas/winch/x64/f32_add/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_add/locals.wat b/tests/disas/winch/x64/f32_add/locals.wat
index c6ccaef796f3..5b12ca9214a3 100644
--- a/tests/disas/winch/x64/f32_add/locals.wat
+++ b/tests/disas/winch/x64/f32_add/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_add/nan_canon.wat b/tests/disas/winch/x64/f32_add/nan_canon.wat
index 9aa0ed26395f..6b155f4c37e4 100644
--- a/tests/disas/winch/x64/f32_add/nan_canon.wat
+++ b/tests/disas/winch/x64/f32_add/nan_canon.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/f32_add/params.wat b/tests/disas/winch/x64/f32_add/params.wat
index 8cacebd33024..65a52dfb16fc 100644
--- a/tests/disas/winch/x64/f32_add/params.wat
+++ b/tests/disas/winch/x64/f32_add/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat
index 3ea313b9412f..863b96447b66 100644
--- a/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat
index 64604cb13f70..88d0a2c3dff0 100644
--- a/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat
index 47fda13284e5..d0c6e0ba5988 100644
--- a/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f32_const/call_id.wat b/tests/disas/winch/x64/f32_const/call_id.wat
index 6fac770cf50b..2b087324a323 100644
--- a/tests/disas/winch/x64/f32_const/call_id.wat
+++ b/tests/disas/winch/x64/f32_const/call_id.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa0
diff --git a/tests/disas/winch/x64/f32_const/id.wat b/tests/disas/winch/x64/f32_const/id.wat
index e1d1cb2a6d99..60cfed2b076d 100644
--- a/tests/disas/winch/x64/f32_const/id.wat
+++ b/tests/disas/winch/x64/f32_const/id.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/const.wat b/tests/disas/winch/x64/f32_convert_i32_s/const.wat
index 5a11fb84d952..1d2d4c1931e3 100644
--- a/tests/disas/winch/x64/f32_convert_i32_s/const.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/locals.wat b/tests/disas/winch/x64/f32_convert_i32_s/locals.wat
index f5f8ad91af63..5029af15ca06 100644
--- a/tests/disas/winch/x64/f32_convert_i32_s/locals.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/params.wat b/tests/disas/winch/x64/f32_convert_i32_s/params.wat
index 91a31ef42e7a..0f78c20a61ca 100644
--- a/tests/disas/winch/x64/f32_convert_i32_s/params.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat b/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat
index e4c44e7178a2..4cf8e82ba070 100644
--- a/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/const.wat b/tests/disas/winch/x64/f32_convert_i32_u/const.wat
index 06048787efda..a78fde833d1f 100644
--- a/tests/disas/winch/x64/f32_convert_i32_u/const.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6d
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/locals.wat b/tests/disas/winch/x64/f32_convert_i32_u/locals.wat
index 686e6fc2fa6c..41b3d6daf4da 100644
--- a/tests/disas/winch/x64/f32_convert_i32_u/locals.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x76
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/params.wat b/tests/disas/winch/x64/f32_convert_i32_u/params.wat
index 354edba9321a..6a2dd9d56059 100644
--- a/tests/disas/winch/x64/f32_convert_i32_u/params.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat b/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat
index 762c6fca27f8..1626db81ef47 100644
--- a/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat
+++ b/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x85
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/const.wat b/tests/disas/winch/x64/f32_convert_i64_s/const.wat
index 5ddc41156230..ba8801d6c312 100644
--- a/tests/disas/winch/x64/f32_convert_i64_s/const.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/locals.wat b/tests/disas/winch/x64/f32_convert_i64_s/locals.wat
index addfa24c4a01..3e88ad3c4bd4 100644
--- a/tests/disas/winch/x64/f32_convert_i64_s/locals.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/params.wat b/tests/disas/winch/x64/f32_convert_i64_s/params.wat
index 9c24930c0158..a495df6bcd47 100644
--- a/tests/disas/winch/x64/f32_convert_i64_s/params.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat b/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat
index f84387e2bdf8..73969f5d8077 100644
--- a/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/const.wat b/tests/disas/winch/x64/f32_convert_i64_u/const.wat
index 8049ef1923f7..8620e039f14b 100644
--- a/tests/disas/winch/x64/f32_convert_i64_u/const.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/locals.wat b/tests/disas/winch/x64/f32_convert_i64_u/locals.wat
index 0886e8fc866e..c0a8a70c3fd4 100644
--- a/tests/disas/winch/x64/f32_convert_i64_u/locals.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x75
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/params.wat b/tests/disas/winch/x64/f32_convert_i64_u/params.wat
index 8e498efdec58..e9bab6bbc0d1 100644
--- a/tests/disas/winch/x64/f32_convert_i64_u/params.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat b/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat
index 8971b1ed4646..34bc974fdb8a 100644
--- a/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat
+++ b/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x83
diff --git a/tests/disas/winch/x64/f32_copysign/const.wat b/tests/disas/winch/x64/f32_copysign/const.wat
index 4c11da750de4..ba3ca1191a72 100644
--- a/tests/disas/winch/x64/f32_copysign/const.wat
+++ b/tests/disas/winch/x64/f32_copysign/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/f32_copysign/locals.wat b/tests/disas/winch/x64/f32_copysign/locals.wat
index 96f026e7b111..87d4f163bf68 100644
--- a/tests/disas/winch/x64/f32_copysign/locals.wat
+++ b/tests/disas/winch/x64/f32_copysign/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x87
diff --git a/tests/disas/winch/x64/f32_copysign/params.wat b/tests/disas/winch/x64/f32_copysign/params.wat
index 18e77bf83930..8bc60e88fed7 100644
--- a/tests/disas/winch/x64/f32_copysign/params.wat
+++ b/tests/disas/winch/x64/f32_copysign/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/f32_demote_f64/const.wat b/tests/disas/winch/x64/f32_demote_f64/const.wat
index fa4cbb42e568..a4a32837cf88 100644
--- a/tests/disas/winch/x64/f32_demote_f64/const.wat
+++ b/tests/disas/winch/x64/f32_demote_f64/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f32_demote_f64/locals.wat b/tests/disas/winch/x64/f32_demote_f64/locals.wat
index 70501d15a535..571c3ccb99bc 100644
--- a/tests/disas/winch/x64/f32_demote_f64/locals.wat
+++ b/tests/disas/winch/x64/f32_demote_f64/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/f32_demote_f64/params.wat b/tests/disas/winch/x64/f32_demote_f64/params.wat
index f3ba148b127e..1939cee97473 100644
--- a/tests/disas/winch/x64/f32_demote_f64/params.wat
+++ b/tests/disas/winch/x64/f32_demote_f64/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/f32_demote_f64/spilled.wat b/tests/disas/winch/x64/f32_demote_f64/spilled.wat
index d4d28d7da7a5..552579f12fee 100644
--- a/tests/disas/winch/x64/f32_demote_f64/spilled.wat
+++ b/tests/disas/winch/x64/f32_demote_f64/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/f32_div/const.wat b/tests/disas/winch/x64/f32_div/const.wat
index 1c84b21b595a..4d2b2b18a120 100644
--- a/tests/disas/winch/x64/f32_div/const.wat
+++ b/tests/disas/winch/x64/f32_div/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_div/locals.wat b/tests/disas/winch/x64/f32_div/locals.wat
index e71008892fc8..f2c600190b02 100644
--- a/tests/disas/winch/x64/f32_div/locals.wat
+++ b/tests/disas/winch/x64/f32_div/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_div/params.wat b/tests/disas/winch/x64/f32_div/params.wat
index 57b9cf3e6d59..86a4e7653810 100644
--- a/tests/disas/winch/x64/f32_div/params.wat
+++ b/tests/disas/winch/x64/f32_div/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/f32_eq/const.wat b/tests/disas/winch/x64/f32_eq/const.wat
index edeccfeafcf3..a9465e6f439c 100644
--- a/tests/disas/winch/x64/f32_eq/const.wat
+++ b/tests/disas/winch/x64/f32_eq/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/f32_eq/locals.wat b/tests/disas/winch/x64/f32_eq/locals.wat
index dedef23a5e34..f7ebf2e6aefd 100644
--- a/tests/disas/winch/x64/f32_eq/locals.wat
+++ b/tests/disas/winch/x64/f32_eq/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/f32_eq/params.wat b/tests/disas/winch/x64/f32_eq/params.wat
index 6a491be65475..d8ea1140ae60 100644
--- a/tests/disas/winch/x64/f32_eq/params.wat
+++ b/tests/disas/winch/x64/f32_eq/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat b/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat
index f14e2bb5fea7..79f294441c29 100644
--- a/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_param.wat b/tests/disas/winch/x64/f32_floor/f32_floor_param.wat
index c860da414f11..6f8225969991 100644
--- a/tests/disas/winch/x64/f32_floor/f32_floor_param.wat
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat b/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat
index 3d06feacd583..1fe97d5205f2 100644
--- a/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f32_ge/const.wat b/tests/disas/winch/x64/f32_ge/const.wat
index 9c959625f4c5..db169b4a23bc 100644
--- a/tests/disas/winch/x64/f32_ge/const.wat
+++ b/tests/disas/winch/x64/f32_ge/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/f32_ge/locals.wat b/tests/disas/winch/x64/f32_ge/locals.wat
index f6aae2fc3e5d..99c13163ce09 100644
--- a/tests/disas/winch/x64/f32_ge/locals.wat
+++ b/tests/disas/winch/x64/f32_ge/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/f32_ge/params.wat b/tests/disas/winch/x64/f32_ge/params.wat
index 8de0a011231c..78dc59d735f2 100644
--- a/tests/disas/winch/x64/f32_ge/params.wat
+++ b/tests/disas/winch/x64/f32_ge/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/f32_gt/const.wat b/tests/disas/winch/x64/f32_gt/const.wat
index 636448cd9f2c..a7b479150155 100644
--- a/tests/disas/winch/x64/f32_gt/const.wat
+++ b/tests/disas/winch/x64/f32_gt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/f32_gt/locals.wat b/tests/disas/winch/x64/f32_gt/locals.wat
index a1516937fcdd..a4eea3e12e1f 100644
--- a/tests/disas/winch/x64/f32_gt/locals.wat
+++ b/tests/disas/winch/x64/f32_gt/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/f32_gt/params.wat b/tests/disas/winch/x64/f32_gt/params.wat
index f9be1947760c..5c450e606439 100644
--- a/tests/disas/winch/x64/f32_gt/params.wat
+++ b/tests/disas/winch/x64/f32_gt/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/f32_le/const.wat b/tests/disas/winch/x64/f32_le/const.wat
index 3eb0c984dbe3..0948adaf36e5 100644
--- a/tests/disas/winch/x64/f32_le/const.wat
+++ b/tests/disas/winch/x64/f32_le/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/f32_le/locals.wat b/tests/disas/winch/x64/f32_le/locals.wat
index 2c6e5bfa51df..8f40357c233d 100644
--- a/tests/disas/winch/x64/f32_le/locals.wat
+++ b/tests/disas/winch/x64/f32_le/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x75
diff --git a/tests/disas/winch/x64/f32_le/params.wat b/tests/disas/winch/x64/f32_le/params.wat
index a04a1b81e6aa..8d5b52e4a229 100644
--- a/tests/disas/winch/x64/f32_le/params.wat
+++ b/tests/disas/winch/x64/f32_le/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/f32_lt/const.wat b/tests/disas/winch/x64/f32_lt/const.wat
index 9b661c7b6bbb..ce9295127420 100644
--- a/tests/disas/winch/x64/f32_lt/const.wat
+++ b/tests/disas/winch/x64/f32_lt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/f32_lt/locals.wat b/tests/disas/winch/x64/f32_lt/locals.wat
index 6128f88f80cd..9bda9731237d 100644
--- a/tests/disas/winch/x64/f32_lt/locals.wat
+++ b/tests/disas/winch/x64/f32_lt/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x75
diff --git a/tests/disas/winch/x64/f32_lt/params.wat b/tests/disas/winch/x64/f32_lt/params.wat
index d506a22040d1..9fc7cd844d1c 100644
--- a/tests/disas/winch/x64/f32_lt/params.wat
+++ b/tests/disas/winch/x64/f32_lt/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/f32_max/const.wat b/tests/disas/winch/x64/f32_max/const.wat
index 232610e0c9bb..ea3451f574a8 100644
--- a/tests/disas/winch/x64/f32_max/const.wat
+++ b/tests/disas/winch/x64/f32_max/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x70
diff --git a/tests/disas/winch/x64/f32_max/locals.wat b/tests/disas/winch/x64/f32_max/locals.wat
index 8794a8d692ea..cc7223f526ff 100644
--- a/tests/disas/winch/x64/f32_max/locals.wat
+++ b/tests/disas/winch/x64/f32_max/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x92
diff --git a/tests/disas/winch/x64/f32_max/params.wat b/tests/disas/winch/x64/f32_max/params.wat
index 2f8598d6483d..6fb69724006e 100644
--- a/tests/disas/winch/x64/f32_max/params.wat
+++ b/tests/disas/winch/x64/f32_max/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x79
diff --git a/tests/disas/winch/x64/f32_min/const.wat b/tests/disas/winch/x64/f32_min/const.wat
index a6e507d8f0b1..492dfc199a92 100644
--- a/tests/disas/winch/x64/f32_min/const.wat
+++ b/tests/disas/winch/x64/f32_min/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x70
diff --git a/tests/disas/winch/x64/f32_min/locals.wat b/tests/disas/winch/x64/f32_min/locals.wat
index 6d14b3fc45bd..3d9613766c4d 100644
--- a/tests/disas/winch/x64/f32_min/locals.wat
+++ b/tests/disas/winch/x64/f32_min/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x92
diff --git a/tests/disas/winch/x64/f32_min/params.wat b/tests/disas/winch/x64/f32_min/params.wat
index 1b2a6a30cf93..50491e49c0cc 100644
--- a/tests/disas/winch/x64/f32_min/params.wat
+++ b/tests/disas/winch/x64/f32_min/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x79
diff --git a/tests/disas/winch/x64/f32_mul/const.wat b/tests/disas/winch/x64/f32_mul/const.wat
index bdc3cf681921..ac1cdedd608e 100644
--- a/tests/disas/winch/x64/f32_mul/const.wat
+++ b/tests/disas/winch/x64/f32_mul/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_mul/locals.wat b/tests/disas/winch/x64/f32_mul/locals.wat
index 0a844b7d5e06..68b80067989a 100644
--- a/tests/disas/winch/x64/f32_mul/locals.wat
+++ b/tests/disas/winch/x64/f32_mul/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_mul/params.wat b/tests/disas/winch/x64/f32_mul/params.wat
index 0e1d53abc047..da62586c61c9 100644
--- a/tests/disas/winch/x64/f32_mul/params.wat
+++ b/tests/disas/winch/x64/f32_mul/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/f32_ne/const.wat b/tests/disas/winch/x64/f32_ne/const.wat
index f695c73c2249..1eb379a6b2e9 100644
--- a/tests/disas/winch/x64/f32_ne/const.wat
+++ b/tests/disas/winch/x64/f32_ne/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/f32_ne/locals.wat b/tests/disas/winch/x64/f32_ne/locals.wat
index 149afaf445c2..0daec89a7525 100644
--- a/tests/disas/winch/x64/f32_ne/locals.wat
+++ b/tests/disas/winch/x64/f32_ne/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/f32_ne/params.wat b/tests/disas/winch/x64/f32_ne/params.wat
index ad2417aa9567..4200242ab946 100644
--- a/tests/disas/winch/x64/f32_ne/params.wat
+++ b/tests/disas/winch/x64/f32_ne/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat b/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat
index 35c39199daa9..84fc18bfcfb4 100644
--- a/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat
+++ b/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat b/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat
index 9bc4e9b23c47..bf35935434f1 100644
--- a/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat
+++ b/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat b/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat
index 1099f240c05a..53643dd40e95 100644
--- a/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat
+++ b/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f32_neg/f32_neg_const.wat b/tests/disas/winch/x64/f32_neg/f32_neg_const.wat
index 595caabdbab7..0102379824e1 100644
--- a/tests/disas/winch/x64/f32_neg/f32_neg_const.wat
+++ b/tests/disas/winch/x64/f32_neg/f32_neg_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_neg/f32_neg_param.wat b/tests/disas/winch/x64/f32_neg/f32_neg_param.wat
index f5a1aa235e0b..9b3201f56a7d 100644
--- a/tests/disas/winch/x64/f32_neg/f32_neg_param.wat
+++ b/tests/disas/winch/x64/f32_neg/f32_neg_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/const.wat b/tests/disas/winch/x64/f32_reinterpret_i32/const.wat
index 2909cbc3bed7..fc72e5cba91b 100644
--- a/tests/disas/winch/x64/f32_reinterpret_i32/const.wat
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat b/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat
index b65ea85dc33e..e0347bd18013 100644
--- a/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/params.wat b/tests/disas/winch/x64/f32_reinterpret_i32/params.wat
index 3604fab1d92d..95730f68903c 100644
--- a/tests/disas/winch/x64/f32_reinterpret_i32/params.wat
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat b/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat
index 48225ec58014..8540ff890905 100644
--- a/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat b/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat
index c109aac75fc9..c794fd297e75 100644
--- a/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat
index 39f756f496c1..071e95200aa5 100644
--- a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat
+++ b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat
index 5f9708cf333b..05462d739477 100644
--- a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat
+++ b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/f32_sub/const.wat b/tests/disas/winch/x64/f32_sub/const.wat
index 2815f6cdccc6..75d19f1795c5 100644
--- a/tests/disas/winch/x64/f32_sub/const.wat
+++ b/tests/disas/winch/x64/f32_sub/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f32_sub/locals.wat b/tests/disas/winch/x64/f32_sub/locals.wat
index b9d97c90b061..93911f00bf09 100644
--- a/tests/disas/winch/x64/f32_sub/locals.wat
+++ b/tests/disas/winch/x64/f32_sub/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f32_sub/params.wat b/tests/disas/winch/x64/f32_sub/params.wat
index 6cb11a1f50f0..62af1966aa58 100644
--- a/tests/disas/winch/x64/f32_sub/params.wat
+++ b/tests/disas/winch/x64/f32_sub/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat
index e3bdc1b757db..e2385df19914 100644
--- a/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat
index 04ea2d3771c2..7f038e936204 100644
--- a/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat
index 74bb65a27677..fa33a4e758f9 100644
--- a/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f32x4_abs/const_avx.wat b/tests/disas/winch/x64/f32x4_abs/const_avx.wat
index 85de1324deb1..a03c2454842c 100644
--- a/tests/disas/winch/x64/f32x4_abs/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_add/const_avx.wat b/tests/disas/winch/x64/f32x4_add/const_avx.wat
index b381b45a2580..5be1bbab8ddd 100644
--- a/tests/disas/winch/x64/f32x4_add/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_add/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_add/nan_canon.wat b/tests/disas/winch/x64/f32x4_add/nan_canon.wat
index 89f1878a80a0..390eb634bd40 100644
--- a/tests/disas/winch/x64/f32x4_add/nan_canon.wat
+++ b/tests/disas/winch/x64/f32x4_add/nan_canon.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6c
diff --git a/tests/disas/winch/x64/f32x4_ceil/const_avx.wat b/tests/disas/winch/x64/f32x4_ceil/const_avx.wat
index 8556472d6052..0be901707fc4 100644
--- a/tests/disas/winch/x64/f32x4_ceil/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_ceil/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32x4_convert_i32x4_s/const_avx.wat b/tests/disas/winch/x64/f32x4_convert_i32x4_s/const_avx.wat
index 741e5e05ec5a..26c3c462a904 100644
--- a/tests/disas/winch/x64/f32x4_convert_i32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_convert_i32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f32x4_convert_i32x4_u/const_avx.wat b/tests/disas/winch/x64/f32x4_convert_i32x4_u/const_avx.wat
index b0d6e4115329..fe0c2ea1b426 100644
--- a/tests/disas/winch/x64/f32x4_convert_i32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_convert_i32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/f32x4_demote_f64x2_zero/const_avx.wat b/tests/disas/winch/x64/f32x4_demote_f64x2_zero/const_avx.wat
index 72e6e60cc330..b756b18d6773 100644
--- a/tests/disas/winch/x64/f32x4_demote_f64x2_zero/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_demote_f64x2_zero/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f32x4_div/const_avx.wat b/tests/disas/winch/x64/f32x4_div/const_avx.wat
index 6e83aac142fc..53840baacb3c 100644
--- a/tests/disas/winch/x64/f32x4_div/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_div/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_eq/const_avx.wat b/tests/disas/winch/x64/f32x4_eq/const_avx.wat
index 5f11907c36ed..0126e388ca82 100644
--- a/tests/disas/winch/x64/f32x4_eq/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_eq/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_extract_lane/first_lane_avx.wat b/tests/disas/winch/x64/f32x4_extract_lane/first_lane_avx.wat
index 0a06197d1d4c..2360063aa201 100644
--- a/tests/disas/winch/x64/f32x4_extract_lane/first_lane_avx.wat
+++ b/tests/disas/winch/x64/f32x4_extract_lane/first_lane_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/f32x4_extract_lane/second_lane_avx.wat b/tests/disas/winch/x64/f32x4_extract_lane/second_lane_avx.wat
index 68eb1c98a0e6..4038a1fea999 100644
--- a/tests/disas/winch/x64/f32x4_extract_lane/second_lane_avx.wat
+++ b/tests/disas/winch/x64/f32x4_extract_lane/second_lane_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f32x4_floor/const_avx.wat b/tests/disas/winch/x64/f32x4_floor/const_avx.wat
index bc127936e666..f7f58d5a7ed4 100644
--- a/tests/disas/winch/x64/f32x4_floor/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_floor/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32x4_ge/const_avx.wat b/tests/disas/winch/x64/f32x4_ge/const_avx.wat
index 78e6311ea622..add48026798b 100644
--- a/tests/disas/winch/x64/f32x4_ge/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_ge/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_gt/const_avx.wat b/tests/disas/winch/x64/f32x4_gt/const_avx.wat
index f6332884ecc1..194548c41064 100644
--- a/tests/disas/winch/x64/f32x4_gt/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_gt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_le/const_avx.wat b/tests/disas/winch/x64/f32x4_le/const_avx.wat
index 044b0dc3f5c5..138f79154517 100644
--- a/tests/disas/winch/x64/f32x4_le/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_le/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_lt/const_avx.wat b/tests/disas/winch/x64/f32x4_lt/const_avx.wat
index 716b6043a5ed..1eb037ac0252 100644
--- a/tests/disas/winch/x64/f32x4_lt/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_lt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_max/const_avx.wat b/tests/disas/winch/x64/f32x4_max/const_avx.wat
index 13d8b86efff9..2cc20d6baceb 100644
--- a/tests/disas/winch/x64/f32x4_max/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_max/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x70
diff --git a/tests/disas/winch/x64/f32x4_min/const_avx.wat b/tests/disas/winch/x64/f32x4_min/const_avx.wat
index 952534efd553..7fab16e8931c 100644
--- a/tests/disas/winch/x64/f32x4_min/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_min/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/f32x4_mul/const_avx.wat b/tests/disas/winch/x64/f32x4_mul/const_avx.wat
index 66e2920e967b..fdfb81f47237 100644
--- a/tests/disas/winch/x64/f32x4_mul/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_mul/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_ne/const_avx.wat b/tests/disas/winch/x64/f32x4_ne/const_avx.wat
index fa87dcfe05f2..37c2bfd49457 100644
--- a/tests/disas/winch/x64/f32x4_ne/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f32x4_nearest/const_avx.wat b/tests/disas/winch/x64/f32x4_nearest/const_avx.wat
index d993846a7f88..ea3f7c12b526 100644
--- a/tests/disas/winch/x64/f32x4_nearest/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_nearest/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f32x4_neg/const_avx.wat b/tests/disas/winch/x64/f32x4_neg/const_avx.wat
index 811e08a2072e..449ba0803bdf 100644
--- a/tests/disas/winch/x64/f32x4_neg/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_neg/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_pmax/const_avx.wat b/tests/disas/winch/x64/f32x4_pmax/const_avx.wat
index 303ebb864ea2..41b195ba46d2 100644
--- a/tests/disas/winch/x64/f32x4_pmax/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_pmax/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_pmin/const_avx.wat b/tests/disas/winch/x64/f32x4_pmin/const_avx.wat
index 8c8cd070be88..60814345c265 100644
--- a/tests/disas/winch/x64/f32x4_pmin/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_pmin/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_replace_lane/const_avx.wat b/tests/disas/winch/x64/f32x4_replace_lane/const_avx.wat
index c7f185d3b932..31043c6b1ace 100644
--- a/tests/disas/winch/x64/f32x4_replace_lane/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_replace_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f32x4_replace_lane/param_avx.wat b/tests/disas/winch/x64/f32x4_replace_lane/param_avx.wat
index 720f8516db53..7b5fbfc502a8 100644
--- a/tests/disas/winch/x64/f32x4_replace_lane/param_avx.wat
+++ b/tests/disas/winch/x64/f32x4_replace_lane/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/f32x4_splat/const_avx2.wat b/tests/disas/winch/x64/f32x4_splat/const_avx2.wat
index dcdf90642cc3..8d7d7faa82b1 100644
--- a/tests/disas/winch/x64/f32x4_splat/const_avx2.wat
+++ b/tests/disas/winch/x64/f32x4_splat/const_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f32x4_splat/params_avx2.wat b/tests/disas/winch/x64/f32x4_splat/params_avx2.wat
index 05b8c1a8cd49..88fc62ee9a45 100644
--- a/tests/disas/winch/x64/f32x4_splat/params_avx2.wat
+++ b/tests/disas/winch/x64/f32x4_splat/params_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f32x4_sqrt/const_avx.wat b/tests/disas/winch/x64/f32x4_sqrt/const_avx.wat
index 85405682a1cd..790dc5f3b306 100644
--- a/tests/disas/winch/x64/f32x4_sqrt/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_sqrt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f32x4_sub/const_avx.wat b/tests/disas/winch/x64/f32x4_sub/const_avx.wat
index 57f220de65b8..8e2f4f4cef4a 100644
--- a/tests/disas/winch/x64/f32x4_sub/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_sub/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f32x4_trunc/const_avx.wat b/tests/disas/winch/x64/f32x4_trunc/const_avx.wat
index cf6273d255d5..2d524a2ae573 100644
--- a/tests/disas/winch/x64/f32x4_trunc/const_avx.wat
+++ b/tests/disas/winch/x64/f32x4_trunc/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64_abs/f64_abs_const.wat b/tests/disas/winch/x64/f64_abs/f64_abs_const.wat
index 130e489e423c..2ff1e1f59586 100644
--- a/tests/disas/winch/x64/f64_abs/f64_abs_const.wat
+++ b/tests/disas/winch/x64/f64_abs/f64_abs_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f64_abs/f64_abs_param.wat b/tests/disas/winch/x64/f64_abs/f64_abs_param.wat
index 3e4b734705b7..b50700ee3795 100644
--- a/tests/disas/winch/x64/f64_abs/f64_abs_param.wat
+++ b/tests/disas/winch/x64/f64_abs/f64_abs_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/f64_add/const.wat b/tests/disas/winch/x64/f64_add/const.wat
index e1fc46a5c44f..908e7d851e18 100644
--- a/tests/disas/winch/x64/f64_add/const.wat
+++ b/tests/disas/winch/x64/f64_add/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f64_add/locals.wat b/tests/disas/winch/x64/f64_add/locals.wat
index 502827d00388..b466f783822d 100644
--- a/tests/disas/winch/x64/f64_add/locals.wat
+++ b/tests/disas/winch/x64/f64_add/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_add/params.wat b/tests/disas/winch/x64/f64_add/params.wat
index 021105e18d97..10173ec93f70 100644
--- a/tests/disas/winch/x64/f64_add/params.wat
+++ b/tests/disas/winch/x64/f64_add/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat
index 56f53722d6b3..f5a06dcd10af 100644
--- a/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat
index d0823c70d614..ff327084d239 100644
--- a/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat
index 0aaad953fb14..ff6805cf5174 100644
--- a/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f64_const/call_id.wat b/tests/disas/winch/x64/f64_const/call_id.wat
index 002104fb78ab..6b0da06a056f 100644
--- a/tests/disas/winch/x64/f64_const/call_id.wat
+++ b/tests/disas/winch/x64/f64_const/call_id.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa0
diff --git a/tests/disas/winch/x64/f64_const/id.wat b/tests/disas/winch/x64/f64_const/id.wat
index e3baa3101e6a..db1fcf7a7139 100644
--- a/tests/disas/winch/x64/f64_const/id.wat
+++ b/tests/disas/winch/x64/f64_const/id.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/const.wat b/tests/disas/winch/x64/f64_convert_i32_s/const.wat
index 9e45a7c0b229..cc94af0a1bb2 100644
--- a/tests/disas/winch/x64/f64_convert_i32_s/const.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/locals.wat b/tests/disas/winch/x64/f64_convert_i32_s/locals.wat
index 89370e8e365c..4e28cd06dcda 100644
--- a/tests/disas/winch/x64/f64_convert_i32_s/locals.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/params.wat b/tests/disas/winch/x64/f64_convert_i32_s/params.wat
index 2c1395aa7dad..c7c86a39dbc3 100644
--- a/tests/disas/winch/x64/f64_convert_i32_s/params.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat b/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat
index a42c69c3d188..75c4439f9fe4 100644
--- a/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/const.wat b/tests/disas/winch/x64/f64_convert_i32_u/const.wat
index cc3e5c9374a6..f41ab6066c0a 100644
--- a/tests/disas/winch/x64/f64_convert_i32_u/const.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6d
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/locals.wat b/tests/disas/winch/x64/f64_convert_i32_u/locals.wat
index ff752039cf30..bd5354224c38 100644
--- a/tests/disas/winch/x64/f64_convert_i32_u/locals.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x76
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/params.wat b/tests/disas/winch/x64/f64_convert_i32_u/params.wat
index 4d529674dfa9..e4e05568b27a 100644
--- a/tests/disas/winch/x64/f64_convert_i32_u/params.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat b/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat
index e911e89c73f2..27cb5a0fd0a9 100644
--- a/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat
+++ b/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x85
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/const.wat b/tests/disas/winch/x64/f64_convert_i64_s/const.wat
index 75e27cd2acbf..e556c67862a0 100644
--- a/tests/disas/winch/x64/f64_convert_i64_s/const.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/locals.wat b/tests/disas/winch/x64/f64_convert_i64_s/locals.wat
index 55f4f9336638..265a648f0b01 100644
--- a/tests/disas/winch/x64/f64_convert_i64_s/locals.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/params.wat b/tests/disas/winch/x64/f64_convert_i64_s/params.wat
index e7106ae4f21e..7f7769a5aede 100644
--- a/tests/disas/winch/x64/f64_convert_i64_s/params.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat b/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat
index 1d32064a4849..2dfc472f217b 100644
--- a/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/const.wat b/tests/disas/winch/x64/f64_convert_i64_u/const.wat
index 6aa80db97f75..37cef573091c 100644
--- a/tests/disas/winch/x64/f64_convert_i64_u/const.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/locals.wat b/tests/disas/winch/x64/f64_convert_i64_u/locals.wat
index a0917dba713c..bf9407f0f7f0 100644
--- a/tests/disas/winch/x64/f64_convert_i64_u/locals.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x75
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/params.wat b/tests/disas/winch/x64/f64_convert_i64_u/params.wat
index db6a4d12e991..272baa5765c5 100644
--- a/tests/disas/winch/x64/f64_convert_i64_u/params.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat b/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat
index a641fa7fb291..b9e0aeaa6305 100644
--- a/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat
+++ b/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x83
diff --git a/tests/disas/winch/x64/f64_copysign/const.wat b/tests/disas/winch/x64/f64_copysign/const.wat
index 70bb856964eb..b2647faff881 100644
--- a/tests/disas/winch/x64/f64_copysign/const.wat
+++ b/tests/disas/winch/x64/f64_copysign/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6c
diff --git a/tests/disas/winch/x64/f64_copysign/locals.wat b/tests/disas/winch/x64/f64_copysign/locals.wat
index c71f6077afcc..feb3220678ae 100644
--- a/tests/disas/winch/x64/f64_copysign/locals.wat
+++ b/tests/disas/winch/x64/f64_copysign/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8f
diff --git a/tests/disas/winch/x64/f64_copysign/params.wat b/tests/disas/winch/x64/f64_copysign/params.wat
index 17f5d56af7c2..a91e8fb872d1 100644
--- a/tests/disas/winch/x64/f64_copysign/params.wat
+++ b/tests/disas/winch/x64/f64_copysign/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x73
diff --git a/tests/disas/winch/x64/f64_div/const.wat b/tests/disas/winch/x64/f64_div/const.wat
index 4788fce93a89..00f500709f15 100644
--- a/tests/disas/winch/x64/f64_div/const.wat
+++ b/tests/disas/winch/x64/f64_div/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f64_div/locals.wat b/tests/disas/winch/x64/f64_div/locals.wat
index ca5bb72152e3..5d233adc3070 100644
--- a/tests/disas/winch/x64/f64_div/locals.wat
+++ b/tests/disas/winch/x64/f64_div/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_div/nan_canon.wat b/tests/disas/winch/x64/f64_div/nan_canon.wat
index cf0285da39fd..16f2cc3746ce 100644
--- a/tests/disas/winch/x64/f64_div/nan_canon.wat
+++ b/tests/disas/winch/x64/f64_div/nan_canon.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/f64_div/params.wat b/tests/disas/winch/x64/f64_div/params.wat
index 5e62977765d9..f45d007a17dd 100644
--- a/tests/disas/winch/x64/f64_div/params.wat
+++ b/tests/disas/winch/x64/f64_div/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/f64_eq/const.wat b/tests/disas/winch/x64/f64_eq/const.wat
index 29e9ef2486da..37b6c841e238 100644
--- a/tests/disas/winch/x64/f64_eq/const.wat
+++ b/tests/disas/winch/x64/f64_eq/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/f64_eq/locals.wat b/tests/disas/winch/x64/f64_eq/locals.wat
index 421556091938..af5b5d4459fa 100644
--- a/tests/disas/winch/x64/f64_eq/locals.wat
+++ b/tests/disas/winch/x64/f64_eq/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/f64_eq/params.wat b/tests/disas/winch/x64/f64_eq/params.wat
index d57c09883e4f..1583e11b584c 100644
--- a/tests/disas/winch/x64/f64_eq/params.wat
+++ b/tests/disas/winch/x64/f64_eq/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat b/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat
index f84da5ae957f..604cfcc9cc72 100644
--- a/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_param.wat b/tests/disas/winch/x64/f64_floor/f64_floor_param.wat
index 87ada7f89f1d..a0e49e63f3a8 100644
--- a/tests/disas/winch/x64/f64_floor/f64_floor_param.wat
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat b/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat
index d96cf3f5969b..e577a5f16b87 100644
--- a/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f64_ge/const.wat b/tests/disas/winch/x64/f64_ge/const.wat
index 3b93c8634933..568a23665564 100644
--- a/tests/disas/winch/x64/f64_ge/const.wat
+++ b/tests/disas/winch/x64/f64_ge/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/f64_ge/locals.wat b/tests/disas/winch/x64/f64_ge/locals.wat
index 357a55a663b4..701f28eb5b28 100644
--- a/tests/disas/winch/x64/f64_ge/locals.wat
+++ b/tests/disas/winch/x64/f64_ge/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/f64_ge/params.wat b/tests/disas/winch/x64/f64_ge/params.wat
index b14684f3c2f4..4b522f7534db 100644
--- a/tests/disas/winch/x64/f64_ge/params.wat
+++ b/tests/disas/winch/x64/f64_ge/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/f64_gt/const.wat b/tests/disas/winch/x64/f64_gt/const.wat
index 2c9533f9d510..cdd9f68172ca 100644
--- a/tests/disas/winch/x64/f64_gt/const.wat
+++ b/tests/disas/winch/x64/f64_gt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/f64_gt/locals.wat b/tests/disas/winch/x64/f64_gt/locals.wat
index c11fb2371e61..6af7e3ad6aec 100644
--- a/tests/disas/winch/x64/f64_gt/locals.wat
+++ b/tests/disas/winch/x64/f64_gt/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/f64_gt/params.wat b/tests/disas/winch/x64/f64_gt/params.wat
index aba4da688555..566c6e2660c4 100644
--- a/tests/disas/winch/x64/f64_gt/params.wat
+++ b/tests/disas/winch/x64/f64_gt/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/f64_le/const.wat b/tests/disas/winch/x64/f64_le/const.wat
index ecf3c7cccc70..712bc6f17b8f 100644
--- a/tests/disas/winch/x64/f64_le/const.wat
+++ b/tests/disas/winch/x64/f64_le/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f64_le/locals.wat b/tests/disas/winch/x64/f64_le/locals.wat
index c46681d70514..808972a28e3c 100644
--- a/tests/disas/winch/x64/f64_le/locals.wat
+++ b/tests/disas/winch/x64/f64_le/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/f64_le/params.wat b/tests/disas/winch/x64/f64_le/params.wat
index c46681d70514..808972a28e3c 100644
--- a/tests/disas/winch/x64/f64_le/params.wat
+++ b/tests/disas/winch/x64/f64_le/params.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/f64_lt/const.wat b/tests/disas/winch/x64/f64_lt/const.wat
index c81fed7500db..68b9de8eb528 100644
--- a/tests/disas/winch/x64/f64_lt/const.wat
+++ b/tests/disas/winch/x64/f64_lt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f64_lt/locals.wat b/tests/disas/winch/x64/f64_lt/locals.wat
index 866325561413..4c52453c43e8 100644
--- a/tests/disas/winch/x64/f64_lt/locals.wat
+++ b/tests/disas/winch/x64/f64_lt/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x77
diff --git a/tests/disas/winch/x64/f64_lt/params.wat b/tests/disas/winch/x64/f64_lt/params.wat
index e51ed5dd33e5..bbdb3d832717 100644
--- a/tests/disas/winch/x64/f64_lt/params.wat
+++ b/tests/disas/winch/x64/f64_lt/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/f64_max/const.wat b/tests/disas/winch/x64/f64_max/const.wat
index 4db6aba4c11f..96fe8bbbe2b1 100644
--- a/tests/disas/winch/x64/f64_max/const.wat
+++ b/tests/disas/winch/x64/f64_max/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_max/locals.wat b/tests/disas/winch/x64/f64_max/locals.wat
index 7a307b5832ff..a1361756a408 100644
--- a/tests/disas/winch/x64/f64_max/locals.wat
+++ b/tests/disas/winch/x64/f64_max/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/f64_max/params.wat b/tests/disas/winch/x64/f64_max/params.wat
index 605b337bdfdb..1f97a8cec001 100644
--- a/tests/disas/winch/x64/f64_max/params.wat
+++ b/tests/disas/winch/x64/f64_max/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x79
diff --git a/tests/disas/winch/x64/f64_min/const.wat b/tests/disas/winch/x64/f64_min/const.wat
index c7daeed36f06..dc1a140d1eac 100644
--- a/tests/disas/winch/x64/f64_min/const.wat
+++ b/tests/disas/winch/x64/f64_min/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_min/locals.wat b/tests/disas/winch/x64/f64_min/locals.wat
index 74f3cc7f7448..f23c49dbf7c4 100644
--- a/tests/disas/winch/x64/f64_min/locals.wat
+++ b/tests/disas/winch/x64/f64_min/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/f64_min/params.wat b/tests/disas/winch/x64/f64_min/params.wat
index bec3ec70971b..889449e90778 100644
--- a/tests/disas/winch/x64/f64_min/params.wat
+++ b/tests/disas/winch/x64/f64_min/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x79
diff --git a/tests/disas/winch/x64/f64_mul/const.wat b/tests/disas/winch/x64/f64_mul/const.wat
index 404e66cb4a56..3ff1a58c08e6 100644
--- a/tests/disas/winch/x64/f64_mul/const.wat
+++ b/tests/disas/winch/x64/f64_mul/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f64_mul/locals.wat b/tests/disas/winch/x64/f64_mul/locals.wat
index 5e96823c847a..a5451c298265 100644
--- a/tests/disas/winch/x64/f64_mul/locals.wat
+++ b/tests/disas/winch/x64/f64_mul/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_mul/params.wat b/tests/disas/winch/x64/f64_mul/params.wat
index 97f457997489..21b1cad1242b 100644
--- a/tests/disas/winch/x64/f64_mul/params.wat
+++ b/tests/disas/winch/x64/f64_mul/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/f64_ne/const.wat b/tests/disas/winch/x64/f64_ne/const.wat
index c4188eb3e8ef..753ed0cae110 100644
--- a/tests/disas/winch/x64/f64_ne/const.wat
+++ b/tests/disas/winch/x64/f64_ne/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/f64_ne/locals.wat b/tests/disas/winch/x64/f64_ne/locals.wat
index 974f42e8cd3d..61722b766d93 100644
--- a/tests/disas/winch/x64/f64_ne/locals.wat
+++ b/tests/disas/winch/x64/f64_ne/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/f64_ne/params.wat b/tests/disas/winch/x64/f64_ne/params.wat
index 2446a3a27ab7..50c4c0146e5e 100644
--- a/tests/disas/winch/x64/f64_ne/params.wat
+++ b/tests/disas/winch/x64/f64_ne/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat
index 1d9dfc93a7cd..759b88f07606 100644
--- a/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat
index 64d7814165e2..8542996e9d83 100644
--- a/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat
index 37ebf14bb9b0..af6a304cdd26 100644
--- a/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f64_neg/f64_neg_const.wat b/tests/disas/winch/x64/f64_neg/f64_neg_const.wat
index 7149bfb98da0..19ee5a512b2f 100644
--- a/tests/disas/winch/x64/f64_neg/f64_neg_const.wat
+++ b/tests/disas/winch/x64/f64_neg/f64_neg_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/f64_neg/f64_neg_param.wat b/tests/disas/winch/x64/f64_neg/f64_neg_param.wat
index 0413f82c60f8..68f339c21d9e 100644
--- a/tests/disas/winch/x64/f64_neg/f64_neg_param.wat
+++ b/tests/disas/winch/x64/f64_neg/f64_neg_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/f64_promote_f32/const.wat b/tests/disas/winch/x64/f64_promote_f32/const.wat
index 4a7e927b3879..9370b8e6f85c 100644
--- a/tests/disas/winch/x64/f64_promote_f32/const.wat
+++ b/tests/disas/winch/x64/f64_promote_f32/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f64_promote_f32/locals.wat b/tests/disas/winch/x64/f64_promote_f32/locals.wat
index 8056f4262bc5..035afde57119 100644
--- a/tests/disas/winch/x64/f64_promote_f32/locals.wat
+++ b/tests/disas/winch/x64/f64_promote_f32/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/f64_promote_f32/params.wat b/tests/disas/winch/x64/f64_promote_f32/params.wat
index a84773c8dfac..7d6d3b09bcf9 100644
--- a/tests/disas/winch/x64/f64_promote_f32/params.wat
+++ b/tests/disas/winch/x64/f64_promote_f32/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/f64_promote_f32/spilled.wat b/tests/disas/winch/x64/f64_promote_f32/spilled.wat
index c4c57bd20eea..aebf9a432226 100644
--- a/tests/disas/winch/x64/f64_promote_f32/spilled.wat
+++ b/tests/disas/winch/x64/f64_promote_f32/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/const.wat b/tests/disas/winch/x64/f64_reinterpret_i64/const.wat
index 9372d9591252..e55b72e505c8 100644
--- a/tests/disas/winch/x64/f64_reinterpret_i64/const.wat
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat b/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat
index 3724e85d5fd4..81700c3cf0cf 100644
--- a/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/params.wat b/tests/disas/winch/x64/f64_reinterpret_i64/params.wat
index f04bcff48e72..b1f96bc14234 100644
--- a/tests/disas/winch/x64/f64_reinterpret_i64/params.wat
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat b/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat
index aff8c6e8bfc0..bda9206f3358 100644
--- a/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x47
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat b/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat
index 2786bda73ca8..0d7d530c07d5 100644
--- a/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat
index 76d6543f771f..4dfe5a2c2afb 100644
--- a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat
+++ b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat
index f8fade2130b0..c39332c90e92 100644
--- a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat
+++ b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/f64_sub/const.wat b/tests/disas/winch/x64/f64_sub/const.wat
index 3eada341e4a7..00f662b89e8d 100644
--- a/tests/disas/winch/x64/f64_sub/const.wat
+++ b/tests/disas/winch/x64/f64_sub/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/f64_sub/locals.wat b/tests/disas/winch/x64/f64_sub/locals.wat
index de8f911ce973..3e569fe6fb90 100644
--- a/tests/disas/winch/x64/f64_sub/locals.wat
+++ b/tests/disas/winch/x64/f64_sub/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x72
diff --git a/tests/disas/winch/x64/f64_sub/params.wat b/tests/disas/winch/x64/f64_sub/params.wat
index ebcef9040784..5936bda2d972 100644
--- a/tests/disas/winch/x64/f64_sub/params.wat
+++ b/tests/disas/winch/x64/f64_sub/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat
index 6cf5f4fdc0e2..f809a8765087 100644
--- a/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat
index 507039062c74..6ee3a2ff2aca 100644
--- a/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7b
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat
index b3b21a90483c..565e1828a735 100644
--- a/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/f64x2_abs/const_avx.wat b/tests/disas/winch/x64/f64x2_abs/const_avx.wat
index 331ebe6fede8..9fd54c9c27f3 100644
--- a/tests/disas/winch/x64/f64x2_abs/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_add/const_avx.wat b/tests/disas/winch/x64/f64x2_add/const_avx.wat
index 9fbcdcc11c16..6918f4368220 100644
--- a/tests/disas/winch/x64/f64x2_add/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_add/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_ceil/const_avx.wat b/tests/disas/winch/x64/f64x2_ceil/const_avx.wat
index b09b5a8a7b53..f6665801e1a9 100644
--- a/tests/disas/winch/x64/f64x2_ceil/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_ceil/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64x2_convert_low_i32x4_s/const_avx.wat b/tests/disas/winch/x64/f64x2_convert_low_i32x4_s/const_avx.wat
index 8dfa7aa1d7a8..8439119602fb 100644
--- a/tests/disas/winch/x64/f64x2_convert_low_i32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_convert_low_i32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f64x2_convert_low_i32x4_u/const_avx.wat b/tests/disas/winch/x64/f64x2_convert_low_i32x4_u/const_avx.wat
index 5f7daa9fda79..b5075bc672c9 100644
--- a/tests/disas/winch/x64/f64x2_convert_low_i32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_convert_low_i32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_div/const_avx.wat b/tests/disas/winch/x64/f64x2_div/const_avx.wat
index 7b2802535257..ac777acde83e 100644
--- a/tests/disas/winch/x64/f64x2_div/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_div/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_eq/const_avx.wat b/tests/disas/winch/x64/f64x2_eq/const_avx.wat
index cecb0bd3b3ab..6045a30073b5 100644
--- a/tests/disas/winch/x64/f64x2_eq/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_eq/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_extract_lane/first_lane_avx.wat b/tests/disas/winch/x64/f64x2_extract_lane/first_lane_avx.wat
index a16d717cd73f..b854a72b6ab4 100644
--- a/tests/disas/winch/x64/f64x2_extract_lane/first_lane_avx.wat
+++ b/tests/disas/winch/x64/f64x2_extract_lane/first_lane_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/f64x2_extract_lane/second_lane_avx.wat b/tests/disas/winch/x64/f64x2_extract_lane/second_lane_avx.wat
index 0ecac2f8bc31..0b2793427173 100644
--- a/tests/disas/winch/x64/f64x2_extract_lane/second_lane_avx.wat
+++ b/tests/disas/winch/x64/f64x2_extract_lane/second_lane_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f64x2_floor/const_avx.wat b/tests/disas/winch/x64/f64x2_floor/const_avx.wat
index 4e2f4bac6c01..20ad459e2926 100644
--- a/tests/disas/winch/x64/f64x2_floor/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_floor/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64x2_ge/const_avx.wat b/tests/disas/winch/x64/f64x2_ge/const_avx.wat
index 7f06e208fb3a..fe21f29ca7c4 100644
--- a/tests/disas/winch/x64/f64x2_ge/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_ge/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_gt/const_avx.wat b/tests/disas/winch/x64/f64x2_gt/const_avx.wat
index 57329372eecf..b1441bc218e5 100644
--- a/tests/disas/winch/x64/f64x2_gt/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_gt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_le/const_avx.wat b/tests/disas/winch/x64/f64x2_le/const_avx.wat
index fd55b236482b..2b4b31424a8a 100644
--- a/tests/disas/winch/x64/f64x2_le/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_le/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_lt/const_avx.wat b/tests/disas/winch/x64/f64x2_lt/const_avx.wat
index 2b4cbf2f5faa..df3251a84c9a 100644
--- a/tests/disas/winch/x64/f64x2_lt/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_lt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_max/const_avx.wat b/tests/disas/winch/x64/f64x2_max/const_avx.wat
index 878ad3de2fdf..4e5d06531824 100644
--- a/tests/disas/winch/x64/f64x2_max/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_max/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x70
diff --git a/tests/disas/winch/x64/f64x2_min/const_avx.wat b/tests/disas/winch/x64/f64x2_min/const_avx.wat
index 21bd48494780..d9e7da4d1897 100644
--- a/tests/disas/winch/x64/f64x2_min/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_min/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/f64x2_mul/const_avx.wat b/tests/disas/winch/x64/f64x2_mul/const_avx.wat
index c340c5db666f..ad2723459bc7 100644
--- a/tests/disas/winch/x64/f64x2_mul/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_mul/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_ne/const_avx.wat b/tests/disas/winch/x64/f64x2_ne/const_avx.wat
index 2a53b742a546..64e662d9fbf3 100644
--- a/tests/disas/winch/x64/f64x2_ne/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/f64x2_nearest/const_avx.wat b/tests/disas/winch/x64/f64x2_nearest/const_avx.wat
index 2ebe3a34c275..98aa31580f48 100644
--- a/tests/disas/winch/x64/f64x2_nearest/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_nearest/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/f64x2_neg/const_avx.wat b/tests/disas/winch/x64/f64x2_neg/const_avx.wat
index 9a2418029384..801cc4f539aa 100644
--- a/tests/disas/winch/x64/f64x2_neg/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_neg/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_pmax/const_avx.wat b/tests/disas/winch/x64/f64x2_pmax/const_avx.wat
index 53af5c2c6d06..731287ab43d7 100644
--- a/tests/disas/winch/x64/f64x2_pmax/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_pmax/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_pmin/const_avx.wat b/tests/disas/winch/x64/f64x2_pmin/const_avx.wat
index b4c45e77da37..cd0e604e022f 100644
--- a/tests/disas/winch/x64/f64x2_pmin/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_pmin/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_promote_low_f32x4/const_avx.wat b/tests/disas/winch/x64/f64x2_promote_low_f32x4/const_avx.wat
index 38005602e5f0..824dbcba2e7a 100644
--- a/tests/disas/winch/x64/f64x2_promote_low_f32x4/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_promote_low_f32x4/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f64x2_replace_lane/const_lane0_avx.wat b/tests/disas/winch/x64/f64x2_replace_lane/const_lane0_avx.wat
index 7028458fe2ef..c3d3572230cb 100644
--- a/tests/disas/winch/x64/f64x2_replace_lane/const_lane0_avx.wat
+++ b/tests/disas/winch/x64/f64x2_replace_lane/const_lane0_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/f64x2_replace_lane/const_lane1_avx.wat b/tests/disas/winch/x64/f64x2_replace_lane/const_lane1_avx.wat
index bd5ae4e0c6cf..6fdb6b52b917 100644
--- a/tests/disas/winch/x64/f64x2_replace_lane/const_lane1_avx.wat
+++ b/tests/disas/winch/x64/f64x2_replace_lane/const_lane1_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/f64x2_replace_lane/param_lane0_avx.wat b/tests/disas/winch/x64/f64x2_replace_lane/param_lane0_avx.wat
index 0acef33a4375..504c2bafd334 100644
--- a/tests/disas/winch/x64/f64x2_replace_lane/param_lane0_avx.wat
+++ b/tests/disas/winch/x64/f64x2_replace_lane/param_lane0_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/f64x2_replace_lane/param_lane1_avx.wat b/tests/disas/winch/x64/f64x2_replace_lane/param_lane1_avx.wat
index 2e7428616532..ef8daf6065b9 100644
--- a/tests/disas/winch/x64/f64x2_replace_lane/param_lane1_avx.wat
+++ b/tests/disas/winch/x64/f64x2_replace_lane/param_lane1_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/f64x2_splat/const_avx.wat b/tests/disas/winch/x64/f64x2_splat/const_avx.wat
index e6bb0ab1e076..942c76cad4f8 100644
--- a/tests/disas/winch/x64/f64x2_splat/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_splat/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/f64x2_splat/param_avx.wat b/tests/disas/winch/x64/f64x2_splat/param_avx.wat
index 62986f2509f7..9e708a0a8236 100644
--- a/tests/disas/winch/x64/f64x2_splat/param_avx.wat
+++ b/tests/disas/winch/x64/f64x2_splat/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/f64x2_sqrt/const_avx.wat b/tests/disas/winch/x64/f64x2_sqrt/const_avx.wat
index 3eedade6ef75..64dfeadfd9eb 100644
--- a/tests/disas/winch/x64/f64x2_sqrt/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_sqrt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/f64x2_sub/const_avx.wat b/tests/disas/winch/x64/f64x2_sub/const_avx.wat
index 4527fe9fc7b1..9753ec8eb11b 100644
--- a/tests/disas/winch/x64/f64x2_sub/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_sub/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/f64x2_trunc/const_avx.wat b/tests/disas/winch/x64/f64x2_trunc/const_avx.wat
index c64701bbdae7..9858c118e4d1 100644
--- a/tests/disas/winch/x64/f64x2_trunc/const_avx.wat
+++ b/tests/disas/winch/x64/f64x2_trunc/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/fuel/call.wat b/tests/disas/winch/x64/fuel/call.wat
index 6ca093472877..99d38232ba3a 100644
--- a/tests/disas/winch/x64/fuel/call.wat
+++ b/tests/disas/winch/x64/fuel/call.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xae
@@ -57,7 +57,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x117
diff --git a/tests/disas/winch/x64/fuel/func.wat b/tests/disas/winch/x64/fuel/func.wat
index cefba99a7980..b96f74dda68c 100644
--- a/tests/disas/winch/x64/fuel/func.wat
+++ b/tests/disas/winch/x64/fuel/func.wat
@@ -7,7 +7,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/fuel/loop.wat b/tests/disas/winch/x64/fuel/loop.wat
index fcb24042b256..bcf78ce4186e 100644
--- a/tests/disas/winch/x64/fuel/loop.wat
+++ b/tests/disas/winch/x64/fuel/loop.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9b
diff --git a/tests/disas/winch/x64/i16x8/add/add.wat b/tests/disas/winch/x64/i16x8/add/add.wat
index 657377ab1d33..ddc4fce8b41d 100644
--- a/tests/disas/winch/x64/i16x8/add/add.wat
+++ b/tests/disas/winch/x64/i16x8/add/add.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/add/add_sat_s.wat b/tests/disas/winch/x64/i16x8/add/add_sat_s.wat
index f3244ab70981..8289b477c0b5 100644
--- a/tests/disas/winch/x64/i16x8/add/add_sat_s.wat
+++ b/tests/disas/winch/x64/i16x8/add/add_sat_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/add/add_sat_u.wat b/tests/disas/winch/x64/i16x8/add/add_sat_u.wat
index 66cf701d26c6..4b256e0e5967 100644
--- a/tests/disas/winch/x64/i16x8/add/add_sat_u.wat
+++ b/tests/disas/winch/x64/i16x8/add/add_sat_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/extadd/extadd_s.wat b/tests/disas/winch/x64/i16x8/extadd/extadd_s.wat
index d414064e0018..67f93e4dae7a 100644
--- a/tests/disas/winch/x64/i16x8/extadd/extadd_s.wat
+++ b/tests/disas/winch/x64/i16x8/extadd/extadd_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i16x8/extadd/extadd_u.wat b/tests/disas/winch/x64/i16x8/extadd/extadd_u.wat
index 243fe0e048d9..e26511e8c15f 100644
--- a/tests/disas/winch/x64/i16x8/extadd/extadd_u.wat
+++ b/tests/disas/winch/x64/i16x8/extadd/extadd_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/i16x8/extmul/high_s.wat b/tests/disas/winch/x64/i16x8/extmul/high_s.wat
index 915b52cd6921..363b66de572a 100644
--- a/tests/disas/winch/x64/i16x8/extmul/high_s.wat
+++ b/tests/disas/winch/x64/i16x8/extmul/high_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6d
diff --git a/tests/disas/winch/x64/i16x8/extmul/high_u.wat b/tests/disas/winch/x64/i16x8/extmul/high_u.wat
index de4008b34e9d..5a71a01a47bd 100644
--- a/tests/disas/winch/x64/i16x8/extmul/high_u.wat
+++ b/tests/disas/winch/x64/i16x8/extmul/high_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6b
diff --git a/tests/disas/winch/x64/i16x8/extmul/low_s.wat b/tests/disas/winch/x64/i16x8/extmul/low_s.wat
index 25537bcc753d..7cb86b3b5e2a 100644
--- a/tests/disas/winch/x64/i16x8/extmul/low_s.wat
+++ b/tests/disas/winch/x64/i16x8/extmul/low_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/i16x8/extmul/low_u.wat b/tests/disas/winch/x64/i16x8/extmul/low_u.wat
index 9cdf9a6e86d0..2fdc5d0e31ca 100644
--- a/tests/disas/winch/x64/i16x8/extmul/low_u.wat
+++ b/tests/disas/winch/x64/i16x8/extmul/low_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/i16x8/extract_lane_s/const_avx.wat b/tests/disas/winch/x64/i16x8/extract_lane_s/const_avx.wat
index 29a064b1ec6f..0b169cbbfd9c 100644
--- a/tests/disas/winch/x64/i16x8/extract_lane_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8/extract_lane_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i16x8/extract_lane_u/const.wat b/tests/disas/winch/x64/i16x8/extract_lane_u/const.wat
index 948908356580..ffa2d63e0d71 100644
--- a/tests/disas/winch/x64/i16x8/extract_lane_u/const.wat
+++ b/tests/disas/winch/x64/i16x8/extract_lane_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i16x8/max/max_s.wat b/tests/disas/winch/x64/i16x8/max/max_s.wat
index 98a6a28ee602..a368b94c00e3 100644
--- a/tests/disas/winch/x64/i16x8/max/max_s.wat
+++ b/tests/disas/winch/x64/i16x8/max/max_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i16x8/max/max_u.wat b/tests/disas/winch/x64/i16x8/max/max_u.wat
index ce262fdcf3d7..32899174019b 100644
--- a/tests/disas/winch/x64/i16x8/max/max_u.wat
+++ b/tests/disas/winch/x64/i16x8/max/max_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i16x8/min/min_s.wat b/tests/disas/winch/x64/i16x8/min/min_s.wat
index d488c61004da..a28a9b668791 100644
--- a/tests/disas/winch/x64/i16x8/min/min_s.wat
+++ b/tests/disas/winch/x64/i16x8/min/min_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i16x8/min/min_u.wat b/tests/disas/winch/x64/i16x8/min/min_u.wat
index fe986183c796..3f673013e0a8 100644
--- a/tests/disas/winch/x64/i16x8/min/min_u.wat
+++ b/tests/disas/winch/x64/i16x8/min/min_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i16x8/mul/mul.wat b/tests/disas/winch/x64/i16x8/mul/mul.wat
index 25f55dcb6b13..46b886db5a78 100644
--- a/tests/disas/winch/x64/i16x8/mul/mul.wat
+++ b/tests/disas/winch/x64/i16x8/mul/mul.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/neg/neg.wat b/tests/disas/winch/x64/i16x8/neg/neg.wat
index 0a0add13d0f4..fac9bf5bf012 100644
--- a/tests/disas/winch/x64/i16x8/neg/neg.wat
+++ b/tests/disas/winch/x64/i16x8/neg/neg.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i16x8/replace_lane/const_avx.wat b/tests/disas/winch/x64/i16x8/replace_lane/const_avx.wat
index 97fc0a9fed16..e56acdaf2b7e 100644
--- a/tests/disas/winch/x64/i16x8/replace_lane/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8/replace_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i16x8/replace_lane/param_avx.wat b/tests/disas/winch/x64/i16x8/replace_lane/param_avx.wat
index 98b944a0457e..afa8629d0c54 100644
--- a/tests/disas/winch/x64/i16x8/replace_lane/param_avx.wat
+++ b/tests/disas/winch/x64/i16x8/replace_lane/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i16x8/shift/shl.wat b/tests/disas/winch/x64/i16x8/shift/shl.wat
index 8cb8450cd000..d5732c1ceed1 100644
--- a/tests/disas/winch/x64/i16x8/shift/shl.wat
+++ b/tests/disas/winch/x64/i16x8/shift/shl.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i16x8/shift/shr_s.wat b/tests/disas/winch/x64/i16x8/shift/shr_s.wat
index 90c25e2fdfae..74df5b42c8b8 100644
--- a/tests/disas/winch/x64/i16x8/shift/shr_s.wat
+++ b/tests/disas/winch/x64/i16x8/shift/shr_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i16x8/shift/shr_u.wat b/tests/disas/winch/x64/i16x8/shift/shr_u.wat
index 2cbafdf3ef9b..ef1695089b5d 100644
--- a/tests/disas/winch/x64/i16x8/shift/shr_u.wat
+++ b/tests/disas/winch/x64/i16x8/shift/shr_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i16x8/splat/const_avx2.wat b/tests/disas/winch/x64/i16x8/splat/const_avx2.wat
index 0ec91d7c127e..732221f472cb 100644
--- a/tests/disas/winch/x64/i16x8/splat/const_avx2.wat
+++ b/tests/disas/winch/x64/i16x8/splat/const_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i16x8/splat/param_avx2.wat b/tests/disas/winch/x64/i16x8/splat/param_avx2.wat
index 6b32b4a0525d..0773d9db93bd 100644
--- a/tests/disas/winch/x64/i16x8/splat/param_avx2.wat
+++ b/tests/disas/winch/x64/i16x8/splat/param_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i16x8/sub/sub.wat b/tests/disas/winch/x64/i16x8/sub/sub.wat
index e2543a13810c..4e973ecab153 100644
--- a/tests/disas/winch/x64/i16x8/sub/sub.wat
+++ b/tests/disas/winch/x64/i16x8/sub/sub.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/sub/sub_sat_s.wat b/tests/disas/winch/x64/i16x8/sub/sub_sat_s.wat
index 821920a430c7..0a12e0a16acb 100644
--- a/tests/disas/winch/x64/i16x8/sub/sub_sat_s.wat
+++ b/tests/disas/winch/x64/i16x8/sub/sub_sat_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8/sub/sub_sat_u.wat b/tests/disas/winch/x64/i16x8/sub/sub_sat_u.wat
index 655a5c6c146f..e766c13da9c9 100644
--- a/tests/disas/winch/x64/i16x8/sub/sub_sat_u.wat
+++ b/tests/disas/winch/x64/i16x8/sub/sub_sat_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_abs/const_avx.wat b/tests/disas/winch/x64/i16x8_abs/const_avx.wat
index 9bd95bb8c6c3..e2dc365f55bb 100644
--- a/tests/disas/winch/x64/i16x8_abs/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i16x8_all_true/const_avx.wat b/tests/disas/winch/x64/i16x8_all_true/const_avx.wat
index ede6ec76c6e6..d9b21707950e 100644
--- a/tests/disas/winch/x64/i16x8_all_true/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_all_true/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i16x8_avgr_u/const_avx.wat b/tests/disas/winch/x64/i16x8_avgr_u/const_avx.wat
index 5522afa37a77..63a694ae010c 100644
--- a/tests/disas/winch/x64/i16x8_avgr_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_avgr_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_bitmask/const_avx.wat b/tests/disas/winch/x64/i16x8_bitmask/const_avx.wat
index ad693012e29e..da1afb3035a0 100644
--- a/tests/disas/winch/x64/i16x8_bitmask/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_bitmask/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i16x8_eq/const_avx.wat b/tests/disas/winch/x64/i16x8_eq/const_avx.wat
index b5d17a4ab409..134a4e96e80b 100644
--- a/tests/disas/winch/x64/i16x8_eq/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_eq/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_extend_high_i8x16_s/const_avx.wat b/tests/disas/winch/x64/i16x8_extend_high_i8x16_s/const_avx.wat
index 28d4579af014..0fe8fa5339de 100644
--- a/tests/disas/winch/x64/i16x8_extend_high_i8x16_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_extend_high_i8x16_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i16x8_extend_high_i8x16_u/const_avx.wat b/tests/disas/winch/x64/i16x8_extend_high_i8x16_u/const_avx.wat
index 58a89f33eff2..1861ffd3d6cb 100644
--- a/tests/disas/winch/x64/i16x8_extend_high_i8x16_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_extend_high_i8x16_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i16x8_extend_low_i8x16_s/const_avx.wat b/tests/disas/winch/x64/i16x8_extend_low_i8x16_s/const_avx.wat
index 09e8947a16ac..cd335a6d9e72 100644
--- a/tests/disas/winch/x64/i16x8_extend_low_i8x16_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_extend_low_i8x16_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i16x8_extend_low_i8x16_u/const_avx.wat b/tests/disas/winch/x64/i16x8_extend_low_i8x16_u/const_avx.wat
index 3283ca0b0746..994bbc476abf 100644
--- a/tests/disas/winch/x64/i16x8_extend_low_i8x16_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_extend_low_i8x16_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i16x8_ge_s/const_avx.wat b/tests/disas/winch/x64/i16x8_ge_s/const_avx.wat
index d5b1539476af..94d8b6ec58ea 100644
--- a/tests/disas/winch/x64/i16x8_ge_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_ge_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/i16x8_ge_u/const_avx.wat b/tests/disas/winch/x64/i16x8_ge_u/const_avx.wat
index 1db6bdc25969..8e00f0892f57 100644
--- a/tests/disas/winch/x64/i16x8_ge_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_ge_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i16x8_gt_s/const_avx.wat b/tests/disas/winch/x64/i16x8_gt_s/const_avx.wat
index 84e4a0b508b7..6f5e504bb46d 100644
--- a/tests/disas/winch/x64/i16x8_gt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_gt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_gt_u/const_avx.wat b/tests/disas/winch/x64/i16x8_gt_u/const_avx.wat
index 3366aff6fbb6..e9156cc24ac2 100644
--- a/tests/disas/winch/x64/i16x8_gt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_gt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i16x8_le_s/const_avx.wat b/tests/disas/winch/x64/i16x8_le_s/const_avx.wat
index bae09fd6030f..c03b38fed5ed 100644
--- a/tests/disas/winch/x64/i16x8_le_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_le_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/i16x8_le_u/const_avx.wat b/tests/disas/winch/x64/i16x8_le_u/const_avx.wat
index 146fb36706ed..05e428df731b 100644
--- a/tests/disas/winch/x64/i16x8_le_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_le_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i16x8_lt_s/const_avx.wat b/tests/disas/winch/x64/i16x8_lt_s/const_avx.wat
index fdbaa2ed8627..f60c9bf52f1c 100644
--- a/tests/disas/winch/x64/i16x8_lt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_lt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_lt_u/const_avx.wat b/tests/disas/winch/x64/i16x8_lt_u/const_avx.wat
index 3483f7325216..2ce769e30d47 100644
--- a/tests/disas/winch/x64/i16x8_lt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_lt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i16x8_narrow_i32x4_s/const_avx.wat b/tests/disas/winch/x64/i16x8_narrow_i32x4_s/const_avx.wat
index 22b791885eeb..4b8d93ad0772 100644
--- a/tests/disas/winch/x64/i16x8_narrow_i32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_narrow_i32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i16x8_narrow_i32x4_u/const_avx.wat b/tests/disas/winch/x64/i16x8_narrow_i32x4_u/const_avx.wat
index 4e48f7576928..a89ccc781e8a 100644
--- a/tests/disas/winch/x64/i16x8_narrow_i32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_narrow_i32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i16x8_ne/const_avx.wat b/tests/disas/winch/x64/i16x8_ne/const_avx.wat
index 4b05fcdb7340..e4309a088086 100644
--- a/tests/disas/winch/x64/i16x8_ne/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i16x8_q15mulr_sat_s/const_avx.wat b/tests/disas/winch/x64/i16x8_q15mulr_sat_s/const_avx.wat
index 5cb49c7575c0..33f06fb7aaec 100644
--- a/tests/disas/winch/x64/i16x8_q15mulr_sat_s/const_avx.wat
+++ b/tests/disas/winch/x64/i16x8_q15mulr_sat_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i32_add/const.wat b/tests/disas/winch/x64/i32_add/const.wat
index 3935fa9a1aa3..f2f4e73c35aa 100644
--- a/tests/disas/winch/x64/i32_add/const.wat
+++ b/tests/disas/winch/x64/i32_add/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_add/locals.wat b/tests/disas/winch/x64/i32_add/locals.wat
index 17d87810d7ef..74d65d9a174b 100644
--- a/tests/disas/winch/x64/i32_add/locals.wat
+++ b/tests/disas/winch/x64/i32_add/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/i32_add/max.wat b/tests/disas/winch/x64/i32_add/max.wat
index f8025c1f8fe3..8b31f37a258f 100644
--- a/tests/disas/winch/x64/i32_add/max.wat
+++ b/tests/disas/winch/x64/i32_add/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_add/max_one.wat b/tests/disas/winch/x64/i32_add/max_one.wat
index 6addd7aa6e80..f8c5b1b8341d 100644
--- a/tests/disas/winch/x64/i32_add/max_one.wat
+++ b/tests/disas/winch/x64/i32_add/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_add/mixed.wat b/tests/disas/winch/x64/i32_add/mixed.wat
index 99a2eea64536..f1b683e232c4 100644
--- a/tests/disas/winch/x64/i32_add/mixed.wat
+++ b/tests/disas/winch/x64/i32_add/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_add/params.wat b/tests/disas/winch/x64/i32_add/params.wat
index 24681bce6d2b..cc80c61480df 100644
--- a/tests/disas/winch/x64/i32_add/params.wat
+++ b/tests/disas/winch/x64/i32_add/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32_add/signed.wat b/tests/disas/winch/x64/i32_add/signed.wat
index 6150aa2191d0..7cbc1502baaf 100644
--- a/tests/disas/winch/x64/i32_add/signed.wat
+++ b/tests/disas/winch/x64/i32_add/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat
index 491cf2fcbf83..e25f56b58878 100644
--- a/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_and/const.wat b/tests/disas/winch/x64/i32_and/const.wat
index 3a630936724b..29dd7608d97c 100644
--- a/tests/disas/winch/x64/i32_and/const.wat
+++ b/tests/disas/winch/x64/i32_and/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_and/locals.wat b/tests/disas/winch/x64/i32_and/locals.wat
index 8a36fb8be53e..d1443116e671 100644
--- a/tests/disas/winch/x64/i32_and/locals.wat
+++ b/tests/disas/winch/x64/i32_and/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/i32_and/params.wat b/tests/disas/winch/x64/i32_and/params.wat
index 852a800fe1ca..19d97e0cebc1 100644
--- a/tests/disas/winch/x64/i32_and/params.wat
+++ b/tests/disas/winch/x64/i32_and/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_const.wat b/tests/disas/winch/x64/i32_clz/lzcnt_const.wat
index 479728c7aa98..d0a763f5306a 100644
--- a/tests/disas/winch/x64/i32_clz/lzcnt_const.wat
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_local.wat b/tests/disas/winch/x64/i32_clz/lzcnt_local.wat
index 9d15ee219672..1310489dbe95 100644
--- a/tests/disas/winch/x64/i32_clz/lzcnt_local.wat
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_local.wat
@@ -17,7 +17,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_param.wat b/tests/disas/winch/x64/i32_clz/lzcnt_param.wat
index d5cc330a0ecc..80463df96b02 100644
--- a/tests/disas/winch/x64/i32_clz/lzcnt_param.wat
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_param.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat
index dbbfb596104e..75063ed6b55c 100644
--- a/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat
index 89cc051523f9..01952128e0a2 100644
--- a/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x63
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat
index 36405e758ebf..1710ed7e7178 100644
--- a/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_const.wat b/tests/disas/winch/x64/i32_ctz/bmi1_const.wat
index 6e552cba49f3..14c5534ba6f3 100644
--- a/tests/disas/winch/x64/i32_ctz/bmi1_const.wat
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_local.wat b/tests/disas/winch/x64/i32_ctz/bmi1_local.wat
index 8893ba64ee8f..85b73a052705 100644
--- a/tests/disas/winch/x64/i32_ctz/bmi1_local.wat
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_local.wat
@@ -18,7 +18,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_param.wat b/tests/disas/winch/x64/i32_ctz/bmi1_param.wat
index 796450faf93f..631bea5824e6 100644
--- a/tests/disas/winch/x64/i32_ctz/bmi1_param.wat
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_param.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat
index 0cf0250d861b..7e31bf158d37 100644
--- a/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat
index a827def48ca4..4904abb57005 100644
--- a/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat
index edf6f15d0c4e..73ae872ebb03 100644
--- a/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_divs/const.wat b/tests/disas/winch/x64/i32_divs/const.wat
index ea1cd3c9083c..eafa4328a360 100644
--- a/tests/disas/winch/x64/i32_divs/const.wat
+++ b/tests/disas/winch/x64/i32_divs/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_divs/one_zero.wat b/tests/disas/winch/x64/i32_divs/one_zero.wat
index e1741d1188b7..49b2369e1b67 100644
--- a/tests/disas/winch/x64/i32_divs/one_zero.wat
+++ b/tests/disas/winch/x64/i32_divs/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_divs/overflow.wat b/tests/disas/winch/x64/i32_divs/overflow.wat
index e64d52f806cf..f9b13835a6f3 100644
--- a/tests/disas/winch/x64/i32_divs/overflow.wat
+++ b/tests/disas/winch/x64/i32_divs/overflow.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_divs/params.wat b/tests/disas/winch/x64/i32_divs/params.wat
index a026bbea7497..5309ea267602 100644
--- a/tests/disas/winch/x64/i32_divs/params.wat
+++ b/tests/disas/winch/x64/i32_divs/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_divs/zero_zero.wat b/tests/disas/winch/x64/i32_divs/zero_zero.wat
index 1acf3bde7dbc..b16818233a3e 100644
--- a/tests/disas/winch/x64/i32_divs/zero_zero.wat
+++ b/tests/disas/winch/x64/i32_divs/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_divu/const.wat b/tests/disas/winch/x64/i32_divu/const.wat
index 2a4da89f9d3e..f07ab268cb0b 100644
--- a/tests/disas/winch/x64/i32_divu/const.wat
+++ b/tests/disas/winch/x64/i32_divu/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i32_divu/one_zero.wat b/tests/disas/winch/x64/i32_divu/one_zero.wat
index 34f86025aeee..eaff0673fdac 100644
--- a/tests/disas/winch/x64/i32_divu/one_zero.wat
+++ b/tests/disas/winch/x64/i32_divu/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i32_divu/params.wat b/tests/disas/winch/x64/i32_divu/params.wat
index c39b9e2d290d..f91faf55c529 100644
--- a/tests/disas/winch/x64/i32_divu/params.wat
+++ b/tests/disas/winch/x64/i32_divu/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32_divu/signed.wat b/tests/disas/winch/x64/i32_divu/signed.wat
index 774d19aacb64..2b9f238b9b00 100644
--- a/tests/disas/winch/x64/i32_divu/signed.wat
+++ b/tests/disas/winch/x64/i32_divu/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i32_divu/zero_zero.wat b/tests/disas/winch/x64/i32_divu/zero_zero.wat
index 3c8bca61becd..33f83cdcdc24 100644
--- a/tests/disas/winch/x64/i32_divu/zero_zero.wat
+++ b/tests/disas/winch/x64/i32_divu/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i32_eq/const.wat b/tests/disas/winch/x64/i32_eq/const.wat
index 42828f9c539b..3f5bd92df67a 100644
--- a/tests/disas/winch/x64/i32_eq/const.wat
+++ b/tests/disas/winch/x64/i32_eq/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_eq/locals.wat b/tests/disas/winch/x64/i32_eq/locals.wat
index 55392a9667ea..9c35e6f52b0b 100644
--- a/tests/disas/winch/x64/i32_eq/locals.wat
+++ b/tests/disas/winch/x64/i32_eq/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_eq/params.wat b/tests/disas/winch/x64/i32_eq/params.wat
index f765c1e0da9b..b560277cc50c 100644
--- a/tests/disas/winch/x64/i32_eq/params.wat
+++ b/tests/disas/winch/x64/i32_eq/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_eqz/const.wat b/tests/disas/winch/x64/i32_eqz/const.wat
index 238ddc937eeb..4b2e9d8f46c0 100644
--- a/tests/disas/winch/x64/i32_eqz/const.wat
+++ b/tests/disas/winch/x64/i32_eqz/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_eqz/local.wat b/tests/disas/winch/x64/i32_eqz/local.wat
index d38112b5a4e3..bddd32a4ecbe 100644
--- a/tests/disas/winch/x64/i32_eqz/local.wat
+++ b/tests/disas/winch/x64/i32_eqz/local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i32_eqz/param.wat b/tests/disas/winch/x64/i32_eqz/param.wat
index f72214733579..853ad8750f1e 100644
--- a/tests/disas/winch/x64/i32_eqz/param.wat
+++ b/tests/disas/winch/x64/i32_eqz/param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/i32_extend_16_s/const.wat b/tests/disas/winch/x64/i32_extend_16_s/const.wat
index 3bf4b10210ff..b29b5ccbd2f0 100644
--- a/tests/disas/winch/x64/i32_extend_16_s/const.wat
+++ b/tests/disas/winch/x64/i32_extend_16_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_extend_16_s/locals.wat b/tests/disas/winch/x64/i32_extend_16_s/locals.wat
index 5cc32722aecf..9c8f71ea9ac5 100644
--- a/tests/disas/winch/x64/i32_extend_16_s/locals.wat
+++ b/tests/disas/winch/x64/i32_extend_16_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i32_extend_16_s/params.wat b/tests/disas/winch/x64/i32_extend_16_s/params.wat
index d99ba18e0283..4ad45e6a1376 100644
--- a/tests/disas/winch/x64/i32_extend_16_s/params.wat
+++ b/tests/disas/winch/x64/i32_extend_16_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i32_extend_8_s/const.wat b/tests/disas/winch/x64/i32_extend_8_s/const.wat
index 59a1dcb20e39..0e6d65990b8c 100644
--- a/tests/disas/winch/x64/i32_extend_8_s/const.wat
+++ b/tests/disas/winch/x64/i32_extend_8_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_extend_8_s/locals.wat b/tests/disas/winch/x64/i32_extend_8_s/locals.wat
index 9607874cbc73..497e2419ad59 100644
--- a/tests/disas/winch/x64/i32_extend_8_s/locals.wat
+++ b/tests/disas/winch/x64/i32_extend_8_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i32_extend_8_s/params.wat b/tests/disas/winch/x64/i32_extend_8_s/params.wat
index 34a7284c108f..908c5a745fbf 100644
--- a/tests/disas/winch/x64/i32_extend_8_s/params.wat
+++ b/tests/disas/winch/x64/i32_extend_8_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i32_ge_s/const.wat b/tests/disas/winch/x64/i32_ge_s/const.wat
index 733b98b8c19e..8a068399ff76 100644
--- a/tests/disas/winch/x64/i32_ge_s/const.wat
+++ b/tests/disas/winch/x64/i32_ge_s/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_ge_s/locals.wat b/tests/disas/winch/x64/i32_ge_s/locals.wat
index b6d7dcbf9684..1e7bec84aea2 100644
--- a/tests/disas/winch/x64/i32_ge_s/locals.wat
+++ b/tests/disas/winch/x64/i32_ge_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_ge_s/params.wat b/tests/disas/winch/x64/i32_ge_s/params.wat
index 70bbd96d13e9..581d232ee80d 100644
--- a/tests/disas/winch/x64/i32_ge_s/params.wat
+++ b/tests/disas/winch/x64/i32_ge_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_ge_u/const.wat b/tests/disas/winch/x64/i32_ge_u/const.wat
index 284cc27e9b3e..b67850611421 100644
--- a/tests/disas/winch/x64/i32_ge_u/const.wat
+++ b/tests/disas/winch/x64/i32_ge_u/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_ge_u/locals.wat b/tests/disas/winch/x64/i32_ge_u/locals.wat
index c04c8f736eff..774252e08c82 100644
--- a/tests/disas/winch/x64/i32_ge_u/locals.wat
+++ b/tests/disas/winch/x64/i32_ge_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_ge_u/params.wat b/tests/disas/winch/x64/i32_ge_u/params.wat
index e6b1675a8f1b..0ae0ae801339 100644
--- a/tests/disas/winch/x64/i32_ge_u/params.wat
+++ b/tests/disas/winch/x64/i32_ge_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_gt_s/const.wat b/tests/disas/winch/x64/i32_gt_s/const.wat
index fc9486298611..7c9b7c8b655f 100644
--- a/tests/disas/winch/x64/i32_gt_s/const.wat
+++ b/tests/disas/winch/x64/i32_gt_s/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_gt_s/locals.wat b/tests/disas/winch/x64/i32_gt_s/locals.wat
index 1b3dc6ebef23..a4d9f225d63e 100644
--- a/tests/disas/winch/x64/i32_gt_s/locals.wat
+++ b/tests/disas/winch/x64/i32_gt_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_gt_s/params.wat b/tests/disas/winch/x64/i32_gt_s/params.wat
index a183f5361a03..be3028baedb8 100644
--- a/tests/disas/winch/x64/i32_gt_s/params.wat
+++ b/tests/disas/winch/x64/i32_gt_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_gt_u/const.wat b/tests/disas/winch/x64/i32_gt_u/const.wat
index a06c71e04892..8938bff56728 100644
--- a/tests/disas/winch/x64/i32_gt_u/const.wat
+++ b/tests/disas/winch/x64/i32_gt_u/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_gt_u/locals.wat b/tests/disas/winch/x64/i32_gt_u/locals.wat
index 872aeced6667..7e03c00f66b7 100644
--- a/tests/disas/winch/x64/i32_gt_u/locals.wat
+++ b/tests/disas/winch/x64/i32_gt_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_gt_u/params.wat b/tests/disas/winch/x64/i32_gt_u/params.wat
index ee6807be15e7..6aaff7e3ed6c 100644
--- a/tests/disas/winch/x64/i32_gt_u/params.wat
+++ b/tests/disas/winch/x64/i32_gt_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_le_s/const.wat b/tests/disas/winch/x64/i32_le_s/const.wat
index e0729bef4026..1933965494df 100644
--- a/tests/disas/winch/x64/i32_le_s/const.wat
+++ b/tests/disas/winch/x64/i32_le_s/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_le_s/locals.wat b/tests/disas/winch/x64/i32_le_s/locals.wat
index 99ac4d92e090..b5cc09f1b1fb 100644
--- a/tests/disas/winch/x64/i32_le_s/locals.wat
+++ b/tests/disas/winch/x64/i32_le_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_le_s/params.wat b/tests/disas/winch/x64/i32_le_s/params.wat
index ad73b7481038..a4d01aee603c 100644
--- a/tests/disas/winch/x64/i32_le_s/params.wat
+++ b/tests/disas/winch/x64/i32_le_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_le_u/const.wat b/tests/disas/winch/x64/i32_le_u/const.wat
index a2fa84467c9d..0fc18cee585a 100644
--- a/tests/disas/winch/x64/i32_le_u/const.wat
+++ b/tests/disas/winch/x64/i32_le_u/const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_le_u/locals.wat b/tests/disas/winch/x64/i32_le_u/locals.wat
index c3a33fe02a82..2fa4032ba519 100644
--- a/tests/disas/winch/x64/i32_le_u/locals.wat
+++ b/tests/disas/winch/x64/i32_le_u/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_le_u/params.wat b/tests/disas/winch/x64/i32_le_u/params.wat
index 60c34d9c8bd1..d6eb4cb2f01b 100644
--- a/tests/disas/winch/x64/i32_le_u/params.wat
+++ b/tests/disas/winch/x64/i32_le_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_lt_s/const.wat b/tests/disas/winch/x64/i32_lt_s/const.wat
index 374f2f657bff..634a27046c54 100644
--- a/tests/disas/winch/x64/i32_lt_s/const.wat
+++ b/tests/disas/winch/x64/i32_lt_s/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_lt_s/locals.wat b/tests/disas/winch/x64/i32_lt_s/locals.wat
index fce7e51b164b..3eeb53ac745b 100644
--- a/tests/disas/winch/x64/i32_lt_s/locals.wat
+++ b/tests/disas/winch/x64/i32_lt_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_lt_s/params.wat b/tests/disas/winch/x64/i32_lt_s/params.wat
index 60938eb4030c..a1bc9d9011f4 100644
--- a/tests/disas/winch/x64/i32_lt_s/params.wat
+++ b/tests/disas/winch/x64/i32_lt_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_lt_u/const.wat b/tests/disas/winch/x64/i32_lt_u/const.wat
index 388c7d96ec5b..bc84ced92cd7 100644
--- a/tests/disas/winch/x64/i32_lt_u/const.wat
+++ b/tests/disas/winch/x64/i32_lt_u/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_lt_u/locals.wat b/tests/disas/winch/x64/i32_lt_u/locals.wat
index b2f6e2feab02..12552715f785 100644
--- a/tests/disas/winch/x64/i32_lt_u/locals.wat
+++ b/tests/disas/winch/x64/i32_lt_u/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_lt_u/params.wat b/tests/disas/winch/x64/i32_lt_u/params.wat
index 4ecd8e556b8b..dcd7ed5a185c 100644
--- a/tests/disas/winch/x64/i32_lt_u/params.wat
+++ b/tests/disas/winch/x64/i32_lt_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_mul/const.wat b/tests/disas/winch/x64/i32_mul/const.wat
index fec18ab5d53c..7b9b4ae9d3d5 100644
--- a/tests/disas/winch/x64/i32_mul/const.wat
+++ b/tests/disas/winch/x64/i32_mul/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_mul/locals.wat b/tests/disas/winch/x64/i32_mul/locals.wat
index 92abb03cac8a..e4dedfdc08a8 100644
--- a/tests/disas/winch/x64/i32_mul/locals.wat
+++ b/tests/disas/winch/x64/i32_mul/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/i32_mul/max.wat b/tests/disas/winch/x64/i32_mul/max.wat
index bd8f6556e11c..ccdbd400f509 100644
--- a/tests/disas/winch/x64/i32_mul/max.wat
+++ b/tests/disas/winch/x64/i32_mul/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_mul/max_one.wat b/tests/disas/winch/x64/i32_mul/max_one.wat
index 985948293ed3..8d292c71ee2f 100644
--- a/tests/disas/winch/x64/i32_mul/max_one.wat
+++ b/tests/disas/winch/x64/i32_mul/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_mul/mixed.wat b/tests/disas/winch/x64/i32_mul/mixed.wat
index 895a0d4d1746..ade82d4e5807 100644
--- a/tests/disas/winch/x64/i32_mul/mixed.wat
+++ b/tests/disas/winch/x64/i32_mul/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_mul/params.wat b/tests/disas/winch/x64/i32_mul/params.wat
index 69a3f0ada145..1ddf23dd9a94 100644
--- a/tests/disas/winch/x64/i32_mul/params.wat
+++ b/tests/disas/winch/x64/i32_mul/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i32_mul/signed.wat b/tests/disas/winch/x64/i32_mul/signed.wat
index 0d715c26c739..f4225bd4cb26 100644
--- a/tests/disas/winch/x64/i32_mul/signed.wat
+++ b/tests/disas/winch/x64/i32_mul/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat
index 9f16328be248..1cbf6bd119da 100644
--- a/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i32_ne/const.wat b/tests/disas/winch/x64/i32_ne/const.wat
index 094e2a764909..3d94ee35a437 100644
--- a/tests/disas/winch/x64/i32_ne/const.wat
+++ b/tests/disas/winch/x64/i32_ne/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_ne/locals.wat b/tests/disas/winch/x64/i32_ne/locals.wat
index 170bfb306774..bbaaeb7fa864 100644
--- a/tests/disas/winch/x64/i32_ne/locals.wat
+++ b/tests/disas/winch/x64/i32_ne/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i32_ne/params.wat b/tests/disas/winch/x64/i32_ne/params.wat
index 56a791ec2df5..6decc21a446f 100644
--- a/tests/disas/winch/x64/i32_ne/params.wat
+++ b/tests/disas/winch/x64/i32_ne/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32_or/const.wat b/tests/disas/winch/x64/i32_or/const.wat
index 0a4d1ee99305..2ac11b00478b 100644
--- a/tests/disas/winch/x64/i32_or/const.wat
+++ b/tests/disas/winch/x64/i32_or/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_or/locals.wat b/tests/disas/winch/x64/i32_or/locals.wat
index 476cd2cf5e4b..3097b17353f1 100644
--- a/tests/disas/winch/x64/i32_or/locals.wat
+++ b/tests/disas/winch/x64/i32_or/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/i32_or/params.wat b/tests/disas/winch/x64/i32_or/params.wat
index b8c21bff3ded..2b1035482278 100644
--- a/tests/disas/winch/x64/i32_or/params.wat
+++ b/tests/disas/winch/x64/i32_or/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32_popcnt/const.wat b/tests/disas/winch/x64/i32_popcnt/const.wat
index d803b4102ed0..f2555253b321 100644
--- a/tests/disas/winch/x64/i32_popcnt/const.wat
+++ b/tests/disas/winch/x64/i32_popcnt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i32_popcnt/fallback.wat b/tests/disas/winch/x64/i32_popcnt/fallback.wat
index 1c84993ff3e1..fddfbe3c9c5b 100644
--- a/tests/disas/winch/x64/i32_popcnt/fallback.wat
+++ b/tests/disas/winch/x64/i32_popcnt/fallback.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/i32_popcnt/no_sse42.wat b/tests/disas/winch/x64/i32_popcnt/no_sse42.wat
index 336660a9eec8..86d4c0514478 100644
--- a/tests/disas/winch/x64/i32_popcnt/no_sse42.wat
+++ b/tests/disas/winch/x64/i32_popcnt/no_sse42.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x71
diff --git a/tests/disas/winch/x64/i32_popcnt/reg.wat b/tests/disas/winch/x64/i32_popcnt/reg.wat
index 90c13571730a..d3e33ec7102a 100644
--- a/tests/disas/winch/x64/i32_popcnt/reg.wat
+++ b/tests/disas/winch/x64/i32_popcnt/reg.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/const.wat b/tests/disas/winch/x64/i32_reinterpret_f32/const.wat
index ff2323da4d2a..c51c25b1a7fe 100644
--- a/tests/disas/winch/x64/i32_reinterpret_f32/const.wat
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat b/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat
index c76e1e9c89f2..9c658feea53f 100644
--- a/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/params.wat b/tests/disas/winch/x64/i32_reinterpret_f32/params.wat
index 17f2dc86d940..189f04b70110 100644
--- a/tests/disas/winch/x64/i32_reinterpret_f32/params.wat
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat b/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat
index 7bdf2462eb62..63a21d3b596a 100644
--- a/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/i32_rems/const.wat b/tests/disas/winch/x64/i32_rems/const.wat
index 9d3729559a3f..5082488fd2b2 100644
--- a/tests/disas/winch/x64/i32_rems/const.wat
+++ b/tests/disas/winch/x64/i32_rems/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i32_rems/one_zero.wat b/tests/disas/winch/x64/i32_rems/one_zero.wat
index 7cde89ac5d0f..f7e21b494e0e 100644
--- a/tests/disas/winch/x64/i32_rems/one_zero.wat
+++ b/tests/disas/winch/x64/i32_rems/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i32_rems/overflow.wat b/tests/disas/winch/x64/i32_rems/overflow.wat
index 663e34e8b3fd..785ad8803b07 100644
--- a/tests/disas/winch/x64/i32_rems/overflow.wat
+++ b/tests/disas/winch/x64/i32_rems/overflow.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i32_rems/params.wat b/tests/disas/winch/x64/i32_rems/params.wat
index 452f5cc28a4d..374f4a2c971a 100644
--- a/tests/disas/winch/x64/i32_rems/params.wat
+++ b/tests/disas/winch/x64/i32_rems/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/i32_rems/zero_zero.wat b/tests/disas/winch/x64/i32_rems/zero_zero.wat
index 5614746b6694..65e89c4e6d6d 100644
--- a/tests/disas/winch/x64/i32_rems/zero_zero.wat
+++ b/tests/disas/winch/x64/i32_rems/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i32_remu/const.wat b/tests/disas/winch/x64/i32_remu/const.wat
index 0d803daea96f..dfb42744d60f 100644
--- a/tests/disas/winch/x64/i32_remu/const.wat
+++ b/tests/disas/winch/x64/i32_remu/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_remu/one_zero.wat b/tests/disas/winch/x64/i32_remu/one_zero.wat
index 8f14c8ad171f..56b114811b22 100644
--- a/tests/disas/winch/x64/i32_remu/one_zero.wat
+++ b/tests/disas/winch/x64/i32_remu/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_remu/params.wat b/tests/disas/winch/x64/i32_remu/params.wat
index 64635632246f..a22abd289f3a 100644
--- a/tests/disas/winch/x64/i32_remu/params.wat
+++ b/tests/disas/winch/x64/i32_remu/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i32_remu/signed.wat b/tests/disas/winch/x64/i32_remu/signed.wat
index 3cad991f6d98..84d1e71fdf74 100644
--- a/tests/disas/winch/x64/i32_remu/signed.wat
+++ b/tests/disas/winch/x64/i32_remu/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_remu/zero_zero.wat b/tests/disas/winch/x64/i32_remu/zero_zero.wat
index 766e9734cfd7..2b528a2f1417 100644
--- a/tests/disas/winch/x64/i32_remu/zero_zero.wat
+++ b/tests/disas/winch/x64/i32_remu/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i32_rotl/16_const.wat b/tests/disas/winch/x64/i32_rotl/16_const.wat
index f419997fc05b..d3b054dc3329 100644
--- a/tests/disas/winch/x64/i32_rotl/16_const.wat
+++ b/tests/disas/winch/x64/i32_rotl/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_rotl/8_const.wat b/tests/disas/winch/x64/i32_rotl/8_const.wat
index d0446176e4ef..5052b093894d 100644
--- a/tests/disas/winch/x64/i32_rotl/8_const.wat
+++ b/tests/disas/winch/x64/i32_rotl/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_rotl/locals.wat b/tests/disas/winch/x64/i32_rotl/locals.wat
index c267a361b46a..0f6f0e2c1547 100644
--- a/tests/disas/winch/x64/i32_rotl/locals.wat
+++ b/tests/disas/winch/x64/i32_rotl/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i32_rotl/params.wat b/tests/disas/winch/x64/i32_rotl/params.wat
index a46607d341fc..111b4727a623 100644
--- a/tests/disas/winch/x64/i32_rotl/params.wat
+++ b/tests/disas/winch/x64/i32_rotl/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32_rotr/16_const.wat b/tests/disas/winch/x64/i32_rotr/16_const.wat
index 63ade0c037cc..6d7cc0e0e646 100644
--- a/tests/disas/winch/x64/i32_rotr/16_const.wat
+++ b/tests/disas/winch/x64/i32_rotr/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_rotr/8_const.wat b/tests/disas/winch/x64/i32_rotr/8_const.wat
index e5ee90e2115a..574339e8fec4 100644
--- a/tests/disas/winch/x64/i32_rotr/8_const.wat
+++ b/tests/disas/winch/x64/i32_rotr/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_rotr/locals.wat b/tests/disas/winch/x64/i32_rotr/locals.wat
index af3ee8343525..108bd91a4c82 100644
--- a/tests/disas/winch/x64/i32_rotr/locals.wat
+++ b/tests/disas/winch/x64/i32_rotr/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i32_rotr/params.wat b/tests/disas/winch/x64/i32_rotr/params.wat
index c96335bb0037..9b7e813a311e 100644
--- a/tests/disas/winch/x64/i32_rotr/params.wat
+++ b/tests/disas/winch/x64/i32_rotr/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32_shl/16_const.wat b/tests/disas/winch/x64/i32_shl/16_const.wat
index d05d52cfb40d..a871dd757206 100644
--- a/tests/disas/winch/x64/i32_shl/16_const.wat
+++ b/tests/disas/winch/x64/i32_shl/16_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shl/8_const.wat b/tests/disas/winch/x64/i32_shl/8_const.wat
index 728507f9ab66..513d9fe085a8 100644
--- a/tests/disas/winch/x64/i32_shl/8_const.wat
+++ b/tests/disas/winch/x64/i32_shl/8_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shl/locals.wat b/tests/disas/winch/x64/i32_shl/locals.wat
index dae11757310a..36e8b927fd1b 100644
--- a/tests/disas/winch/x64/i32_shl/locals.wat
+++ b/tests/disas/winch/x64/i32_shl/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i32_shl/params.wat b/tests/disas/winch/x64/i32_shl/params.wat
index f5e91c8725e7..e645f082081a 100644
--- a/tests/disas/winch/x64/i32_shl/params.wat
+++ b/tests/disas/winch/x64/i32_shl/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32_shr_s/16_const.wat b/tests/disas/winch/x64/i32_shr_s/16_const.wat
index 5b9249c9f5fc..fd0901778096 100644
--- a/tests/disas/winch/x64/i32_shr_s/16_const.wat
+++ b/tests/disas/winch/x64/i32_shr_s/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shr_s/8_const.wat b/tests/disas/winch/x64/i32_shr_s/8_const.wat
index adc7532bcbcb..6cac959bb1b5 100644
--- a/tests/disas/winch/x64/i32_shr_s/8_const.wat
+++ b/tests/disas/winch/x64/i32_shr_s/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shr_s/locals.wat b/tests/disas/winch/x64/i32_shr_s/locals.wat
index 9b2c5066f5fd..1f42bc548316 100644
--- a/tests/disas/winch/x64/i32_shr_s/locals.wat
+++ b/tests/disas/winch/x64/i32_shr_s/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i32_shr_s/params.wat b/tests/disas/winch/x64/i32_shr_s/params.wat
index 89924f8cb8c8..7be1aa0d9ae7 100644
--- a/tests/disas/winch/x64/i32_shr_s/params.wat
+++ b/tests/disas/winch/x64/i32_shr_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32_shr_u/16_const.wat b/tests/disas/winch/x64/i32_shr_u/16_const.wat
index a29aee648f90..c4d951c97207 100644
--- a/tests/disas/winch/x64/i32_shr_u/16_const.wat
+++ b/tests/disas/winch/x64/i32_shr_u/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shr_u/8_const.wat b/tests/disas/winch/x64/i32_shr_u/8_const.wat
index 6099bd96f46b..d438ad5dfb40 100644
--- a/tests/disas/winch/x64/i32_shr_u/8_const.wat
+++ b/tests/disas/winch/x64/i32_shr_u/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i32_shr_u/locals.wat b/tests/disas/winch/x64/i32_shr_u/locals.wat
index 7db57769b0ea..7e65f346c940 100644
--- a/tests/disas/winch/x64/i32_shr_u/locals.wat
+++ b/tests/disas/winch/x64/i32_shr_u/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i32_shr_u/params.wat b/tests/disas/winch/x64/i32_shr_u/params.wat
index 0914f79bda26..c0dab1f46b7e 100644
--- a/tests/disas/winch/x64/i32_shr_u/params.wat
+++ b/tests/disas/winch/x64/i32_shr_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32_sub/const.wat b/tests/disas/winch/x64/i32_sub/const.wat
index bc6e67a2f31f..459595dad4aa 100644
--- a/tests/disas/winch/x64/i32_sub/const.wat
+++ b/tests/disas/winch/x64/i32_sub/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_sub/locals.wat b/tests/disas/winch/x64/i32_sub/locals.wat
index 563d9ddac62b..afef5226e19f 100644
--- a/tests/disas/winch/x64/i32_sub/locals.wat
+++ b/tests/disas/winch/x64/i32_sub/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/i32_sub/max.wat b/tests/disas/winch/x64/i32_sub/max.wat
index 710dfe8d0fe7..d96aa9892747 100644
--- a/tests/disas/winch/x64/i32_sub/max.wat
+++ b/tests/disas/winch/x64/i32_sub/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_sub/max_one.wat b/tests/disas/winch/x64/i32_sub/max_one.wat
index 3b3ebe610ed4..600af0303796 100644
--- a/tests/disas/winch/x64/i32_sub/max_one.wat
+++ b/tests/disas/winch/x64/i32_sub/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_sub/mixed.wat b/tests/disas/winch/x64/i32_sub/mixed.wat
index 0f8ed9e3c6e8..8e3ad239babd 100644
--- a/tests/disas/winch/x64/i32_sub/mixed.wat
+++ b/tests/disas/winch/x64/i32_sub/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_sub/params.wat b/tests/disas/winch/x64/i32_sub/params.wat
index c04824ed3dd2..9e7ebe497d92 100644
--- a/tests/disas/winch/x64/i32_sub/params.wat
+++ b/tests/disas/winch/x64/i32_sub/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32_sub/signed.wat b/tests/disas/winch/x64/i32_sub/signed.wat
index b74d55187d69..630be58c7444 100644
--- a/tests/disas/winch/x64/i32_sub/signed.wat
+++ b/tests/disas/winch/x64/i32_sub/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat
index 7eaa4ca33037..11336205c28b 100644
--- a/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/const.wat b/tests/disas/winch/x64/i32_trunc_f32_s/const.wat
index f1cec13a3070..74bacd60ef62 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_s/const.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7a
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat b/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat
index 5116f4213cd1..bbf375def244 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/params.wat b/tests/disas/winch/x64/i32_trunc_f32_s/params.wat
index 2a446a7761a1..220423fd8aeb 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_s/params.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7f
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/const.wat b/tests/disas/winch/x64/i32_trunc_f32_u/const.wat
index e8dd165f76c9..06825e5e3426 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_u/const.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat b/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat
index 9625e490b01b..0ab6bd5294f8 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8c
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/params.wat b/tests/disas/winch/x64/i32_trunc_f32_u/params.wat
index cf569b2ebff0..4d3c3907f604 100644
--- a/tests/disas/winch/x64/i32_trunc_f32_u/params.wat
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/const.wat b/tests/disas/winch/x64/i32_trunc_f64_s/const.wat
index 915cc00f72f0..c8f592d092c1 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_s/const.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x81
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat b/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat
index b5a1eff8e506..a721477670b7 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/params.wat b/tests/disas/winch/x64/i32_trunc_f64_s/params.wat
index 9ce2d0584f2d..e3d4c2066ec0 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_s/params.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x86
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/const.wat b/tests/disas/winch/x64/i32_trunc_f64_u/const.wat
index dd5ef3833de6..f30a1f9a1175 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_u/const.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x89
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat b/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat
index 2633d3133ebb..a07d8902b1e5 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x91
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/params.wat b/tests/disas/winch/x64/i32_trunc_f64_u/params.wat
index 302279a9ac99..7c08197f2a62 100644
--- a/tests/disas/winch/x64/i32_trunc_f64_u/params.wat
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8e
diff --git a/tests/disas/winch/x64/i32_wrap_i64/const.wat b/tests/disas/winch/x64/i32_wrap_i64/const.wat
index fc8bece72aa3..d5a105ed6fcc 100644
--- a/tests/disas/winch/x64/i32_wrap_i64/const.wat
+++ b/tests/disas/winch/x64/i32_wrap_i64/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3f
diff --git a/tests/disas/winch/x64/i32_wrap_i64/locals.wat b/tests/disas/winch/x64/i32_wrap_i64/locals.wat
index 81fe7dbad249..c7963fd8a940 100644
--- a/tests/disas/winch/x64/i32_wrap_i64/locals.wat
+++ b/tests/disas/winch/x64/i32_wrap_i64/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i32_wrap_i64/params.wat b/tests/disas/winch/x64/i32_wrap_i64/params.wat
index a123b5f0418c..f08caebd061a 100644
--- a/tests/disas/winch/x64/i32_wrap_i64/params.wat
+++ b/tests/disas/winch/x64/i32_wrap_i64/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32_wrap_i64/spilled.wat b/tests/disas/winch/x64/i32_wrap_i64/spilled.wat
index f1255e8c1dc9..80c42bfa527a 100644
--- a/tests/disas/winch/x64/i32_wrap_i64/spilled.wat
+++ b/tests/disas/winch/x64/i32_wrap_i64/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32_xor/const.wat b/tests/disas/winch/x64/i32_xor/const.wat
index fa2ded54e861..b3ab4469a74c 100644
--- a/tests/disas/winch/x64/i32_xor/const.wat
+++ b/tests/disas/winch/x64/i32_xor/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i32_xor/locals.wat b/tests/disas/winch/x64/i32_xor/locals.wat
index a1d41e80f929..714da0e93bc7 100644
--- a/tests/disas/winch/x64/i32_xor/locals.wat
+++ b/tests/disas/winch/x64/i32_xor/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/i32_xor/params.wat b/tests/disas/winch/x64/i32_xor/params.wat
index 6374f4ccf2eb..12b4698f2a72 100644
--- a/tests/disas/winch/x64/i32_xor/params.wat
+++ b/tests/disas/winch/x64/i32_xor/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i32x4/add/add.wat b/tests/disas/winch/x64/i32x4/add/add.wat
index a6613e9052ec..82857fb7a44e 100644
--- a/tests/disas/winch/x64/i32x4/add/add.wat
+++ b/tests/disas/winch/x64/i32x4/add/add.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4/extadd/extadd_s.wat b/tests/disas/winch/x64/i32x4/extadd/extadd_s.wat
index 69392a0ef569..f61a14b52fd5 100644
--- a/tests/disas/winch/x64/i32x4/extadd/extadd_s.wat
+++ b/tests/disas/winch/x64/i32x4/extadd/extadd_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32x4/extadd/extadd_u.wat b/tests/disas/winch/x64/i32x4/extadd/extadd_u.wat
index 31e54b337f8c..88c3418fe534 100644
--- a/tests/disas/winch/x64/i32x4/extadd/extadd_u.wat
+++ b/tests/disas/winch/x64/i32x4/extadd/extadd_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/i32x4/extmul/high_s.wat b/tests/disas/winch/x64/i32x4/extmul/high_s.wat
index fd8f93a850be..20785c7ee897 100644
--- a/tests/disas/winch/x64/i32x4/extmul/high_s.wat
+++ b/tests/disas/winch/x64/i32x4/extmul/high_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i32x4/extmul/high_u.wat b/tests/disas/winch/x64/i32x4/extmul/high_u.wat
index 93c355977bb4..a512a0fce998 100644
--- a/tests/disas/winch/x64/i32x4/extmul/high_u.wat
+++ b/tests/disas/winch/x64/i32x4/extmul/high_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6c
diff --git a/tests/disas/winch/x64/i32x4/extmul/low_s.wat b/tests/disas/winch/x64/i32x4/extmul/low_s.wat
index 036eeed5542a..6a594c993e7a 100644
--- a/tests/disas/winch/x64/i32x4/extmul/low_s.wat
+++ b/tests/disas/winch/x64/i32x4/extmul/low_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x62
diff --git a/tests/disas/winch/x64/i32x4/extmul/low_u.wat b/tests/disas/winch/x64/i32x4/extmul/low_u.wat
index 5d02346ff0ef..80c1dc39e0cd 100644
--- a/tests/disas/winch/x64/i32x4/extmul/low_u.wat
+++ b/tests/disas/winch/x64/i32x4/extmul/low_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x62
diff --git a/tests/disas/winch/x64/i32x4/extract_lane/const_avx.wat b/tests/disas/winch/x64/i32x4/extract_lane/const_avx.wat
index 3c788179ede5..63c790ad28a0 100644
--- a/tests/disas/winch/x64/i32x4/extract_lane/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4/extract_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i32x4/max/max_s.wat b/tests/disas/winch/x64/i32x4/max/max_s.wat
index 57c2c29de023..c0aa92280cca 100644
--- a/tests/disas/winch/x64/i32x4/max/max_s.wat
+++ b/tests/disas/winch/x64/i32x4/max/max_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i32x4/max/max_u.wat b/tests/disas/winch/x64/i32x4/max/max_u.wat
index 025f7408f9e5..767ea3f26adf 100644
--- a/tests/disas/winch/x64/i32x4/max/max_u.wat
+++ b/tests/disas/winch/x64/i32x4/max/max_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i32x4/min/min_s.wat b/tests/disas/winch/x64/i32x4/min/min_s.wat
index aecad808a5bd..6d7cb3bf206b 100644
--- a/tests/disas/winch/x64/i32x4/min/min_s.wat
+++ b/tests/disas/winch/x64/i32x4/min/min_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i32x4/min/min_u.wat b/tests/disas/winch/x64/i32x4/min/min_u.wat
index 248f0c4b5f68..299bcdd1de96 100644
--- a/tests/disas/winch/x64/i32x4/min/min_u.wat
+++ b/tests/disas/winch/x64/i32x4/min/min_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i32x4/mul/mul.wat b/tests/disas/winch/x64/i32x4/mul/mul.wat
index 815d7a23214d..ce3fc197b203 100644
--- a/tests/disas/winch/x64/i32x4/mul/mul.wat
+++ b/tests/disas/winch/x64/i32x4/mul/mul.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i32x4/neg/neg.wat b/tests/disas/winch/x64/i32x4/neg/neg.wat
index b5573258e860..a55a7d437c78 100644
--- a/tests/disas/winch/x64/i32x4/neg/neg.wat
+++ b/tests/disas/winch/x64/i32x4/neg/neg.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i32x4/replace_lane/const_avx.wat b/tests/disas/winch/x64/i32x4/replace_lane/const_avx.wat
index 10154e96e683..8fce893c238e 100644
--- a/tests/disas/winch/x64/i32x4/replace_lane/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4/replace_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i32x4/replace_lane/param_avx.wat b/tests/disas/winch/x64/i32x4/replace_lane/param_avx.wat
index a1a74fefae86..48be5f176228 100644
--- a/tests/disas/winch/x64/i32x4/replace_lane/param_avx.wat
+++ b/tests/disas/winch/x64/i32x4/replace_lane/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i32x4/shift/shl.wat b/tests/disas/winch/x64/i32x4/shift/shl.wat
index 19feb65cb28f..34b903f6f323 100644
--- a/tests/disas/winch/x64/i32x4/shift/shl.wat
+++ b/tests/disas/winch/x64/i32x4/shift/shl.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32x4/shift/shr_s.wat b/tests/disas/winch/x64/i32x4/shift/shr_s.wat
index 1e0781e8347f..a766f9d4f53e 100644
--- a/tests/disas/winch/x64/i32x4/shift/shr_s.wat
+++ b/tests/disas/winch/x64/i32x4/shift/shr_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32x4/shift/shr_u.wat b/tests/disas/winch/x64/i32x4/shift/shr_u.wat
index 70e96b19e414..a9bac907b109 100644
--- a/tests/disas/winch/x64/i32x4/shift/shr_u.wat
+++ b/tests/disas/winch/x64/i32x4/shift/shr_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i32x4/splat/const_avx2.wat b/tests/disas/winch/x64/i32x4/splat/const_avx2.wat
index ffa85722f999..cbf091008a94 100644
--- a/tests/disas/winch/x64/i32x4/splat/const_avx2.wat
+++ b/tests/disas/winch/x64/i32x4/splat/const_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i32x4/splat/param_avx2.wat b/tests/disas/winch/x64/i32x4/splat/param_avx2.wat
index 74f042eb1fea..b5cd032cbe14 100644
--- a/tests/disas/winch/x64/i32x4/splat/param_avx2.wat
+++ b/tests/disas/winch/x64/i32x4/splat/param_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i32x4/sub/sub.wat b/tests/disas/winch/x64/i32x4/sub/sub.wat
index e5cd5c83e165..52b164a7e425 100644
--- a/tests/disas/winch/x64/i32x4/sub/sub.wat
+++ b/tests/disas/winch/x64/i32x4/sub/sub.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4_abs/const_avx.wat b/tests/disas/winch/x64/i32x4_abs/const_avx.wat
index 6946f85f0da9..477ed068df59 100644
--- a/tests/disas/winch/x64/i32x4_abs/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32x4_all_true/const_avx.wat b/tests/disas/winch/x64/i32x4_all_true/const_avx.wat
index b053b762aa2e..bb34c5f5fb98 100644
--- a/tests/disas/winch/x64/i32x4_all_true/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_all_true/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i32x4_bitmask/const_avx.wat b/tests/disas/winch/x64/i32x4_bitmask/const_avx.wat
index ed63cb8011e6..37dcbabccc79 100644
--- a/tests/disas/winch/x64/i32x4_bitmask/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_bitmask/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i32x4_dot_i16x8_s/const_avx.wat b/tests/disas/winch/x64/i32x4_dot_i16x8_s/const_avx.wat
index e08c6d53258c..5572d84d6a64 100644
--- a/tests/disas/winch/x64/i32x4_dot_i16x8_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_dot_i16x8_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4_eq/const_avx.wat b/tests/disas/winch/x64/i32x4_eq/const_avx.wat
index dd433bd8069e..b2529ce43046 100644
--- a/tests/disas/winch/x64/i32x4_eq/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_eq/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4_extend_high_i16x8_s/const_avx.wat b/tests/disas/winch/x64/i32x4_extend_high_i16x8_s/const_avx.wat
index 35f2ea1b86c8..ffb5e4dd867b 100644
--- a/tests/disas/winch/x64/i32x4_extend_high_i16x8_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_extend_high_i16x8_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i32x4_extend_high_i16x8_u/const_avx.wat b/tests/disas/winch/x64/i32x4_extend_high_i16x8_u/const_avx.wat
index 1f3519c5e2e5..4613173152c9 100644
--- a/tests/disas/winch/x64/i32x4_extend_high_i16x8_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_extend_high_i16x8_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i32x4_extend_low_i16x8_s/const_avx.wat b/tests/disas/winch/x64/i32x4_extend_low_i16x8_s/const_avx.wat
index 1fa561cbdd3c..85f75c3bb5bb 100644
--- a/tests/disas/winch/x64/i32x4_extend_low_i16x8_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_extend_low_i16x8_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32x4_extend_low_i16x8_u/const_avx.wat b/tests/disas/winch/x64/i32x4_extend_low_i16x8_u/const_avx.wat
index 4b4584eac5a3..f211d1409333 100644
--- a/tests/disas/winch/x64/i32x4_extend_low_i16x8_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_extend_low_i16x8_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i32x4_ge_s/const_avx.wat b/tests/disas/winch/x64/i32x4_ge_s/const_avx.wat
index 714dd42f0660..111bc7790b2a 100644
--- a/tests/disas/winch/x64/i32x4_ge_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_ge_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32x4_ge_u/const_avx.wat b/tests/disas/winch/x64/i32x4_ge_u/const_avx.wat
index 43c9f49d28d7..b10e01347f00 100644
--- a/tests/disas/winch/x64/i32x4_ge_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_ge_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32x4_gt_s/const_avx.wat b/tests/disas/winch/x64/i32x4_gt_s/const_avx.wat
index 413f5640b7ab..6ee2ce418ca9 100644
--- a/tests/disas/winch/x64/i32x4_gt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_gt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4_gt_u/const_avx.wat b/tests/disas/winch/x64/i32x4_gt_u/const_avx.wat
index 9bc1b9b9c6e3..05ccfbeb07f8 100644
--- a/tests/disas/winch/x64/i32x4_gt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_gt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i32x4_le_s/const_avx.wat b/tests/disas/winch/x64/i32x4_le_s/const_avx.wat
index 8458da457e0e..927b9e02ec99 100644
--- a/tests/disas/winch/x64/i32x4_le_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_le_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32x4_le_u/const_avx.wat b/tests/disas/winch/x64/i32x4_le_u/const_avx.wat
index dedfcd60e4f0..071607b2430c 100644
--- a/tests/disas/winch/x64/i32x4_le_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_le_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i32x4_lt_s/const_avx.wat b/tests/disas/winch/x64/i32x4_lt_s/const_avx.wat
index 2c474ec414b9..19588bbbdcf2 100644
--- a/tests/disas/winch/x64/i32x4_lt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_lt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i32x4_lt_u/const_avx.wat b/tests/disas/winch/x64/i32x4_lt_u/const_avx.wat
index ab9273185433..2ff886f6393c 100644
--- a/tests/disas/winch/x64/i32x4_lt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_lt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i32x4_ne/const_avx.wat b/tests/disas/winch/x64/i32x4_ne/const_avx.wat
index f5d019664de7..5daf143b565c 100644
--- a/tests/disas/winch/x64/i32x4_ne/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_s/const_avx.wat b/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_s/const_avx.wat
index 755b0c63ff7a..a1e02ab7d872 100644
--- a/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x62
diff --git a/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_u/const_avx.wat b/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_u/const_avx.wat
index 2460918f667a..e5bc4a4a6849 100644
--- a/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_trunc_sat_f32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_s_zero/const_avx.wat b/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_s_zero/const_avx.wat
index 618987242c5e..b8e2506be8f9 100644
--- a/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_s_zero/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_s_zero/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_u_zero/const_avx.wat b/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_u_zero/const_avx.wat
index 7a807c83e5a5..e0e2a8c8820e 100644
--- a/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_u_zero/const_avx.wat
+++ b/tests/disas/winch/x64/i32x4_trunc_sat_f64x2_u_zero/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/i64_add/const.wat b/tests/disas/winch/x64/i64_add/const.wat
index 98092f62c3e7..6dff318a1cd9 100644
--- a/tests/disas/winch/x64/i64_add/const.wat
+++ b/tests/disas/winch/x64/i64_add/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_add/locals.wat b/tests/disas/winch/x64/i64_add/locals.wat
index 8895a57cd3ad..13f60d09fb23 100644
--- a/tests/disas/winch/x64/i64_add/locals.wat
+++ b/tests/disas/winch/x64/i64_add/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_add/max.wat b/tests/disas/winch/x64/i64_add/max.wat
index 28abbf769058..b7a169ee3f85 100644
--- a/tests/disas/winch/x64/i64_add/max.wat
+++ b/tests/disas/winch/x64/i64_add/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64_add/max_one.wat b/tests/disas/winch/x64/i64_add/max_one.wat
index f7e23a199a49..0fc8bd37e741 100644
--- a/tests/disas/winch/x64/i64_add/max_one.wat
+++ b/tests/disas/winch/x64/i64_add/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_add/mixed.wat b/tests/disas/winch/x64/i64_add/mixed.wat
index af74d76d8a55..3c775af845c3 100644
--- a/tests/disas/winch/x64/i64_add/mixed.wat
+++ b/tests/disas/winch/x64/i64_add/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64_add/params.wat b/tests/disas/winch/x64/i64_add/params.wat
index 6d472f062108..c2f2a977594b 100644
--- a/tests/disas/winch/x64/i64_add/params.wat
+++ b/tests/disas/winch/x64/i64_add/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_add/signed.wat b/tests/disas/winch/x64/i64_add/signed.wat
index 5a05609e2b04..682156e83619 100644
--- a/tests/disas/winch/x64/i64_add/signed.wat
+++ b/tests/disas/winch/x64/i64_add/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat
index 32ccec9900a6..d5ae0a66aa9c 100644
--- a/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_and/32_const.wat b/tests/disas/winch/x64/i64_and/32_const.wat
index e9aab85c5e61..9a4f58738990 100644
--- a/tests/disas/winch/x64/i64_and/32_const.wat
+++ b/tests/disas/winch/x64/i64_and/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_and/64_const.wat b/tests/disas/winch/x64/i64_and/64_const.wat
index 8c8ebd386b95..740db375a6c0 100644
--- a/tests/disas/winch/x64/i64_and/64_const.wat
+++ b/tests/disas/winch/x64/i64_and/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i64_and/locals.wat b/tests/disas/winch/x64/i64_and/locals.wat
index b1624a0ca596..c1d16444f787 100644
--- a/tests/disas/winch/x64/i64_and/locals.wat
+++ b/tests/disas/winch/x64/i64_and/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_and/params.wat b/tests/disas/winch/x64/i64_and/params.wat
index 869641c7cddc..c0f88465f27f 100644
--- a/tests/disas/winch/x64/i64_and/params.wat
+++ b/tests/disas/winch/x64/i64_and/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_const.wat b/tests/disas/winch/x64/i64_clz/lzcnt_const.wat
index 7862964ce9fc..10fee8b28ba7 100644
--- a/tests/disas/winch/x64/i64_clz/lzcnt_const.wat
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_local.wat b/tests/disas/winch/x64/i64_clz/lzcnt_local.wat
index 0e098d6422d7..a2111f017fc6 100644
--- a/tests/disas/winch/x64/i64_clz/lzcnt_local.wat
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_local.wat
@@ -17,7 +17,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_param.wat b/tests/disas/winch/x64/i64_clz/lzcnt_param.wat
index 776f02f68311..cbfb501d7609 100644
--- a/tests/disas/winch/x64/i64_clz/lzcnt_param.wat
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_param.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat
index d8b9bdd2c0ce..87ffe6cfc42a 100644
--- a/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat
index e7fe656f65e2..5252d6e16636 100644
--- a/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat
index 99010af90f58..bf075abdc85a 100644
--- a/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5b
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_const.wat b/tests/disas/winch/x64/i64_ctz/bmi1_const.wat
index 219347f4fe4c..181685844524 100644
--- a/tests/disas/winch/x64/i64_ctz/bmi1_const.wat
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_local.wat b/tests/disas/winch/x64/i64_ctz/bmi1_local.wat
index 34aa2344a696..c5eec098f4b7 100644
--- a/tests/disas/winch/x64/i64_ctz/bmi1_local.wat
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_local.wat
@@ -17,7 +17,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x56
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_param.wat b/tests/disas/winch/x64/i64_ctz/bmi1_param.wat
index 26ace5d9da91..c4bb32240df0 100644
--- a/tests/disas/winch/x64/i64_ctz/bmi1_param.wat
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_param.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat
index 64eb745d0460..37e55edb0477 100644
--- a/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat
index fdced990cc2d..29b62bfe93d8 100644
--- a/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5f
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat
index c49fd4b49db0..18a5f9a4d7cc 100644
--- a/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_divs/const.wat b/tests/disas/winch/x64/i64_divs/const.wat
index 4b0b92001c41..1cbe78a30f4b 100644
--- a/tests/disas/winch/x64/i64_divs/const.wat
+++ b/tests/disas/winch/x64/i64_divs/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_divs/one_zero.wat b/tests/disas/winch/x64/i64_divs/one_zero.wat
index b9d23eaadbc4..fa0cfe0d9ef3 100644
--- a/tests/disas/winch/x64/i64_divs/one_zero.wat
+++ b/tests/disas/winch/x64/i64_divs/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_divs/overflow.wat b/tests/disas/winch/x64/i64_divs/overflow.wat
index 1da600fd20c2..c0ca8d6f63fc 100644
--- a/tests/disas/winch/x64/i64_divs/overflow.wat
+++ b/tests/disas/winch/x64/i64_divs/overflow.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_divs/params.wat b/tests/disas/winch/x64/i64_divs/params.wat
index 6b005f79b807..2bd7d39fe4fc 100644
--- a/tests/disas/winch/x64/i64_divs/params.wat
+++ b/tests/disas/winch/x64/i64_divs/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i64_divs/zero_zero.wat b/tests/disas/winch/x64/i64_divs/zero_zero.wat
index 85f27cc42b1e..2cf370a83e3f 100644
--- a/tests/disas/winch/x64/i64_divs/zero_zero.wat
+++ b/tests/disas/winch/x64/i64_divs/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_divu/const.wat b/tests/disas/winch/x64/i64_divu/const.wat
index 0b07cc57182a..5c62bf846252 100644
--- a/tests/disas/winch/x64/i64_divu/const.wat
+++ b/tests/disas/winch/x64/i64_divu/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_divu/one_zero.wat b/tests/disas/winch/x64/i64_divu/one_zero.wat
index 95e41a496bf7..00f6c1661f39 100644
--- a/tests/disas/winch/x64/i64_divu/one_zero.wat
+++ b/tests/disas/winch/x64/i64_divu/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_divu/params.wat b/tests/disas/winch/x64/i64_divu/params.wat
index 01d234ca1a76..011e71781e59 100644
--- a/tests/disas/winch/x64/i64_divu/params.wat
+++ b/tests/disas/winch/x64/i64_divu/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_divu/signed.wat b/tests/disas/winch/x64/i64_divu/signed.wat
index 07549fe6999f..5703b85611a4 100644
--- a/tests/disas/winch/x64/i64_divu/signed.wat
+++ b/tests/disas/winch/x64/i64_divu/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4c
diff --git a/tests/disas/winch/x64/i64_divu/zero_zero.wat b/tests/disas/winch/x64/i64_divu/zero_zero.wat
index 8aa9560ba7b2..2d1f6613ef64 100644
--- a/tests/disas/winch/x64/i64_divu/zero_zero.wat
+++ b/tests/disas/winch/x64/i64_divu/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_eq/32_const.wat b/tests/disas/winch/x64/i64_eq/32_const.wat
index d37416c8c1de..73b2215845d7 100644
--- a/tests/disas/winch/x64/i64_eq/32_const.wat
+++ b/tests/disas/winch/x64/i64_eq/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_eq/64_const.wat b/tests/disas/winch/x64/i64_eq/64_const.wat
index 96f82e4eea50..2a9760c30089 100644
--- a/tests/disas/winch/x64/i64_eq/64_const.wat
+++ b/tests/disas/winch/x64/i64_eq/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_eq/locals.wat b/tests/disas/winch/x64/i64_eq/locals.wat
index c45e457da7e9..3d5641784dbe 100644
--- a/tests/disas/winch/x64/i64_eq/locals.wat
+++ b/tests/disas/winch/x64/i64_eq/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_eq/params.wat b/tests/disas/winch/x64/i64_eq/params.wat
index 5d610803facb..165fe2a01970 100644
--- a/tests/disas/winch/x64/i64_eq/params.wat
+++ b/tests/disas/winch/x64/i64_eq/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_eqz/32_const.wat b/tests/disas/winch/x64/i64_eqz/32_const.wat
index 41d200c8dc23..e7aff042fc08 100644
--- a/tests/disas/winch/x64/i64_eqz/32_const.wat
+++ b/tests/disas/winch/x64/i64_eqz/32_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_eqz/64_const.wat b/tests/disas/winch/x64/i64_eqz/64_const.wat
index 651c9330d8a6..a591a9fb96b6 100644
--- a/tests/disas/winch/x64/i64_eqz/64_const.wat
+++ b/tests/disas/winch/x64/i64_eqz/64_const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_eqz/local.wat b/tests/disas/winch/x64/i64_eqz/local.wat
index 2d463af6d5db..3fb295c17b96 100644
--- a/tests/disas/winch/x64/i64_eqz/local.wat
+++ b/tests/disas/winch/x64/i64_eqz/local.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i64_eqz/param.wat b/tests/disas/winch/x64/i64_eqz/param.wat
index 5b978a64f0e1..8453922c6204 100644
--- a/tests/disas/winch/x64/i64_eqz/param.wat
+++ b/tests/disas/winch/x64/i64_eqz/param.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i64_eqz/spilled.wat b/tests/disas/winch/x64/i64_eqz/spilled.wat
index c65ef713f358..a7cfd69bc929 100644
--- a/tests/disas/winch/x64/i64_eqz/spilled.wat
+++ b/tests/disas/winch/x64/i64_eqz/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x14, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5d
diff --git a/tests/disas/winch/x64/i64_extend_16_s/const.wat b/tests/disas/winch/x64/i64_extend_16_s/const.wat
index 0395a494db73..a057cf3a602b 100644
--- a/tests/disas/winch/x64/i64_extend_16_s/const.wat
+++ b/tests/disas/winch/x64/i64_extend_16_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_extend_16_s/locals.wat b/tests/disas/winch/x64/i64_extend_16_s/locals.wat
index c3754174b989..454130bc253f 100644
--- a/tests/disas/winch/x64/i64_extend_16_s/locals.wat
+++ b/tests/disas/winch/x64/i64_extend_16_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_extend_16_s/params.wat b/tests/disas/winch/x64/i64_extend_16_s/params.wat
index 80fe2548e55d..d877cbcba859 100644
--- a/tests/disas/winch/x64/i64_extend_16_s/params.wat
+++ b/tests/disas/winch/x64/i64_extend_16_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x47
diff --git a/tests/disas/winch/x64/i64_extend_32_s/const.wat b/tests/disas/winch/x64/i64_extend_32_s/const.wat
index a2224930c754..b1adcf28bdc1 100644
--- a/tests/disas/winch/x64/i64_extend_32_s/const.wat
+++ b/tests/disas/winch/x64/i64_extend_32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i64_extend_32_s/locals.wat b/tests/disas/winch/x64/i64_extend_32_s/locals.wat
index 51c3d1227ea6..3421c6dfaafb 100644
--- a/tests/disas/winch/x64/i64_extend_32_s/locals.wat
+++ b/tests/disas/winch/x64/i64_extend_32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64_extend_32_s/params.wat b/tests/disas/winch/x64/i64_extend_32_s/params.wat
index 3e942fffeb3d..956d0b1299f1 100644
--- a/tests/disas/winch/x64/i64_extend_32_s/params.wat
+++ b/tests/disas/winch/x64/i64_extend_32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i64_extend_8_s/const.wat b/tests/disas/winch/x64/i64_extend_8_s/const.wat
index cc5183dfef1e..beb181aac300 100644
--- a/tests/disas/winch/x64/i64_extend_8_s/const.wat
+++ b/tests/disas/winch/x64/i64_extend_8_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_extend_8_s/locals.wat b/tests/disas/winch/x64/i64_extend_8_s/locals.wat
index 383bb10fa08c..36b8965b21f1 100644
--- a/tests/disas/winch/x64/i64_extend_8_s/locals.wat
+++ b/tests/disas/winch/x64/i64_extend_8_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_extend_8_s/params.wat b/tests/disas/winch/x64/i64_extend_8_s/params.wat
index 59c49e649e3f..2c02a39b3c61 100644
--- a/tests/disas/winch/x64/i64_extend_8_s/params.wat
+++ b/tests/disas/winch/x64/i64_extend_8_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x47
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/const.wat b/tests/disas/winch/x64/i64_extend_i32_s/const.wat
index 270cd74a18c3..e500f4104db3 100644
--- a/tests/disas/winch/x64/i64_extend_i32_s/const.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x40
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/locals.wat b/tests/disas/winch/x64/i64_extend_i32_s/locals.wat
index 65694d020edf..958b63a72294 100644
--- a/tests/disas/winch/x64/i64_extend_i32_s/locals.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/params.wat b/tests/disas/winch/x64/i64_extend_i32_s/params.wat
index 82df12142bb0..c98d47272894 100644
--- a/tests/disas/winch/x64/i64_extend_i32_s/params.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat b/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat
index 95a105684759..02a17cf88d6f 100644
--- a/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/const.wat b/tests/disas/winch/x64/i64_extend_i32_u/const.wat
index 2c5547b96c4e..9813a5b560ae 100644
--- a/tests/disas/winch/x64/i64_extend_i32_u/const.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3f
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/locals.wat b/tests/disas/winch/x64/i64_extend_i32_u/locals.wat
index 00a7dd0b7607..204abbdf41c9 100644
--- a/tests/disas/winch/x64/i64_extend_i32_u/locals.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/params.wat b/tests/disas/winch/x64/i64_extend_i32_u/params.wat
index 6bf35f24ff5d..2588c233d603 100644
--- a/tests/disas/winch/x64/i64_extend_i32_u/params.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat b/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat
index 0a7280419f56..489053739265 100644
--- a/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat
+++ b/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x18, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_ge_s/32_const.wat b/tests/disas/winch/x64/i64_ge_s/32_const.wat
index ef348943119c..79516c4bd064 100644
--- a/tests/disas/winch/x64/i64_ge_s/32_const.wat
+++ b/tests/disas/winch/x64/i64_ge_s/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_ge_s/64_const.wat b/tests/disas/winch/x64/i64_ge_s/64_const.wat
index fbdb695a7a62..e75ef11c1af3 100644
--- a/tests/disas/winch/x64/i64_ge_s/64_const.wat
+++ b/tests/disas/winch/x64/i64_ge_s/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_ge_s/locals.wat b/tests/disas/winch/x64/i64_ge_s/locals.wat
index a58caa8abb39..ff7368ec6c87 100644
--- a/tests/disas/winch/x64/i64_ge_s/locals.wat
+++ b/tests/disas/winch/x64/i64_ge_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_ge_s/params.wat b/tests/disas/winch/x64/i64_ge_s/params.wat
index 9b885c00c464..a9180e46c997 100644
--- a/tests/disas/winch/x64/i64_ge_s/params.wat
+++ b/tests/disas/winch/x64/i64_ge_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_ge_u/32_const.wat b/tests/disas/winch/x64/i64_ge_u/32_const.wat
index 2c6320cd3ba4..93b028f144ec 100644
--- a/tests/disas/winch/x64/i64_ge_u/32_const.wat
+++ b/tests/disas/winch/x64/i64_ge_u/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_ge_u/64_const.wat b/tests/disas/winch/x64/i64_ge_u/64_const.wat
index a121defe6097..12e67e66d4ab 100644
--- a/tests/disas/winch/x64/i64_ge_u/64_const.wat
+++ b/tests/disas/winch/x64/i64_ge_u/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_ge_u/locals.wat b/tests/disas/winch/x64/i64_ge_u/locals.wat
index 3b99c5212e99..08cb33eb953f 100644
--- a/tests/disas/winch/x64/i64_ge_u/locals.wat
+++ b/tests/disas/winch/x64/i64_ge_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_ge_u/params.wat b/tests/disas/winch/x64/i64_ge_u/params.wat
index 1ff3f93fba69..92d797f9287c 100644
--- a/tests/disas/winch/x64/i64_ge_u/params.wat
+++ b/tests/disas/winch/x64/i64_ge_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_gt_s/32_const.wat b/tests/disas/winch/x64/i64_gt_s/32_const.wat
index 58a20a35aed3..7c390209621b 100644
--- a/tests/disas/winch/x64/i64_gt_s/32_const.wat
+++ b/tests/disas/winch/x64/i64_gt_s/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_gt_s/64_const.wat b/tests/disas/winch/x64/i64_gt_s/64_const.wat
index 01e380a1850f..e7612e3fd98c 100644
--- a/tests/disas/winch/x64/i64_gt_s/64_const.wat
+++ b/tests/disas/winch/x64/i64_gt_s/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_gt_s/locals.wat b/tests/disas/winch/x64/i64_gt_s/locals.wat
index a5a52c89cb75..c26af4781d66 100644
--- a/tests/disas/winch/x64/i64_gt_s/locals.wat
+++ b/tests/disas/winch/x64/i64_gt_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_gt_s/params.wat b/tests/disas/winch/x64/i64_gt_s/params.wat
index 42557f810bc1..4a5fa0b17ae9 100644
--- a/tests/disas/winch/x64/i64_gt_s/params.wat
+++ b/tests/disas/winch/x64/i64_gt_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_gt_u/32_const.wat b/tests/disas/winch/x64/i64_gt_u/32_const.wat
index 43fb29541b62..063e9e71a987 100644
--- a/tests/disas/winch/x64/i64_gt_u/32_const.wat
+++ b/tests/disas/winch/x64/i64_gt_u/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_gt_u/64_const.wat b/tests/disas/winch/x64/i64_gt_u/64_const.wat
index 70592a4b7f74..496670d0bde6 100644
--- a/tests/disas/winch/x64/i64_gt_u/64_const.wat
+++ b/tests/disas/winch/x64/i64_gt_u/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_gt_u/locals.wat b/tests/disas/winch/x64/i64_gt_u/locals.wat
index e80d1b42c98e..41e3c3b034ab 100644
--- a/tests/disas/winch/x64/i64_gt_u/locals.wat
+++ b/tests/disas/winch/x64/i64_gt_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_gt_u/params.wat b/tests/disas/winch/x64/i64_gt_u/params.wat
index 3fab63b49f9c..20259732db79 100644
--- a/tests/disas/winch/x64/i64_gt_u/params.wat
+++ b/tests/disas/winch/x64/i64_gt_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_le_s/32_const.wat b/tests/disas/winch/x64/i64_le_s/32_const.wat
index 98d10504f617..89aad8b973fa 100644
--- a/tests/disas/winch/x64/i64_le_s/32_const.wat
+++ b/tests/disas/winch/x64/i64_le_s/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_le_s/64_const.wat b/tests/disas/winch/x64/i64_le_s/64_const.wat
index 2fc4cb3c3821..c1a09d71d4db 100644
--- a/tests/disas/winch/x64/i64_le_s/64_const.wat
+++ b/tests/disas/winch/x64/i64_le_s/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_le_s/locals.wat b/tests/disas/winch/x64/i64_le_s/locals.wat
index cde03b7aa8dd..4c9b0e5e5ec6 100644
--- a/tests/disas/winch/x64/i64_le_s/locals.wat
+++ b/tests/disas/winch/x64/i64_le_s/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_le_s/params.wat b/tests/disas/winch/x64/i64_le_s/params.wat
index 44cbe8664e68..cc5903a78aa8 100644
--- a/tests/disas/winch/x64/i64_le_s/params.wat
+++ b/tests/disas/winch/x64/i64_le_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_le_u/32_const.wat b/tests/disas/winch/x64/i64_le_u/32_const.wat
index 1b610b485f01..49c80e89c4e6 100644
--- a/tests/disas/winch/x64/i64_le_u/32_const.wat
+++ b/tests/disas/winch/x64/i64_le_u/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_le_u/64_const.wat b/tests/disas/winch/x64/i64_le_u/64_const.wat
index b8b24f5ef4ce..64622dbe7b8d 100644
--- a/tests/disas/winch/x64/i64_le_u/64_const.wat
+++ b/tests/disas/winch/x64/i64_le_u/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_le_u/locals.wat b/tests/disas/winch/x64/i64_le_u/locals.wat
index 743799ab06ba..9a1ccd6259f4 100644
--- a/tests/disas/winch/x64/i64_le_u/locals.wat
+++ b/tests/disas/winch/x64/i64_le_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_le_u/params.wat b/tests/disas/winch/x64/i64_le_u/params.wat
index 2d2ac085b846..761e8b09cd46 100644
--- a/tests/disas/winch/x64/i64_le_u/params.wat
+++ b/tests/disas/winch/x64/i64_le_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_lt_s/32_const.wat b/tests/disas/winch/x64/i64_lt_s/32_const.wat
index a1cd3f122eee..dad5f3812a54 100644
--- a/tests/disas/winch/x64/i64_lt_s/32_const.wat
+++ b/tests/disas/winch/x64/i64_lt_s/32_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_lt_s/64_const.wat b/tests/disas/winch/x64/i64_lt_s/64_const.wat
index 6060c37c0833..e34264fb1cc5 100644
--- a/tests/disas/winch/x64/i64_lt_s/64_const.wat
+++ b/tests/disas/winch/x64/i64_lt_s/64_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_lt_s/locals.wat b/tests/disas/winch/x64/i64_lt_s/locals.wat
index 086ad452c688..e3a5de352104 100644
--- a/tests/disas/winch/x64/i64_lt_s/locals.wat
+++ b/tests/disas/winch/x64/i64_lt_s/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_lt_s/params.wat b/tests/disas/winch/x64/i64_lt_s/params.wat
index f8a6158e3ca2..f314e7d7c3d0 100644
--- a/tests/disas/winch/x64/i64_lt_s/params.wat
+++ b/tests/disas/winch/x64/i64_lt_s/params.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_lt_u/32_const.wat b/tests/disas/winch/x64/i64_lt_u/32_const.wat
index c33b531fc83e..10ff8d7eeed0 100644
--- a/tests/disas/winch/x64/i64_lt_u/32_const.wat
+++ b/tests/disas/winch/x64/i64_lt_u/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_lt_u/64_const.wat b/tests/disas/winch/x64/i64_lt_u/64_const.wat
index 3ef1fe0e8657..b81e35f38c2b 100644
--- a/tests/disas/winch/x64/i64_lt_u/64_const.wat
+++ b/tests/disas/winch/x64/i64_lt_u/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_lt_u/locals.wat b/tests/disas/winch/x64/i64_lt_u/locals.wat
index aacf4f4ca2a2..fef259ef2494 100644
--- a/tests/disas/winch/x64/i64_lt_u/locals.wat
+++ b/tests/disas/winch/x64/i64_lt_u/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_lt_u/params.wat b/tests/disas/winch/x64/i64_lt_u/params.wat
index 33e4c2de80bf..3491fb1ac7fe 100644
--- a/tests/disas/winch/x64/i64_lt_u/params.wat
+++ b/tests/disas/winch/x64/i64_lt_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_mul/const.wat b/tests/disas/winch/x64/i64_mul/const.wat
index c95fe6395fb6..4f4ca4dca39d 100644
--- a/tests/disas/winch/x64/i64_mul/const.wat
+++ b/tests/disas/winch/x64/i64_mul/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i64_mul/locals.wat b/tests/disas/winch/x64/i64_mul/locals.wat
index 17924cceabd2..cfcfade25387 100644
--- a/tests/disas/winch/x64/i64_mul/locals.wat
+++ b/tests/disas/winch/x64/i64_mul/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i64_mul/max.wat b/tests/disas/winch/x64/i64_mul/max.wat
index cb74c554eaea..f2b1c8d818f5 100644
--- a/tests/disas/winch/x64/i64_mul/max.wat
+++ b/tests/disas/winch/x64/i64_mul/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_mul/max_one.wat b/tests/disas/winch/x64/i64_mul/max_one.wat
index 34ac62aaf9b5..8bcf397197f7 100644
--- a/tests/disas/winch/x64/i64_mul/max_one.wat
+++ b/tests/disas/winch/x64/i64_mul/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_mul/mixed.wat b/tests/disas/winch/x64/i64_mul/mixed.wat
index 96e307bf833a..9b90ec0c3957 100644
--- a/tests/disas/winch/x64/i64_mul/mixed.wat
+++ b/tests/disas/winch/x64/i64_mul/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i64_mul/params.wat b/tests/disas/winch/x64/i64_mul/params.wat
index bd8a8ea2946b..82e312c7f163 100644
--- a/tests/disas/winch/x64/i64_mul/params.wat
+++ b/tests/disas/winch/x64/i64_mul/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x52
diff --git a/tests/disas/winch/x64/i64_mul/signed.wat b/tests/disas/winch/x64/i64_mul/signed.wat
index 9828bc44b79c..ef6ae70f051c 100644
--- a/tests/disas/winch/x64/i64_mul/signed.wat
+++ b/tests/disas/winch/x64/i64_mul/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat
index 4d6996823894..338ccb4ca500 100644
--- a/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i64_ne/32_const.wat b/tests/disas/winch/x64/i64_ne/32_const.wat
index 041ed83ad04c..37c82bb400b6 100644
--- a/tests/disas/winch/x64/i64_ne/32_const.wat
+++ b/tests/disas/winch/x64/i64_ne/32_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64_ne/64_const.wat b/tests/disas/winch/x64/i64_ne/64_const.wat
index f789945a6f53..989d7e031a1e 100644
--- a/tests/disas/winch/x64/i64_ne/64_const.wat
+++ b/tests/disas/winch/x64/i64_ne/64_const.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64_ne/locals.wat b/tests/disas/winch/x64/i64_ne/locals.wat
index 6b6c424937e4..cd1da14d4030 100644
--- a/tests/disas/winch/x64/i64_ne/locals.wat
+++ b/tests/disas/winch/x64/i64_ne/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6e
diff --git a/tests/disas/winch/x64/i64_ne/params.wat b/tests/disas/winch/x64/i64_ne/params.wat
index 36d6607599b3..8a2e92089f08 100644
--- a/tests/disas/winch/x64/i64_ne/params.wat
+++ b/tests/disas/winch/x64/i64_ne/params.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i64_or/32_const.wat b/tests/disas/winch/x64/i64_or/32_const.wat
index bd87367444d6..75a460fa6668 100644
--- a/tests/disas/winch/x64/i64_or/32_const.wat
+++ b/tests/disas/winch/x64/i64_or/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_or/64_const.wat b/tests/disas/winch/x64/i64_or/64_const.wat
index 395d52d4523b..1463cdfcf9ce 100644
--- a/tests/disas/winch/x64/i64_or/64_const.wat
+++ b/tests/disas/winch/x64/i64_or/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i64_or/locals.wat b/tests/disas/winch/x64/i64_or/locals.wat
index a1977bb5aeb9..4b42c4404f57 100644
--- a/tests/disas/winch/x64/i64_or/locals.wat
+++ b/tests/disas/winch/x64/i64_or/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_or/params.wat b/tests/disas/winch/x64/i64_or/params.wat
index ca5a2f6e39b0..a832bf076d35 100644
--- a/tests/disas/winch/x64/i64_or/params.wat
+++ b/tests/disas/winch/x64/i64_or/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_popcnt/const.wat b/tests/disas/winch/x64/i64_popcnt/const.wat
index 5f23f9ebe3a1..af7b031be6c5 100644
--- a/tests/disas/winch/x64/i64_popcnt/const.wat
+++ b/tests/disas/winch/x64/i64_popcnt/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x42
diff --git a/tests/disas/winch/x64/i64_popcnt/fallback.wat b/tests/disas/winch/x64/i64_popcnt/fallback.wat
index 62f52f55f988..2ff532cf2215 100644
--- a/tests/disas/winch/x64/i64_popcnt/fallback.wat
+++ b/tests/disas/winch/x64/i64_popcnt/fallback.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x97
diff --git a/tests/disas/winch/x64/i64_popcnt/no_sse42.wat b/tests/disas/winch/x64/i64_popcnt/no_sse42.wat
index 6b728ab08d25..3a09e97dd93d 100644
--- a/tests/disas/winch/x64/i64_popcnt/no_sse42.wat
+++ b/tests/disas/winch/x64/i64_popcnt/no_sse42.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x97
diff --git a/tests/disas/winch/x64/i64_popcnt/reg.wat b/tests/disas/winch/x64/i64_popcnt/reg.wat
index 9b588ae42c38..849a9a82be84 100644
--- a/tests/disas/winch/x64/i64_popcnt/reg.wat
+++ b/tests/disas/winch/x64/i64_popcnt/reg.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/const.wat b/tests/disas/winch/x64/i64_reinterpret_f64/const.wat
index b413f2c23bb1..8c7a79cf2be6 100644
--- a/tests/disas/winch/x64/i64_reinterpret_f64/const.wat
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat b/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat
index 5aa995737a77..6f19e9f0bb21 100644
--- a/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/params.wat b/tests/disas/winch/x64/i64_reinterpret_f64/params.wat
index 12cfb91c92f7..d1871ea0789a 100644
--- a/tests/disas/winch/x64/i64_reinterpret_f64/params.wat
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat b/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat
index e3984b073477..d04dafa76879 100644
--- a/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i64_rems/const.wat b/tests/disas/winch/x64/i64_rems/const.wat
index 6de324f87f87..03d65db42e13 100644
--- a/tests/disas/winch/x64/i64_rems/const.wat
+++ b/tests/disas/winch/x64/i64_rems/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i64_rems/one_zero.wat b/tests/disas/winch/x64/i64_rems/one_zero.wat
index 0844eaafd623..66dde10e8ddd 100644
--- a/tests/disas/winch/x64/i64_rems/one_zero.wat
+++ b/tests/disas/winch/x64/i64_rems/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i64_rems/overflow.wat b/tests/disas/winch/x64/i64_rems/overflow.wat
index 22eec60ed513..46163d5ffe0a 100644
--- a/tests/disas/winch/x64/i64_rems/overflow.wat
+++ b/tests/disas/winch/x64/i64_rems/overflow.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/i64_rems/params.wat b/tests/disas/winch/x64/i64_rems/params.wat
index ff05c0cc9b8c..b3647014c4c7 100644
--- a/tests/disas/winch/x64/i64_rems/params.wat
+++ b/tests/disas/winch/x64/i64_rems/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_rems/zero_zero.wat b/tests/disas/winch/x64/i64_rems/zero_zero.wat
index 16ccfa1c937d..de4ab3b857bd 100644
--- a/tests/disas/winch/x64/i64_rems/zero_zero.wat
+++ b/tests/disas/winch/x64/i64_rems/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5e
diff --git a/tests/disas/winch/x64/i64_remu/const.wat b/tests/disas/winch/x64/i64_remu/const.wat
index 67a9e210caa3..2f4522227752 100644
--- a/tests/disas/winch/x64/i64_remu/const.wat
+++ b/tests/disas/winch/x64/i64_remu/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_remu/one_zero.wat b/tests/disas/winch/x64/i64_remu/one_zero.wat
index 785c0c51746b..55c61a13ebf7 100644
--- a/tests/disas/winch/x64/i64_remu/one_zero.wat
+++ b/tests/disas/winch/x64/i64_remu/one_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_remu/params.wat b/tests/disas/winch/x64/i64_remu/params.wat
index f36d3c961cac..b3681ac1bd56 100644
--- a/tests/disas/winch/x64/i64_remu/params.wat
+++ b/tests/disas/winch/x64/i64_remu/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/i64_remu/signed.wat b/tests/disas/winch/x64/i64_remu/signed.wat
index 687f57d5c12d..e14f5cd27c11 100644
--- a/tests/disas/winch/x64/i64_remu/signed.wat
+++ b/tests/disas/winch/x64/i64_remu/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i64_remu/zero_zero.wat b/tests/disas/winch/x64/i64_remu/zero_zero.wat
index eab91679edb5..4496c19052ae 100644
--- a/tests/disas/winch/x64/i64_remu/zero_zero.wat
+++ b/tests/disas/winch/x64/i64_remu/zero_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/i64_rotl/16_const.wat b/tests/disas/winch/x64/i64_rotl/16_const.wat
index 048e818a1822..8a9e6835fcb8 100644
--- a/tests/disas/winch/x64/i64_rotl/16_const.wat
+++ b/tests/disas/winch/x64/i64_rotl/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_rotl/8_const.wat b/tests/disas/winch/x64/i64_rotl/8_const.wat
index ab273ea66024..4fba528137c4 100644
--- a/tests/disas/winch/x64/i64_rotl/8_const.wat
+++ b/tests/disas/winch/x64/i64_rotl/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_rotl/locals.wat b/tests/disas/winch/x64/i64_rotl/locals.wat
index 2fa1e1b1f002..72d44bc45d3a 100644
--- a/tests/disas/winch/x64/i64_rotl/locals.wat
+++ b/tests/disas/winch/x64/i64_rotl/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/i64_rotl/params.wat b/tests/disas/winch/x64/i64_rotl/params.wat
index 297410732d54..84d0578845ea 100644
--- a/tests/disas/winch/x64/i64_rotl/params.wat
+++ b/tests/disas/winch/x64/i64_rotl/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_rotr/16_const.wat b/tests/disas/winch/x64/i64_rotr/16_const.wat
index 74206ba7ca16..5f94ef646dbd 100644
--- a/tests/disas/winch/x64/i64_rotr/16_const.wat
+++ b/tests/disas/winch/x64/i64_rotr/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_rotr/8_const.wat b/tests/disas/winch/x64/i64_rotr/8_const.wat
index 5fdcb0f84aab..a73d2e59b451 100644
--- a/tests/disas/winch/x64/i64_rotr/8_const.wat
+++ b/tests/disas/winch/x64/i64_rotr/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_rotr/locals.wat b/tests/disas/winch/x64/i64_rotr/locals.wat
index 20198c7fd003..da3342d7ce77 100644
--- a/tests/disas/winch/x64/i64_rotr/locals.wat
+++ b/tests/disas/winch/x64/i64_rotr/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/i64_rotr/params.wat b/tests/disas/winch/x64/i64_rotr/params.wat
index 807a107e1b6a..9345744d0864 100644
--- a/tests/disas/winch/x64/i64_rotr/params.wat
+++ b/tests/disas/winch/x64/i64_rotr/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_shl/16_const.wat b/tests/disas/winch/x64/i64_shl/16_const.wat
index f63abc23b1aa..0760b085b7da 100644
--- a/tests/disas/winch/x64/i64_shl/16_const.wat
+++ b/tests/disas/winch/x64/i64_shl/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shl/8_const.wat b/tests/disas/winch/x64/i64_shl/8_const.wat
index 529ae5d6d9c8..9a9ca2011776 100644
--- a/tests/disas/winch/x64/i64_shl/8_const.wat
+++ b/tests/disas/winch/x64/i64_shl/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shl/locals.wat b/tests/disas/winch/x64/i64_shl/locals.wat
index 6cc85ce6fd52..b870aa975f01 100644
--- a/tests/disas/winch/x64/i64_shl/locals.wat
+++ b/tests/disas/winch/x64/i64_shl/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/i64_shl/params.wat b/tests/disas/winch/x64/i64_shl/params.wat
index d3a5daa21d2e..87384636e887 100644
--- a/tests/disas/winch/x64/i64_shl/params.wat
+++ b/tests/disas/winch/x64/i64_shl/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_shr_s/16_const.wat b/tests/disas/winch/x64/i64_shr_s/16_const.wat
index 8f1471a14511..5b07935d538d 100644
--- a/tests/disas/winch/x64/i64_shr_s/16_const.wat
+++ b/tests/disas/winch/x64/i64_shr_s/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shr_s/8_const.wat b/tests/disas/winch/x64/i64_shr_s/8_const.wat
index 691677552f4f..0b1f8e863352 100644
--- a/tests/disas/winch/x64/i64_shr_s/8_const.wat
+++ b/tests/disas/winch/x64/i64_shr_s/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shr_s/locals.wat b/tests/disas/winch/x64/i64_shr_s/locals.wat
index fe1951c2377f..bc6659ff0a73 100644
--- a/tests/disas/winch/x64/i64_shr_s/locals.wat
+++ b/tests/disas/winch/x64/i64_shr_s/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/i64_shr_s/params.wat b/tests/disas/winch/x64/i64_shr_s/params.wat
index 5d48228720dd..6ca7bab3bcc7 100644
--- a/tests/disas/winch/x64/i64_shr_s/params.wat
+++ b/tests/disas/winch/x64/i64_shr_s/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_shr_u/16_const.wat b/tests/disas/winch/x64/i64_shr_u/16_const.wat
index afc7602b847f..3f1462a080ac 100644
--- a/tests/disas/winch/x64/i64_shr_u/16_const.wat
+++ b/tests/disas/winch/x64/i64_shr_u/16_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shr_u/8_const.wat b/tests/disas/winch/x64/i64_shr_u/8_const.wat
index bb04a4b2c270..b9bb5d89c4d9 100644
--- a/tests/disas/winch/x64/i64_shr_u/8_const.wat
+++ b/tests/disas/winch/x64/i64_shr_u/8_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64_shr_u/locals.wat b/tests/disas/winch/x64/i64_shr_u/locals.wat
index 04547ee62004..e6a028debbc1 100644
--- a/tests/disas/winch/x64/i64_shr_u/locals.wat
+++ b/tests/disas/winch/x64/i64_shr_u/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x64
diff --git a/tests/disas/winch/x64/i64_shr_u/params.wat b/tests/disas/winch/x64/i64_shr_u/params.wat
index 914fb19498e3..b37c8481ad65 100644
--- a/tests/disas/winch/x64/i64_shr_u/params.wat
+++ b/tests/disas/winch/x64/i64_shr_u/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64_sub/const.wat b/tests/disas/winch/x64/i64_sub/const.wat
index e98556642fd5..c0533bda80ec 100644
--- a/tests/disas/winch/x64/i64_sub/const.wat
+++ b/tests/disas/winch/x64/i64_sub/const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_sub/locals.wat b/tests/disas/winch/x64/i64_sub/locals.wat
index bae58f1cc0d1..540caae1881b 100644
--- a/tests/disas/winch/x64/i64_sub/locals.wat
+++ b/tests/disas/winch/x64/i64_sub/locals.wat
@@ -21,7 +21,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_sub/max.wat b/tests/disas/winch/x64/i64_sub/max.wat
index e9fb9ecc61ce..027923a621e4 100644
--- a/tests/disas/winch/x64/i64_sub/max.wat
+++ b/tests/disas/winch/x64/i64_sub/max.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_sub/max_one.wat b/tests/disas/winch/x64/i64_sub/max_one.wat
index 07ff8b53ccbd..d0db6e8c745a 100644
--- a/tests/disas/winch/x64/i64_sub/max_one.wat
+++ b/tests/disas/winch/x64/i64_sub/max_one.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/i64_sub/mixed.wat b/tests/disas/winch/x64/i64_sub/mixed.wat
index 48ff37666a92..217904450aea 100644
--- a/tests/disas/winch/x64/i64_sub/mixed.wat
+++ b/tests/disas/winch/x64/i64_sub/mixed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64_sub/params.wat b/tests/disas/winch/x64/i64_sub/params.wat
index 216b18556c8e..d44d20c82e62 100644
--- a/tests/disas/winch/x64/i64_sub/params.wat
+++ b/tests/disas/winch/x64/i64_sub/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64_sub/signed.wat b/tests/disas/winch/x64/i64_sub/signed.wat
index 0fb4d459ffaa..4ed3da68f7e7 100644
--- a/tests/disas/winch/x64/i64_sub/signed.wat
+++ b/tests/disas/winch/x64/i64_sub/signed.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat
index f52fefcf2d9d..d8835693f992 100644
--- a/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat
+++ b/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/const.wat b/tests/disas/winch/x64/i64_trunc_f32_s/const.wat
index e1bcccba3ba7..c76d31c94a23 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_s/const.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7c
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat b/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat
index b695bafc68ad..61b9f3763d9b 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x84
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/params.wat b/tests/disas/winch/x64/i64_trunc_f32_s/params.wat
index 2ee810c5f30d..1039749a65e2 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_s/params.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x81
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/const.wat b/tests/disas/winch/x64/i64_trunc_f32_u/const.wat
index c9c5c416b319..425f6fc1e285 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_u/const.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x90
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat b/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat
index 3a1edf2502d3..bacc7db4813a 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x98
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/params.wat b/tests/disas/winch/x64/i64_trunc_f32_u/params.wat
index 65a2d29a2fea..374df11d8565 100644
--- a/tests/disas/winch/x64/i64_trunc_f32_u/params.wat
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/const.wat b/tests/disas/winch/x64/i64_trunc_f64_s/const.wat
index 931d56f31a81..c36753e46f9a 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_s/const.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x83
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat b/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat
index 152240d61b9a..ee7b42414c56 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8b
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/params.wat b/tests/disas/winch/x64/i64_trunc_f64_s/params.wat
index 1f02fb59bca8..cf2d229ebc1d 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_s/params.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/const.wat b/tests/disas/winch/x64/i64_trunc_f64_u/const.wat
index fd8fd17de5a0..4875c03bced1 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_u/const.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat b/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat
index f924bbdc017d..0d27289f5b42 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9d
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/params.wat b/tests/disas/winch/x64/i64_trunc_f64_u/params.wat
index 03c4c2f91b01..4b8c8ee6852f 100644
--- a/tests/disas/winch/x64/i64_trunc_f64_u/params.wat
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/params.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9a
diff --git a/tests/disas/winch/x64/i64_xor/32_const.wat b/tests/disas/winch/x64/i64_xor/32_const.wat
index 3c31a18ffd92..28e7d51a66bb 100644
--- a/tests/disas/winch/x64/i64_xor/32_const.wat
+++ b/tests/disas/winch/x64/i64_xor/32_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/i64_xor/64_const.wat b/tests/disas/winch/x64/i64_xor/64_const.wat
index d66523564a7a..b91577129bbf 100644
--- a/tests/disas/winch/x64/i64_xor/64_const.wat
+++ b/tests/disas/winch/x64/i64_xor/64_const.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i64_xor/locals.wat b/tests/disas/winch/x64/i64_xor/locals.wat
index c3ca50d871a6..c1b0ae85477c 100644
--- a/tests/disas/winch/x64/i64_xor/locals.wat
+++ b/tests/disas/winch/x64/i64_xor/locals.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i64_xor/params.wat b/tests/disas/winch/x64/i64_xor/params.wat
index 98871f2fda9e..f91e242a6040 100644
--- a/tests/disas/winch/x64/i64_xor/params.wat
+++ b/tests/disas/winch/x64/i64_xor/params.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64x2/add/add.wat b/tests/disas/winch/x64/i64x2/add/add.wat
index 984165e99856..28072a8fc42e 100644
--- a/tests/disas/winch/x64/i64x2/add/add.wat
+++ b/tests/disas/winch/x64/i64x2/add/add.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64x2/extmul/high_s.wat b/tests/disas/winch/x64/i64x2/extmul/high_s.wat
index 2fa08a87e613..33c74a69e942 100644
--- a/tests/disas/winch/x64/i64x2/extmul/high_s.wat
+++ b/tests/disas/winch/x64/i64x2/extmul/high_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8c
diff --git a/tests/disas/winch/x64/i64x2/extmul/high_u.wat b/tests/disas/winch/x64/i64x2/extmul/high_u.wat
index 52197868d695..8b87186ec1cf 100644
--- a/tests/disas/winch/x64/i64x2/extmul/high_u.wat
+++ b/tests/disas/winch/x64/i64x2/extmul/high_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8c
diff --git a/tests/disas/winch/x64/i64x2/extmul/low_s.wat b/tests/disas/winch/x64/i64x2/extmul/low_s.wat
index fa647d858037..d1ec09b62111 100644
--- a/tests/disas/winch/x64/i64x2/extmul/low_s.wat
+++ b/tests/disas/winch/x64/i64x2/extmul/low_s.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/i64x2/extmul/low_u.wat b/tests/disas/winch/x64/i64x2/extmul/low_u.wat
index 3a72ea0838c2..6e1c1284396a 100644
--- a/tests/disas/winch/x64/i64x2/extmul/low_u.wat
+++ b/tests/disas/winch/x64/i64x2/extmul/low_u.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x82
diff --git a/tests/disas/winch/x64/i64x2/extract_lane/const.wat b/tests/disas/winch/x64/i64x2/extract_lane/const.wat
index 1c2d05c324ad..5e05612ba6d4 100644
--- a/tests/disas/winch/x64/i64x2/extract_lane/const.wat
+++ b/tests/disas/winch/x64/i64x2/extract_lane/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i64x2/mul/mul.wat b/tests/disas/winch/x64/i64x2/mul/mul.wat
index f89344034d83..9c0135623a2e 100644
--- a/tests/disas/winch/x64/i64x2/mul/mul.wat
+++ b/tests/disas/winch/x64/i64x2/mul/mul.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i64x2/mul/mul_fallback.wat b/tests/disas/winch/x64/i64x2/mul/mul_fallback.wat
index ea83816220ed..f94049118622 100644
--- a/tests/disas/winch/x64/i64x2/mul/mul_fallback.wat
+++ b/tests/disas/winch/x64/i64x2/mul/mul_fallback.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/i64x2/neg/neg.wat b/tests/disas/winch/x64/i64x2/neg/neg.wat
index 42117bc8bdb6..028c8a3b3943 100644
--- a/tests/disas/winch/x64/i64x2/neg/neg.wat
+++ b/tests/disas/winch/x64/i64x2/neg/neg.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i64x2/replace_lane/const_avx.wat b/tests/disas/winch/x64/i64x2/replace_lane/const_avx.wat
index 18f326053f8a..4de3655e9251 100644
--- a/tests/disas/winch/x64/i64x2/replace_lane/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2/replace_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64x2/replace_lane/param_avx.wat b/tests/disas/winch/x64/i64x2/replace_lane/param_avx.wat
index 2f5c4f3295d9..4d601aa28ae4 100644
--- a/tests/disas/winch/x64/i64x2/replace_lane/param_avx.wat
+++ b/tests/disas/winch/x64/i64x2/replace_lane/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64x2/shift/shl.wat b/tests/disas/winch/x64/i64x2/shift/shl.wat
index 3d0eeea21672..5a49f2222f8b 100644
--- a/tests/disas/winch/x64/i64x2/shift/shl.wat
+++ b/tests/disas/winch/x64/i64x2/shift/shl.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i64x2/shift/shr_s.wat b/tests/disas/winch/x64/i64x2/shift/shr_s.wat
index 41a2995fb3bb..e025f53da655 100644
--- a/tests/disas/winch/x64/i64x2/shift/shr_s.wat
+++ b/tests/disas/winch/x64/i64x2/shift/shr_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x68
diff --git a/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_float_local.wat b/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_float_local.wat
index f41c490870b5..ed9aa8d96410 100644
--- a/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_float_local.wat
+++ b/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_float_local.wat
@@ -45,7 +45,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x98, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x2c2
diff --git a/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_int_local.wat b/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_int_local.wat
index ddd4acfd0ff4..8f4300cc0acb 100644
--- a/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_int_local.wat
+++ b/tests/disas/winch/x64/i64x2/shift/shr_s_all_fprs_int_local.wat
@@ -45,7 +45,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x98, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x2b4
diff --git a/tests/disas/winch/x64/i64x2/shift/shr_u.wat b/tests/disas/winch/x64/i64x2/shift/shr_u.wat
index b36a181ff4b5..1452dfe15d9f 100644
--- a/tests/disas/winch/x64/i64x2/shift/shr_u.wat
+++ b/tests/disas/winch/x64/i64x2/shift/shr_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/i64x2/splat/const_avx.wat b/tests/disas/winch/x64/i64x2/splat/const_avx.wat
index 6a13027f27c2..2e5992613d9e 100644
--- a/tests/disas/winch/x64/i64x2/splat/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2/splat/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i64x2/splat/param_avx.wat b/tests/disas/winch/x64/i64x2/splat/param_avx.wat
index 2a95f7bc1af2..aee67e47f7b5 100644
--- a/tests/disas/winch/x64/i64x2/splat/param_avx.wat
+++ b/tests/disas/winch/x64/i64x2/splat/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/i64x2/sub/sub.wat b/tests/disas/winch/x64/i64x2/sub/sub.wat
index ca8d8b9feee3..89b5e35f0325 100644
--- a/tests/disas/winch/x64/i64x2/sub/sub.wat
+++ b/tests/disas/winch/x64/i64x2/sub/sub.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/i64x2_abs/const_avx.wat b/tests/disas/winch/x64/i64x2_abs/const_avx.wat
index 49fbb47f0775..060d308caf5f 100644
--- a/tests/disas/winch/x64/i64x2_abs/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i64x2_all_true/const_avx.wat b/tests/disas/winch/x64/i64x2_all_true/const_avx.wat
index b6f672b9379b..96fea1e9f8dd 100644
--- a/tests/disas/winch/x64/i64x2_all_true/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_all_true/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i64x2_bitmask/const_avx.wat b/tests/disas/winch/x64/i64x2_bitmask/const_avx.wat
index 2310817f276d..51f6212a3838 100644
--- a/tests/disas/winch/x64/i64x2_bitmask/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_bitmask/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i64x2_eq/const.wat b/tests/disas/winch/x64/i64x2_eq/const.wat
index a5e08623f593..b2eeb3b66778 100644
--- a/tests/disas/winch/x64/i64x2_eq/const.wat
+++ b/tests/disas/winch/x64/i64x2_eq/const.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64x2_extend_high_i32x4_s/const_avx.wat b/tests/disas/winch/x64/i64x2_extend_high_i32x4_s/const_avx.wat
index 196b208f235c..9f6f3c4e4955 100644
--- a/tests/disas/winch/x64/i64x2_extend_high_i32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_extend_high_i32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64x2_extend_high_i32x4_u/const_avx.wat b/tests/disas/winch/x64/i64x2_extend_high_i32x4_u/const_avx.wat
index 1b1c57862b27..918ddb4603db 100644
--- a/tests/disas/winch/x64/i64x2_extend_high_i32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_extend_high_i32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i64x2_extend_low_i32x4_s/const_avx.wat b/tests/disas/winch/x64/i64x2_extend_low_i32x4_s/const_avx.wat
index fee6f0a1a96b..22e5255841de 100644
--- a/tests/disas/winch/x64/i64x2_extend_low_i32x4_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_extend_low_i32x4_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64x2_extend_low_i32x4_u/const_avx.wat b/tests/disas/winch/x64/i64x2_extend_low_i32x4_u/const_avx.wat
index 887843e43dcb..c1847e6e63e5 100644
--- a/tests/disas/winch/x64/i64x2_extend_low_i32x4_u/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_extend_low_i32x4_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i64x2_ge_s/const_avx.wat b/tests/disas/winch/x64/i64x2_ge_s/const_avx.wat
index 9d862a7741da..347470008caa 100644
--- a/tests/disas/winch/x64/i64x2_ge_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_ge_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i64x2_gt_s/const_avx.wat b/tests/disas/winch/x64/i64x2_gt_s/const_avx.wat
index e8538d0d1fc6..a77fc75db8c8 100644
--- a/tests/disas/winch/x64/i64x2_gt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_gt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64x2_le_s/const_avx.wat b/tests/disas/winch/x64/i64x2_le_s/const_avx.wat
index 3443adfbf0ea..1d933e9217a4 100644
--- a/tests/disas/winch/x64/i64x2_le_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_le_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i64x2_lt_s/const_avx.wat b/tests/disas/winch/x64/i64x2_lt_s/const_avx.wat
index 4383b12517d8..4e51ecedf506 100644
--- a/tests/disas/winch/x64/i64x2_lt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_lt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x51
diff --git a/tests/disas/winch/x64/i64x2_ne/const_avx.wat b/tests/disas/winch/x64/i64x2_ne/const_avx.wat
index 754af59b3532..de6494605d79 100644
--- a/tests/disas/winch/x64/i64x2_ne/const_avx.wat
+++ b/tests/disas/winch/x64/i64x2_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/i8x16/add/add.wat b/tests/disas/winch/x64/i8x16/add/add.wat
index 0710708c5fe1..6da4dec3a9ed 100644
--- a/tests/disas/winch/x64/i8x16/add/add.wat
+++ b/tests/disas/winch/x64/i8x16/add/add.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/add/add_sat_s.wat b/tests/disas/winch/x64/i8x16/add/add_sat_s.wat
index 60f81e8291a9..97888d3437ec 100644
--- a/tests/disas/winch/x64/i8x16/add/add_sat_s.wat
+++ b/tests/disas/winch/x64/i8x16/add/add_sat_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/add/add_sat_u.wat b/tests/disas/winch/x64/i8x16/add/add_sat_u.wat
index 9215e5043f5d..22eb1d4d996a 100644
--- a/tests/disas/winch/x64/i8x16/add/add_sat_u.wat
+++ b/tests/disas/winch/x64/i8x16/add/add_sat_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/extract_lane_s/const_avx.wat b/tests/disas/winch/x64/i8x16/extract_lane_s/const_avx.wat
index e37c96bfec29..117f6b56858e 100644
--- a/tests/disas/winch/x64/i8x16/extract_lane_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16/extract_lane_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i8x16/extract_lane_u/const_avx.wat b/tests/disas/winch/x64/i8x16/extract_lane_u/const_avx.wat
index 442d7317e58f..e91e21fcd366 100644
--- a/tests/disas/winch/x64/i8x16/extract_lane_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16/extract_lane_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
diff --git a/tests/disas/winch/x64/i8x16/max/max_s.wat b/tests/disas/winch/x64/i8x16/max/max_s.wat
index 81b43900029b..ca795bcb1614 100644
--- a/tests/disas/winch/x64/i8x16/max/max_s.wat
+++ b/tests/disas/winch/x64/i8x16/max/max_s.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i8x16/max/max_u.wat b/tests/disas/winch/x64/i8x16/max/max_u.wat
index b0e2ae713cd1..842c5f5dbff9 100644
--- a/tests/disas/winch/x64/i8x16/max/max_u.wat
+++ b/tests/disas/winch/x64/i8x16/max/max_u.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i8x16/min/min_s.wat b/tests/disas/winch/x64/i8x16/min/min_s.wat
index 7d54919fc71d..3b3ca8da0e19 100644
--- a/tests/disas/winch/x64/i8x16/min/min_s.wat
+++ b/tests/disas/winch/x64/i8x16/min/min_s.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i8x16/min/min_u.wat b/tests/disas/winch/x64/i8x16/min/min_u.wat
index 81fc5eb5f03a..a97505cb9221 100644
--- a/tests/disas/winch/x64/i8x16/min/min_u.wat
+++ b/tests/disas/winch/x64/i8x16/min/min_u.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i8x16/neg/neg.wat b/tests/disas/winch/x64/i8x16/neg/neg.wat
index f64cb3007af9..ed53723b9385 100644
--- a/tests/disas/winch/x64/i8x16/neg/neg.wat
+++ b/tests/disas/winch/x64/i8x16/neg/neg.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/i8x16/replace_lane/const_avx.wat b/tests/disas/winch/x64/i8x16/replace_lane/const_avx.wat
index 25f7a63ac2c8..803161513b24 100644
--- a/tests/disas/winch/x64/i8x16/replace_lane/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16/replace_lane/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i8x16/replace_lane/param_avx.wat b/tests/disas/winch/x64/i8x16/replace_lane/param_avx.wat
index 5d13beb9f9df..5f2b289545c4 100644
--- a/tests/disas/winch/x64/i8x16/replace_lane/param_avx.wat
+++ b/tests/disas/winch/x64/i8x16/replace_lane/param_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/i8x16/shift/shl.wat b/tests/disas/winch/x64/i8x16/shift/shl.wat
index 6476cbe16c7e..5243cfdb47c0 100644
--- a/tests/disas/winch/x64/i8x16/shift/shl.wat
+++ b/tests/disas/winch/x64/i8x16/shift/shl.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i8x16/shift/shr_s.wat b/tests/disas/winch/x64/i8x16/shift/shr_s.wat
index ae6691db9aff..0804e268dce6 100644
--- a/tests/disas/winch/x64/i8x16/shift/shr_s.wat
+++ b/tests/disas/winch/x64/i8x16/shift/shr_s.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x69
diff --git a/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_float_local.wat b/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_float_local.wat
index b0cd1844586c..bb9c0ec2914d 100644
--- a/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_float_local.wat
+++ b/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_float_local.wat
@@ -45,7 +45,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x98, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x2c5
diff --git a/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_int_local.wat b/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_int_local.wat
index ca7e38ceb5a2..540096a6e0f4 100644
--- a/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_int_local.wat
+++ b/tests/disas/winch/x64/i8x16/shift/shr_s_all_fprs_int_local.wat
@@ -45,7 +45,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x98, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x2b7
diff --git a/tests/disas/winch/x64/i8x16/shift/shr_u.wat b/tests/disas/winch/x64/i8x16/shift/shr_u.wat
index d85dbb31cf84..495834e6876b 100644
--- a/tests/disas/winch/x64/i8x16/shift/shr_u.wat
+++ b/tests/disas/winch/x64/i8x16/shift/shr_u.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/i8x16/shuffle/const_avx.wat b/tests/disas/winch/x64/i8x16/shuffle/const_avx.wat
index 6411b1799646..bbd071ae88c8 100644
--- a/tests/disas/winch/x64/i8x16/shuffle/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16/shuffle/const_avx.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x63
diff --git a/tests/disas/winch/x64/i8x16/splat/const_avx2.wat b/tests/disas/winch/x64/i8x16/splat/const_avx2.wat
index 99453f693696..5a881e12a943 100644
--- a/tests/disas/winch/x64/i8x16/splat/const_avx2.wat
+++ b/tests/disas/winch/x64/i8x16/splat/const_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
diff --git a/tests/disas/winch/x64/i8x16/splat/param_avx2.wat b/tests/disas/winch/x64/i8x16/splat/param_avx2.wat
index 1fe18b7e5128..91288515a6cd 100644
--- a/tests/disas/winch/x64/i8x16/splat/param_avx2.wat
+++ b/tests/disas/winch/x64/i8x16/splat/param_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/i8x16/sub/sub.wat b/tests/disas/winch/x64/i8x16/sub/sub.wat
index 2a3abcddf4bd..dd6d579a6fca 100644
--- a/tests/disas/winch/x64/i8x16/sub/sub.wat
+++ b/tests/disas/winch/x64/i8x16/sub/sub.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/sub/sub_sat_s.wat b/tests/disas/winch/x64/i8x16/sub/sub_sat_s.wat
index e2e7cd230b59..9c38675a5c6b 100644
--- a/tests/disas/winch/x64/i8x16/sub/sub_sat_s.wat
+++ b/tests/disas/winch/x64/i8x16/sub/sub_sat_s.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/sub/sub_sat_u.wat b/tests/disas/winch/x64/i8x16/sub/sub_sat_u.wat
index c92f87ea5121..02eff24880c9 100644
--- a/tests/disas/winch/x64/i8x16/sub/sub_sat_u.wat
+++ b/tests/disas/winch/x64/i8x16/sub/sub_sat_u.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16/swizzle/const_avx.wat b/tests/disas/winch/x64/i8x16/swizzle/const_avx.wat
index 5bd4baeb2a52..d620c68d108c 100644
--- a/tests/disas/winch/x64/i8x16/swizzle/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16/swizzle/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x59
diff --git a/tests/disas/winch/x64/i8x16_abs/const_avx.wat b/tests/disas/winch/x64/i8x16_abs/const_avx.wat
index 4e9da3ca12c2..85bc3222947a 100644
--- a/tests/disas/winch/x64/i8x16_abs/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_abs/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/i8x16_all_true/const_avx.wat b/tests/disas/winch/x64/i8x16_all_true/const_avx.wat
index 67be65b7323b..51a72cda549e 100644
--- a/tests/disas/winch/x64/i8x16_all_true/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_all_true/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/i8x16_avgr_u/const_avx.wat b/tests/disas/winch/x64/i8x16_avgr_u/const_avx.wat
index 4868d2e34985..05a917af5d0a 100644
--- a/tests/disas/winch/x64/i8x16_avgr_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_avgr_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_bitmask/const_avx.wat b/tests/disas/winch/x64/i8x16_bitmask/const_avx.wat
index e1ad2ecd3663..4e89511c20bd 100644
--- a/tests/disas/winch/x64/i8x16_bitmask/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_bitmask/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x44
diff --git a/tests/disas/winch/x64/i8x16_eq/const_avx.wat b/tests/disas/winch/x64/i8x16_eq/const_avx.wat
index ebef0568dc15..8c0488c92972 100644
--- a/tests/disas/winch/x64/i8x16_eq/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_eq/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_ge_s/const_avx.wat b/tests/disas/winch/x64/i8x16_ge_s/const_avx.wat
index a46acc7e7e93..788e5e6dfc59 100644
--- a/tests/disas/winch/x64/i8x16_ge_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_ge_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i8x16_ge_u/const_avx.wat b/tests/disas/winch/x64/i8x16_ge_u/const_avx.wat
index fc349af3f699..267fa25b403e 100644
--- a/tests/disas/winch/x64/i8x16_ge_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_ge_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/i8x16_gt_s/const_avx.wat b/tests/disas/winch/x64/i8x16_gt_s/const_avx.wat
index 11267dcec333..47549ac5e329 100644
--- a/tests/disas/winch/x64/i8x16_gt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_gt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_gt_u/const_avx.wat b/tests/disas/winch/x64/i8x16_gt_u/const_avx.wat
index cdd3f914ac20..3dd26f310e14 100644
--- a/tests/disas/winch/x64/i8x16_gt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_gt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/i8x16_le_s/const_avx.wat b/tests/disas/winch/x64/i8x16_le_s/const_avx.wat
index 2f77728c05aa..aab92c8518c6 100644
--- a/tests/disas/winch/x64/i8x16_le_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_le_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x55
diff --git a/tests/disas/winch/x64/i8x16_le_u/const_avx.wat b/tests/disas/winch/x64/i8x16_le_u/const_avx.wat
index fa16cabf376d..a65b176ce352 100644
--- a/tests/disas/winch/x64/i8x16_le_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_le_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/i8x16_lt_s/const_avx.wat b/tests/disas/winch/x64/i8x16_lt_s/const_avx.wat
index 48f14e0ff13d..e7674826d7cd 100644
--- a/tests/disas/winch/x64/i8x16_lt_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_lt_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_lt_u/const_avx.wat b/tests/disas/winch/x64/i8x16_lt_u/const_avx.wat
index 90aafd171f4f..c778d25279b9 100644
--- a/tests/disas/winch/x64/i8x16_lt_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_lt_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5c
diff --git a/tests/disas/winch/x64/i8x16_narrow_i16x8_s/const_avx.wat b/tests/disas/winch/x64/i8x16_narrow_i16x8_s/const_avx.wat
index 445555a7ad86..e3d9653158c3 100644
--- a/tests/disas/winch/x64/i8x16_narrow_i16x8_s/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_narrow_i16x8_s/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_narrow_i16x8_u/const_avx.wat b/tests/disas/winch/x64/i8x16_narrow_i16x8_u/const_avx.wat
index 03fe106cc64e..3caa49c6f02d 100644
--- a/tests/disas/winch/x64/i8x16_narrow_i16x8_u/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_narrow_i16x8_u/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/i8x16_ne/const_avx.wat b/tests/disas/winch/x64/i8x16_ne/const_avx.wat
index 02e91fa28fe4..2e7fc36a60cd 100644
--- a/tests/disas/winch/x64/i8x16_ne/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_ne/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/i8x16_popcnt/const_avx.wat b/tests/disas/winch/x64/i8x16_popcnt/const_avx.wat
index f2060d782674..b5098df963d6 100644
--- a/tests/disas/winch/x64/i8x16_popcnt/const_avx.wat
+++ b/tests/disas/winch/x64/i8x16_popcnt/const_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6c
diff --git a/tests/disas/winch/x64/i8x16_popcnt/multiple.wat b/tests/disas/winch/x64/i8x16_popcnt/multiple.wat
index 63c878706583..24506aeddbff 100644
--- a/tests/disas/winch/x64/i8x16_popcnt/multiple.wat
+++ b/tests/disas/winch/x64/i8x16_popcnt/multiple.wat
@@ -34,7 +34,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x8c, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x1c5
diff --git a/tests/disas/winch/x64/if/as_binop.wat b/tests/disas/winch/x64/if/as_binop.wat
index 7aaab86331b1..40c520a18bef 100644
--- a/tests/disas/winch/x64/if/as_binop.wat
+++ b/tests/disas/winch/x64/if/as_binop.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -37,7 +37,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x12c
diff --git a/tests/disas/winch/x64/if/as_br_if_last.wat b/tests/disas/winch/x64/if/as_br_if_last.wat
index c5d4431d85ee..a4aee211b477 100644
--- a/tests/disas/winch/x64/if/as_br_if_last.wat
+++ b/tests/disas/winch/x64/if/as_br_if_last.wat
@@ -19,7 +19,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -36,7 +36,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xef
diff --git a/tests/disas/winch/x64/if/as_if_cond.wat b/tests/disas/winch/x64/if/as_if_cond.wat
index e80f9740a45c..7fddbf350dc6 100644
--- a/tests/disas/winch/x64/if/as_if_cond.wat
+++ b/tests/disas/winch/x64/if/as_if_cond.wat
@@ -17,7 +17,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -34,7 +34,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xcf
diff --git a/tests/disas/winch/x64/if/as_testop.wat b/tests/disas/winch/x64/if/as_testop.wat
index aca192beef57..11f4d105d21a 100644
--- a/tests/disas/winch/x64/if/as_testop.wat
+++ b/tests/disas/winch/x64/if/as_testop.wat
@@ -15,7 +15,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -32,7 +32,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xc3
diff --git a/tests/disas/winch/x64/if/break_value.wat b/tests/disas/winch/x64/if/break_value.wat
index 86b51e73e5e3..c2ba505a7231 100644
--- a/tests/disas/winch/x64/if/break_value.wat
+++ b/tests/disas/winch/x64/if/break_value.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/if/nested.wat b/tests/disas/winch/x64/if/nested.wat
index 6262f768c26e..307d3e75f152 100644
--- a/tests/disas/winch/x64/if/nested.wat
+++ b/tests/disas/winch/x64/if/nested.wat
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -44,7 +44,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x182
diff --git a/tests/disas/winch/x64/if/reachability.wat b/tests/disas/winch/x64/if/reachability.wat
index de8b8c09469f..e88f84b6d1f3 100644
--- a/tests/disas/winch/x64/if/reachability.wat
+++ b/tests/disas/winch/x64/if/reachability.wat
@@ -18,7 +18,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/if/singular.wat b/tests/disas/winch/x64/if/singular.wat
index a46cab96f86a..d1317fe4800f 100644
--- a/tests/disas/winch/x64/if/singular.wat
+++ b/tests/disas/winch/x64/if/singular.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xb0
diff --git a/tests/disas/winch/x64/load/f32.wat b/tests/disas/winch/x64/load/f32.wat
index 9fdc307e01e0..eef05f696d09 100644
--- a/tests/disas/winch/x64/load/f32.wat
+++ b/tests/disas/winch/x64/load/f32.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/load/f64.wat b/tests/disas/winch/x64/load/f64.wat
index d496068814de..b609f750699f 100644
--- a/tests/disas/winch/x64/load/f64.wat
+++ b/tests/disas/winch/x64/load/f64.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/load/grow_load.wat b/tests/disas/winch/x64/load/grow_load.wat
index 500e3caa2488..189f18e0cf25 100644
--- a/tests/disas/winch/x64/load/grow_load.wat
+++ b/tests/disas/winch/x64/load/grow_load.wat
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x70, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x137
diff --git a/tests/disas/winch/x64/load/i32.wat b/tests/disas/winch/x64/load/i32.wat
index 6b073fc967fa..64afb8ab0aa5 100644
--- a/tests/disas/winch/x64/load/i32.wat
+++ b/tests/disas/winch/x64/load/i32.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x48
diff --git a/tests/disas/winch/x64/load/i64.wat b/tests/disas/winch/x64/load/i64.wat
index 658d26807202..fef490ea3574 100644
--- a/tests/disas/winch/x64/load/i64.wat
+++ b/tests/disas/winch/x64/load/i64.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/load/v128.wat b/tests/disas/winch/x64/load/v128.wat
index c961d2500e2f..c7daf1d4c818 100644
--- a/tests/disas/winch/x64/load/v128.wat
+++ b/tests/disas/winch/x64/load/v128.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/load/v128_load16_splat_avx2.wat b/tests/disas/winch/x64/load/v128_load16_splat_avx2.wat
index ba8a93892743..2cdcc3952a2b 100644
--- a/tests/disas/winch/x64/load/v128_load16_splat_avx2.wat
+++ b/tests/disas/winch/x64/load/v128_load16_splat_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load16x4_s_avx.wat b/tests/disas/winch/x64/load/v128_load16x4_s_avx.wat
index 9ee5e73e3790..8ea43c1a750c 100644
--- a/tests/disas/winch/x64/load/v128_load16x4_s_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load16x4_s_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load16x4_u_avx.wat b/tests/disas/winch/x64/load/v128_load16x4_u_avx.wat
index a73fd80c1aa8..c639b4154587 100644
--- a/tests/disas/winch/x64/load/v128_load16x4_u_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load16x4_u_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load32_splat_avx2.wat b/tests/disas/winch/x64/load/v128_load32_splat_avx2.wat
index cb86b36d6978..79d7b1016b98 100644
--- a/tests/disas/winch/x64/load/v128_load32_splat_avx2.wat
+++ b/tests/disas/winch/x64/load/v128_load32_splat_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load32_zero_avx.wat b/tests/disas/winch/x64/load/v128_load32_zero_avx.wat
index ea090a4d0faf..321ba9559c3d 100644
--- a/tests/disas/winch/x64/load/v128_load32_zero_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load32_zero_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/load/v128_load32x2_s_avx.wat b/tests/disas/winch/x64/load/v128_load32x2_s_avx.wat
index b3a3c9c60069..c2156cfb8da4 100644
--- a/tests/disas/winch/x64/load/v128_load32x2_s_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load32x2_s_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load32x2_s_oob_avx.wat b/tests/disas/winch/x64/load/v128_load32x2_s_oob_avx.wat
index 01f56b4eb664..b8491fc0f58c 100644
--- a/tests/disas/winch/x64/load/v128_load32x2_s_oob_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load32x2_s_oob_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/load/v128_load32x2_u_avx.wat b/tests/disas/winch/x64/load/v128_load32x2_u_avx.wat
index a48bc4f2dd49..f6b77520b233 100644
--- a/tests/disas/winch/x64/load/v128_load32x2_u_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load32x2_u_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load32x2_u_oob_avx.wat b/tests/disas/winch/x64/load/v128_load32x2_u_oob_avx.wat
index 911768638fca..b24608b207b9 100644
--- a/tests/disas/winch/x64/load/v128_load32x2_u_oob_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load32x2_u_oob_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x66
diff --git a/tests/disas/winch/x64/load/v128_load64_splat_avx.wat b/tests/disas/winch/x64/load/v128_load64_splat_avx.wat
index 8e465afb7d7d..2890ed4ab232 100644
--- a/tests/disas/winch/x64/load/v128_load64_splat_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load64_splat_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/load/v128_load64_zero_avx.wat b/tests/disas/winch/x64/load/v128_load64_zero_avx.wat
index 31fbcdc06057..c0ca0da8f92f 100644
--- a/tests/disas/winch/x64/load/v128_load64_zero_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load64_zero_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4e
diff --git a/tests/disas/winch/x64/load/v128_load8_splat_avx2.wat b/tests/disas/winch/x64/load/v128_load8_splat_avx2.wat
index 7e96449876c6..e47020f4470e 100644
--- a/tests/disas/winch/x64/load/v128_load8_splat_avx2.wat
+++ b/tests/disas/winch/x64/load/v128_load8_splat_avx2.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load8x8_s_avx.wat b/tests/disas/winch/x64/load/v128_load8x8_s_avx.wat
index 5e321b7b3de7..3d05eb3d4a64 100644
--- a/tests/disas/winch/x64/load/v128_load8x8_s_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load8x8_s_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/load/v128_load8x8_u_avx.wat b/tests/disas/winch/x64/load/v128_load8x8_u_avx.wat
index 342e4325aa68..2e1e7f481b7b 100644
--- a/tests/disas/winch/x64/load/v128_load8x8_u_avx.wat
+++ b/tests/disas/winch/x64/load/v128_load8x8_u_avx.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
diff --git a/tests/disas/winch/x64/local/latent.wat b/tests/disas/winch/x64/local/latent.wat
index d4a3519be85a..0d4d39d30b9e 100644
--- a/tests/disas/winch/x64/local/latent.wat
+++ b/tests/disas/winch/x64/local/latent.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/local/materialized.wat b/tests/disas/winch/x64/local/materialized.wat
index 99e1a59e6a8d..b3d4f2593e65 100644
--- a/tests/disas/winch/x64/local/materialized.wat
+++ b/tests/disas/winch/x64/local/materialized.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x45
diff --git a/tests/disas/winch/x64/local/v128_multivalue.wat b/tests/disas/winch/x64/local/v128_multivalue.wat
index 2d48e08c696e..57efdfe9b029 100644
--- a/tests/disas/winch/x64/local/v128_multivalue.wat
+++ b/tests/disas/winch/x64/local/v128_multivalue.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x48, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9d
diff --git a/tests/disas/winch/x64/loop/as_binary_operand.wat b/tests/disas/winch/x64/loop/as_binary_operand.wat
index 1788ec16e9c6..02cfed67ac01 100644
--- a/tests/disas/winch/x64/loop/as_binary_operand.wat
+++ b/tests/disas/winch/x64/loop/as_binary_operand.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa3
diff --git a/tests/disas/winch/x64/loop/as_br_if_first.wat b/tests/disas/winch/x64/loop/as_br_if_first.wat
index 7692c10dbe26..a3a2c1d589e6 100644
--- a/tests/disas/winch/x64/loop/as_br_if_first.wat
+++ b/tests/disas/winch/x64/loop/as_br_if_first.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/loop/as_br_if_last.wat b/tests/disas/winch/x64/loop/as_br_if_last.wat
index ab7bc581b09c..33865c3cb40e 100644
--- a/tests/disas/winch/x64/loop/as_br_if_last.wat
+++ b/tests/disas/winch/x64/loop/as_br_if_last.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4a
diff --git a/tests/disas/winch/x64/loop/as_br_value.wat b/tests/disas/winch/x64/loop/as_br_value.wat
index 6f5a061a428f..6ba9d7322485 100644
--- a/tests/disas/winch/x64/loop/as_br_value.wat
+++ b/tests/disas/winch/x64/loop/as_br_value.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/loop/as_call_value.wat b/tests/disas/winch/x64/loop/as_call_value.wat
index 80591e3f8ebc..2cf04ea7ba2e 100644
--- a/tests/disas/winch/x64/loop/as_call_value.wat
+++ b/tests/disas/winch/x64/loop/as_call_value.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x41
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9d
diff --git a/tests/disas/winch/x64/loop/as_if_condition.wat b/tests/disas/winch/x64/loop/as_if_condition.wat
index 2eba7483b1c6..2786af80c4b2 100644
--- a/tests/disas/winch/x64/loop/as_if_condition.wat
+++ b/tests/disas/winch/x64/loop/as_if_condition.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x95
diff --git a/tests/disas/winch/x64/loop/as_if_else.wat b/tests/disas/winch/x64/loop/as_if_else.wat
index 8a78696938ac..ea4720ae836d 100644
--- a/tests/disas/winch/x64/loop/as_if_else.wat
+++ b/tests/disas/winch/x64/loop/as_if_else.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/loop/as_if_then.wat b/tests/disas/winch/x64/loop/as_if_then.wat
index 7744c6b7327e..15565b566c83 100644
--- a/tests/disas/winch/x64/loop/as_if_then.wat
+++ b/tests/disas/winch/x64/loop/as_if_then.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/loop/as_local_set_value.wat b/tests/disas/winch/x64/loop/as_local_set_value.wat
index a5b314cd7822..e31850dbc761 100644
--- a/tests/disas/winch/x64/loop/as_local_set_value.wat
+++ b/tests/disas/winch/x64/loop/as_local_set_value.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/loop/as_test_operand.wat b/tests/disas/winch/x64/loop/as_test_operand.wat
index 61d743c11628..69cf0fdc7ce3 100644
--- a/tests/disas/winch/x64/loop/as_test_operand.wat
+++ b/tests/disas/winch/x64/loop/as_test_operand.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x98
diff --git a/tests/disas/winch/x64/loop/as_unary_operand.wat b/tests/disas/winch/x64/loop/as_unary_operand.wat
index 67cc40a5389e..935086bbba21 100644
--- a/tests/disas/winch/x64/loop/as_unary_operand.wat
+++ b/tests/disas/winch/x64/loop/as_unary_operand.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9a
diff --git a/tests/disas/winch/x64/loop/break_inner.wat b/tests/disas/winch/x64/loop/break_inner.wat
index 8baf553a6114..f0e97bd14277 100644
--- a/tests/disas/winch/x64/loop/break_inner.wat
+++ b/tests/disas/winch/x64/loop/break_inner.wat
@@ -16,7 +16,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x108
diff --git a/tests/disas/winch/x64/loop/cont_inner.wat b/tests/disas/winch/x64/loop/cont_inner.wat
index d60466c79c1b..b87716855003 100644
--- a/tests/disas/winch/x64/loop/cont_inner.wat
+++ b/tests/disas/winch/x64/loop/cont_inner.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/loop/deep.wat b/tests/disas/winch/x64/loop/deep.wat
index 2640d5149d01..619a8c2cecc9 100644
--- a/tests/disas/winch/x64/loop/deep.wat
+++ b/tests/disas/winch/x64/loop/deep.wat
@@ -51,7 +51,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -68,7 +68,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/loop/effects.wat b/tests/disas/winch/x64/loop/effects.wat
index eadcbf71f24a..8755b75f86ae 100644
--- a/tests/disas/winch/x64/loop/effects.wat
+++ b/tests/disas/winch/x64/loop/effects.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x83
diff --git a/tests/disas/winch/x64/loop/empty.wat b/tests/disas/winch/x64/loop/empty.wat
index dbf7734a1e3d..eca9f9935e1f 100644
--- a/tests/disas/winch/x64/loop/empty.wat
+++ b/tests/disas/winch/x64/loop/empty.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
diff --git a/tests/disas/winch/x64/loop/for.wat b/tests/disas/winch/x64/loop/for.wat
index f441a7150e29..ff34873de445 100644
--- a/tests/disas/winch/x64/loop/for.wat
+++ b/tests/disas/winch/x64/loop/for.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa9
diff --git a/tests/disas/winch/x64/loop/multi.wat b/tests/disas/winch/x64/loop/multi.wat
index b80f98fa24e8..f3e7f802328b 100644
--- a/tests/disas/winch/x64/loop/multi.wat
+++ b/tests/disas/winch/x64/loop/multi.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xed
diff --git a/tests/disas/winch/x64/loop/nested.wat b/tests/disas/winch/x64/loop/nested.wat
index 2ce4084b6085..0155e3a348d0 100644
--- a/tests/disas/winch/x64/loop/nested.wat
+++ b/tests/disas/winch/x64/loop/nested.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9d
diff --git a/tests/disas/winch/x64/loop/singular.wat b/tests/disas/winch/x64/loop/singular.wat
index c2127544965c..5397b1ebe3d2 100644
--- a/tests/disas/winch/x64/loop/singular.wat
+++ b/tests/disas/winch/x64/loop/singular.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/loop/while.wat b/tests/disas/winch/x64/loop/while.wat
index 1d242ab7f7d9..7be5cd18053e 100644
--- a/tests/disas/winch/x64/loop/while.wat
+++ b/tests/disas/winch/x64/loop/while.wat
@@ -19,7 +19,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x92
diff --git a/tests/disas/winch/x64/nop/nop.wat b/tests/disas/winch/x64/nop/nop.wat
index 7e1c61f9779c..fd4c49928bc0 100644
--- a/tests/disas/winch/x64/nop/nop.wat
+++ b/tests/disas/winch/x64/nop/nop.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
diff --git a/tests/disas/winch/x64/ref/func.wat b/tests/disas/winch/x64/ref/func.wat
index 49f72b56b790..da7a682abcfe 100644
--- a/tests/disas/winch/x64/ref/func.wat
+++ b/tests/disas/winch/x64/ref/func.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/ref/is_null.wat b/tests/disas/winch/x64/ref/is_null.wat
index 53d5a08b3278..011973f51b4f 100644
--- a/tests/disas/winch/x64/ref/is_null.wat
+++ b/tests/disas/winch/x64/ref/is_null.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4f
diff --git a/tests/disas/winch/x64/ref/null.wat b/tests/disas/winch/x64/ref/null.wat
index c680c526038a..046e94a7212b 100644
--- a/tests/disas/winch/x64/ref/null.wat
+++ b/tests/disas/winch/x64/ref/null.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/return/as_block_first.wat b/tests/disas/winch/x64/return/as_block_first.wat
index 8beda35529ac..20b3078747d5 100644
--- a/tests/disas/winch/x64/return/as_block_first.wat
+++ b/tests/disas/winch/x64/return/as_block_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/return/as_block_last.wat b/tests/disas/winch/x64/return/as_block_last.wat
index 6a33af2eedb5..2e6d462028c1 100644
--- a/tests/disas/winch/x64/return/as_block_last.wat
+++ b/tests/disas/winch/x64/return/as_block_last.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/return/as_block_mid.wat b/tests/disas/winch/x64/return/as_block_mid.wat
index c4f2a909a529..58e567de10a0 100644
--- a/tests/disas/winch/x64/return/as_block_mid.wat
+++ b/tests/disas/winch/x64/return/as_block_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/return/as_block_value.wat b/tests/disas/winch/x64/return/as_block_value.wat
index 002a67a2cdce..901e1e17a0b3 100644
--- a/tests/disas/winch/x64/return/as_block_value.wat
+++ b/tests/disas/winch/x64/return/as_block_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_br_if_cond.wat b/tests/disas/winch/x64/return/as_br_if_cond.wat
index b88ee661ca30..55e4f11cad27 100644
--- a/tests/disas/winch/x64/return/as_br_if_cond.wat
+++ b/tests/disas/winch/x64/return/as_br_if_cond.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/return/as_br_value.wat b/tests/disas/winch/x64/return/as_br_value.wat
index 6d62d3483f00..a1b1573a9219 100644
--- a/tests/disas/winch/x64/return/as_br_value.wat
+++ b/tests/disas/winch/x64/return/as_br_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/as_call_fist.wat b/tests/disas/winch/x64/return/as_call_fist.wat
index 96cc8edfe1ee..ab70b18f8ad9 100644
--- a/tests/disas/winch/x64/return/as_call_fist.wat
+++ b/tests/disas/winch/x64/return/as_call_fist.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -32,7 +32,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_call_last.wat b/tests/disas/winch/x64/return/as_call_last.wat
index 3233cb09890d..57cc9dbe4658 100644
--- a/tests/disas/winch/x64/return/as_call_last.wat
+++ b/tests/disas/winch/x64/return/as_call_last.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -32,7 +32,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_call_mid.wat b/tests/disas/winch/x64/return/as_call_mid.wat
index cfd82420fd2a..94c2910b1eb7 100644
--- a/tests/disas/winch/x64/return/as_call_mid.wat
+++ b/tests/disas/winch/x64/return/as_call_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4b
@@ -32,7 +32,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_func_first.wat b/tests/disas/winch/x64/return/as_func_first.wat
index 807ad91ff69a..0efa369c1edc 100644
--- a/tests/disas/winch/x64/return/as_func_first.wat
+++ b/tests/disas/winch/x64/return/as_func_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/as_func_last.wat b/tests/disas/winch/x64/return/as_func_last.wat
index 353eb3dbd9fb..99d79e5e062d 100644
--- a/tests/disas/winch/x64/return/as_func_last.wat
+++ b/tests/disas/winch/x64/return/as_func_last.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
diff --git a/tests/disas/winch/x64/return/as_func_mid.wat b/tests/disas/winch/x64/return/as_func_mid.wat
index fd16144e4cb4..672a613c347d 100644
--- a/tests/disas/winch/x64/return/as_func_mid.wat
+++ b/tests/disas/winch/x64/return/as_func_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_func_value.wat b/tests/disas/winch/x64/return/as_func_value.wat
index c8bf6a0343ca..fa6db3caaa30 100644
--- a/tests/disas/winch/x64/return/as_func_value.wat
+++ b/tests/disas/winch/x64/return/as_func_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_if_cond.wat b/tests/disas/winch/x64/return/as_if_cond.wat
index 9a2a81f860cd..023f51aa2eb5 100644
--- a/tests/disas/winch/x64/return/as_if_cond.wat
+++ b/tests/disas/winch/x64/return/as_if_cond.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/as_if_else.wat b/tests/disas/winch/x64/return/as_if_else.wat
index 6e30f729efcf..5a5f30719e47 100644
--- a/tests/disas/winch/x64/return/as_if_else.wat
+++ b/tests/disas/winch/x64/return/as_if_else.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9b
diff --git a/tests/disas/winch/x64/return/as_if_then.wat b/tests/disas/winch/x64/return/as_if_then.wat
index ecbb8790392a..8b762413da16 100644
--- a/tests/disas/winch/x64/return/as_if_then.wat
+++ b/tests/disas/winch/x64/return/as_if_then.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x9b
diff --git a/tests/disas/winch/x64/return/as_loop_first.wat b/tests/disas/winch/x64/return/as_loop_first.wat
index cceabfa3f536..d4df98067424 100644
--- a/tests/disas/winch/x64/return/as_loop_first.wat
+++ b/tests/disas/winch/x64/return/as_loop_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/as_loop_last.wat b/tests/disas/winch/x64/return/as_loop_last.wat
index 0b191cdc6c0a..d7429e268728 100644
--- a/tests/disas/winch/x64/return/as_loop_last.wat
+++ b/tests/disas/winch/x64/return/as_loop_last.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_loop_mid.wat b/tests/disas/winch/x64/return/as_loop_mid.wat
index f000cf9eb816..33e06cc7a2b7 100644
--- a/tests/disas/winch/x64/return/as_loop_mid.wat
+++ b/tests/disas/winch/x64/return/as_loop_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/return/as_return_value.wat b/tests/disas/winch/x64/return/as_return_value.wat
index b165f4bfe5f0..fba58781fea1 100644
--- a/tests/disas/winch/x64/return/as_return_value.wat
+++ b/tests/disas/winch/x64/return/as_return_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/nullary.wat b/tests/disas/winch/x64/return/nullary.wat
index 40cf3b740af5..1b36b4b5072d 100644
--- a/tests/disas/winch/x64/return/nullary.wat
+++ b/tests/disas/winch/x64/return/nullary.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -26,7 +26,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
diff --git a/tests/disas/winch/x64/return/type_i32.wat b/tests/disas/winch/x64/return/type_i32.wat
index 3572aa404a6f..5d68a08c9fde 100644
--- a/tests/disas/winch/x64/return/type_i32.wat
+++ b/tests/disas/winch/x64/return/type_i32.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/return/type_i64_value.wat b/tests/disas/winch/x64/return/type_i64_value.wat
index 17687fa93813..a8f4f37f69c7 100644
--- a/tests/disas/winch/x64/return/type_i64_value.wat
+++ b/tests/disas/winch/x64/return/type_i64_value.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
diff --git a/tests/disas/winch/x64/select/f32.wat b/tests/disas/winch/x64/select/f32.wat
index 2b22404a3855..cb257e54fbf9 100644
--- a/tests/disas/winch/x64/select/f32.wat
+++ b/tests/disas/winch/x64/select/f32.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/select/f64.wat b/tests/disas/winch/x64/select/f64.wat
index e243beb47623..c1b7ccb108f4 100644
--- a/tests/disas/winch/x64/select/f64.wat
+++ b/tests/disas/winch/x64/select/f64.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x65
diff --git a/tests/disas/winch/x64/select/i32.wat b/tests/disas/winch/x64/select/i32.wat
index 5b3188faafb4..35a459c963a6 100644
--- a/tests/disas/winch/x64/select/i32.wat
+++ b/tests/disas/winch/x64/select/i32.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x5a
diff --git a/tests/disas/winch/x64/select/i64.wat b/tests/disas/winch/x64/select/i64.wat
index f40cedca487e..dc60b6115ea6 100644
--- a/tests/disas/winch/x64/select/i64.wat
+++ b/tests/disas/winch/x64/select/i64.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/select/typed.wat b/tests/disas/winch/x64/select/typed.wat
index e27730f121d6..084eaca8d9c1 100644
--- a/tests/disas/winch/x64/select/typed.wat
+++ b/tests/disas/winch/x64/select/typed.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/store/f32.wat b/tests/disas/winch/x64/store/f32.wat
index 9b4435c53046..3749dbaa13f5 100644
--- a/tests/disas/winch/x64/store/f32.wat
+++ b/tests/disas/winch/x64/store/f32.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x52
diff --git a/tests/disas/winch/x64/store/f64.wat b/tests/disas/winch/x64/store/f64.wat
index 8bcea2421d6e..962eb384536a 100644
--- a/tests/disas/winch/x64/store/f64.wat
+++ b/tests/disas/winch/x64/store/f64.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x52
diff --git a/tests/disas/winch/x64/store/i32.wat b/tests/disas/winch/x64/store/i32.wat
index b5e656d808c6..2fedc89b87e0 100644
--- a/tests/disas/winch/x64/store/i32.wat
+++ b/tests/disas/winch/x64/store/i32.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/store/i64.wat b/tests/disas/winch/x64/store/i64.wat
index b6b94abbaf2b..a9a65b45763a 100644
--- a/tests/disas/winch/x64/store/i64.wat
+++ b/tests/disas/winch/x64/store/i64.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
diff --git a/tests/disas/winch/x64/store/oob.wat b/tests/disas/winch/x64/store/oob.wat
index 8d32715bb5ef..3c8b6a5c2905 100644
--- a/tests/disas/winch/x64/store/oob.wat
+++ b/tests/disas/winch/x64/store/oob.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x88
diff --git a/tests/disas/winch/x64/store/v128.wat b/tests/disas/winch/x64/store/v128.wat
index d8f87f3dcec6..b9027465ed15 100644
--- a/tests/disas/winch/x64/store/v128.wat
+++ b/tests/disas/winch/x64/store/v128.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x52
diff --git a/tests/disas/winch/x64/table/fill.wat b/tests/disas/winch/x64/table/fill.wat
index b971e7a536eb..126506db911d 100644
--- a/tests/disas/winch/x64/table/fill.wat
+++ b/tests/disas/winch/x64/table/fill.wat
@@ -24,7 +24,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -41,7 +41,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x78
@@ -58,7 +58,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xb8
@@ -75,7 +75,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x40, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x22a
diff --git a/tests/disas/winch/x64/table/get.wat b/tests/disas/winch/x64/table/get.wat
index 20c466bc5e14..f4445ad1f924 100644
--- a/tests/disas/winch/x64/table/get.wat
+++ b/tests/disas/winch/x64/table/get.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x10e
diff --git a/tests/disas/winch/x64/table/grow.wat b/tests/disas/winch/x64/table/grow.wat
index b92e8611123f..48b170bc50a5 100644
--- a/tests/disas/winch/x64/table/grow.wat
+++ b/tests/disas/winch/x64/table/grow.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x108
diff --git a/tests/disas/winch/x64/table/init_copy_drop.wat b/tests/disas/winch/x64/table/init_copy_drop.wat
index f50465b2e8df..3e9d814b26c7 100644
--- a/tests/disas/winch/x64/table/init_copy_drop.wat
+++ b/tests/disas/winch/x64/table/init_copy_drop.wat
@@ -38,7 +38,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3d
@@ -56,7 +56,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7d
@@ -74,7 +74,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xbd
@@ -92,7 +92,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xfd
@@ -110,7 +110,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x13d
@@ -128,7 +128,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x40, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa31
@@ -722,7 +722,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xb96
diff --git a/tests/disas/winch/x64/table/set.wat b/tests/disas/winch/x64/table/set.wat
index 562ef0da46ae..799793c8fa34 100644
--- a/tests/disas/winch/x64/table/set.wat
+++ b/tests/disas/winch/x64/table/set.wat
@@ -19,7 +19,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -36,7 +36,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xbd
@@ -71,7 +71,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x1f0
diff --git a/tests/disas/winch/x64/table/size.wat b/tests/disas/winch/x64/table/size.wat
index 85fc71dab99b..528ff5acf951 100644
--- a/tests/disas/winch/x64/table/size.wat
+++ b/tests/disas/winch/x64/table/size.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3f
diff --git a/tests/disas/winch/x64/unreachable/as_block_broke.wat b/tests/disas/winch/x64/unreachable/as_block_broke.wat
index 1b9ae63e709e..5ada0659f731 100644
--- a/tests/disas/winch/x64/unreachable/as_block_broke.wat
+++ b/tests/disas/winch/x64/unreachable/as_block_broke.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/unreachable/as_block_first.wat b/tests/disas/winch/x64/unreachable/as_block_first.wat
index ae9c2f4687eb..3413a6a3638c 100644
--- a/tests/disas/winch/x64/unreachable/as_block_first.wat
+++ b/tests/disas/winch/x64/unreachable/as_block_first.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/as_block_last.wat b/tests/disas/winch/x64/unreachable/as_block_last.wat
index ef61feaf1b38..b8d970ef62ad 100644
--- a/tests/disas/winch/x64/unreachable/as_block_last.wat
+++ b/tests/disas/winch/x64/unreachable/as_block_last.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_block_mid.wat b/tests/disas/winch/x64/unreachable/as_block_mid.wat
index 4ebf285baecc..96b7973d2efc 100644
--- a/tests/disas/winch/x64/unreachable/as_block_mid.wat
+++ b/tests/disas/winch/x64/unreachable/as_block_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_block_value.wat b/tests/disas/winch/x64/unreachable/as_block_value.wat
index d3c8cd33a5be..97b5fa509439 100644
--- a/tests/disas/winch/x64/unreachable/as_block_value.wat
+++ b/tests/disas/winch/x64/unreachable/as_block_value.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_br_if_cond.wat b/tests/disas/winch/x64/unreachable/as_br_if_cond.wat
index 87433cada618..e48345c41b96 100644
--- a/tests/disas/winch/x64/unreachable/as_br_if_cond.wat
+++ b/tests/disas/winch/x64/unreachable/as_br_if_cond.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/as_br_value.wat b/tests/disas/winch/x64/unreachable/as_br_value.wat
index 6424835941da..c772e26e1133 100644
--- a/tests/disas/winch/x64/unreachable/as_br_value.wat
+++ b/tests/disas/winch/x64/unreachable/as_br_value.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/as_call_first.wat b/tests/disas/winch/x64/unreachable/as_call_first.wat
index fac71ad4f7e6..f86c36015cb8 100644
--- a/tests/disas/winch/x64/unreachable/as_call_first.wat
+++ b/tests/disas/winch/x64/unreachable/as_call_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_call_last.wat b/tests/disas/winch/x64/unreachable/as_call_last.wat
index e7d9bb7394da..4969c7e499c9 100644
--- a/tests/disas/winch/x64/unreachable/as_call_last.wat
+++ b/tests/disas/winch/x64/unreachable/as_call_last.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
@@ -32,7 +32,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_call_mid.wat b/tests/disas/winch/x64/unreachable/as_call_mid.wat
index 03dc9b9767ba..c15119855b84 100644
--- a/tests/disas/winch/x64/unreachable/as_call_mid.wat
+++ b/tests/disas/winch/x64/unreachable/as_call_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x46
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_func_first.wat b/tests/disas/winch/x64/unreachable/as_func_first.wat
index 5264a4d07d41..b35921cd1d37 100644
--- a/tests/disas/winch/x64/unreachable/as_func_first.wat
+++ b/tests/disas/winch/x64/unreachable/as_func_first.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x7a
diff --git a/tests/disas/winch/x64/unreachable/as_func_last.wat b/tests/disas/winch/x64/unreachable/as_func_last.wat
index d601c6b857b2..7814896f9a2d 100644
--- a/tests/disas/winch/x64/unreachable/as_func_last.wat
+++ b/tests/disas/winch/x64/unreachable/as_func_last.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -27,7 +27,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_func_mid.wat b/tests/disas/winch/x64/unreachable/as_func_mid.wat
index 706c999cd319..5848e5d355b8 100644
--- a/tests/disas/winch/x64/unreachable/as_func_mid.wat
+++ b/tests/disas/winch/x64/unreachable/as_func_mid.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_func_value.wat b/tests/disas/winch/x64/unreachable/as_func_value.wat
index a2ec39a64524..5711fcf93e3d 100644
--- a/tests/disas/winch/x64/unreachable/as_func_value.wat
+++ b/tests/disas/winch/x64/unreachable/as_func_value.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -28,7 +28,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_if_cond.wat b/tests/disas/winch/x64/unreachable/as_if_cond.wat
index f87bf77345a4..249afcc12fd4 100644
--- a/tests/disas/winch/x64/unreachable/as_if_cond.wat
+++ b/tests/disas/winch/x64/unreachable/as_if_cond.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/as_if_else.wat b/tests/disas/winch/x64/unreachable/as_if_else.wat
index ed3061756375..1c54af3e9a0a 100644
--- a/tests/disas/winch/x64/unreachable/as_if_else.wat
+++ b/tests/disas/winch/x64/unreachable/as_if_else.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/unreachable/as_if_then.wat b/tests/disas/winch/x64/unreachable/as_if_then.wat
index 705802baf54d..a02e3d7d191d 100644
--- a/tests/disas/winch/x64/unreachable/as_if_then.wat
+++ b/tests/disas/winch/x64/unreachable/as_if_then.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat b/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat
index 95dd7e0cdcd0..38ed680c14bd 100644
--- a/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat
+++ b/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x53
diff --git a/tests/disas/winch/x64/unreachable/as_loop_broke.wat b/tests/disas/winch/x64/unreachable/as_loop_broke.wat
index 0a93f94e4e3c..126e8b1bdecd 100644
--- a/tests/disas/winch/x64/unreachable/as_loop_broke.wat
+++ b/tests/disas/winch/x64/unreachable/as_loop_broke.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -30,7 +30,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8d
diff --git a/tests/disas/winch/x64/unreachable/as_loop_first.wat b/tests/disas/winch/x64/unreachable/as_loop_first.wat
index d414ec61d4f8..80c71565e0cb 100644
--- a/tests/disas/winch/x64/unreachable/as_loop_first.wat
+++ b/tests/disas/winch/x64/unreachable/as_loop_first.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/as_loop_last.wat b/tests/disas/winch/x64/unreachable/as_loop_last.wat
index abffcabe878a..8d257e61e9c9 100644
--- a/tests/disas/winch/x64/unreachable/as_loop_last.wat
+++ b/tests/disas/winch/x64/unreachable/as_loop_last.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_loop_mid.wat b/tests/disas/winch/x64/unreachable/as_loop_mid.wat
index 9f8a05823de6..ba992bda62d6 100644
--- a/tests/disas/winch/x64/unreachable/as_loop_mid.wat
+++ b/tests/disas/winch/x64/unreachable/as_loop_mid.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x38
@@ -29,7 +29,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x8a
diff --git a/tests/disas/winch/x64/unreachable/as_return_value.wat b/tests/disas/winch/x64/unreachable/as_return_value.wat
index e62c96dc3b01..b74340f47e50 100644
--- a/tests/disas/winch/x64/unreachable/as_return_value.wat
+++ b/tests/disas/winch/x64/unreachable/as_return_value.wat
@@ -10,7 +10,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/type_i32.wat b/tests/disas/winch/x64/unreachable/type_i32.wat
index e3cdc94917bb..c15ec3f7bc8e 100644
--- a/tests/disas/winch/x64/unreachable/type_i32.wat
+++ b/tests/disas/winch/x64/unreachable/type_i32.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/type_i64.wat b/tests/disas/winch/x64/unreachable/type_i64.wat
index 1d35fcf64de5..6b6d660bbd6d 100644
--- a/tests/disas/winch/x64/unreachable/type_i64.wat
+++ b/tests/disas/winch/x64/unreachable/type_i64.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x3a
diff --git a/tests/disas/winch/x64/unreachable/with_spilled_local.wat b/tests/disas/winch/x64/unreachable/with_spilled_local.wat
index be14cd2bcc1d..7b6e0b7c9320 100644
--- a/tests/disas/winch/x64/unreachable/with_spilled_local.wat
+++ b/tests/disas/winch/x64/unreachable/with_spilled_local.wat
@@ -14,7 +14,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat b/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat
index d0e74bfb1c15..54353aa36105 100644
--- a/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat
+++ b/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat
@@ -19,7 +19,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x24, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x60
diff --git a/tests/disas/winch/x64/v128_const/call_id.wat b/tests/disas/winch/x64/v128_const/call_id.wat
index 01e2abe42636..3db9785eaa4c 100644
--- a/tests/disas/winch/x64/v128_const/call_id.wat
+++ b/tests/disas/winch/x64/v128_const/call_id.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
@@ -31,7 +31,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0xa0
diff --git a/tests/disas/winch/x64/v128_const/id.wat b/tests/disas/winch/x64/v128_const/id.wat
index 93aa35c837db..52a46c4adb42 100644
--- a/tests/disas/winch/x64/v128_const/id.wat
+++ b/tests/disas/winch/x64/v128_const/id.wat
@@ -8,7 +8,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x20, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x43
diff --git a/tests/disas/winch/x64/v128_const/multivalue.wat b/tests/disas/winch/x64/v128_const/multivalue.wat
index 3902b4e272a5..39deb5f4ee75 100644
--- a/tests/disas/winch/x64/v128_const/multivalue.wat
+++ b/tests/disas/winch/x64/v128_const/multivalue.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rsi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x73
diff --git a/tests/disas/winch/x64/v128_const/spilled.wat b/tests/disas/winch/x64/v128_const/spilled.wat
index e98a0113526f..60806a1e923d 100644
--- a/tests/disas/winch/x64/v128_const/spilled.wat
+++ b/tests/disas/winch/x64/v128_const/spilled.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/v128_mixed_sig.wat b/tests/disas/winch/x64/v128_mixed_sig.wat
index e389d8b7aa30..954e4eeb8fff 100644
--- a/tests/disas/winch/x64/v128_mixed_sig.wat
+++ b/tests/disas/winch/x64/v128_mixed_sig.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x30, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x6d
diff --git a/tests/disas/winch/x64/v128_ops/and.wat b/tests/disas/winch/x64/v128_ops/and.wat
index fc89379a74ef..af392911fa32 100644
--- a/tests/disas/winch/x64/v128_ops/and.wat
+++ b/tests/disas/winch/x64/v128_ops/and.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/v128_ops/andnot.wat b/tests/disas/winch/x64/v128_ops/andnot.wat
index 7399d792a7f3..957c168aabc2 100644
--- a/tests/disas/winch/x64/v128_ops/andnot.wat
+++ b/tests/disas/winch/x64/v128_ops/andnot.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/v128_ops/any_true.wat b/tests/disas/winch/x64/v128_ops/any_true.wat
index 24931796ab44..3fe7a8c44e57 100644
--- a/tests/disas/winch/x64/v128_ops/any_true.wat
+++ b/tests/disas/winch/x64/v128_ops/any_true.wat
@@ -11,7 +11,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x4d
diff --git a/tests/disas/winch/x64/v128_ops/bitselect.wat b/tests/disas/winch/x64/v128_ops/bitselect.wat
index 980fa7aeda59..6a7c8b7e3352 100644
--- a/tests/disas/winch/x64/v128_ops/bitselect.wat
+++ b/tests/disas/winch/x64/v128_ops/bitselect.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x61
diff --git a/tests/disas/winch/x64/v128_ops/load_lane/load16.wat b/tests/disas/winch/x64/v128_ops/load_lane/load16.wat
index 868ae7ef93d2..4bbb8ed55d0d 100644
--- a/tests/disas/winch/x64/v128_ops/load_lane/load16.wat
+++ b/tests/disas/winch/x64/v128_ops/load_lane/load16.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/v128_ops/load_lane/load32.wat b/tests/disas/winch/x64/v128_ops/load_lane/load32.wat
index a3c5d244a719..0a490e559045 100644
--- a/tests/disas/winch/x64/v128_ops/load_lane/load32.wat
+++ b/tests/disas/winch/x64/v128_ops/load_lane/load32.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/v128_ops/load_lane/load64.wat b/tests/disas/winch/x64/v128_ops/load_lane/load64.wat
index 93086310b900..567db475ee62 100644
--- a/tests/disas/winch/x64/v128_ops/load_lane/load64.wat
+++ b/tests/disas/winch/x64/v128_ops/load_lane/load64.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x57
diff --git a/tests/disas/winch/x64/v128_ops/load_lane/load8.wat b/tests/disas/winch/x64/v128_ops/load_lane/load8.wat
index f5119c55630d..08796c61fe44 100644
--- a/tests/disas/winch/x64/v128_ops/load_lane/load8.wat
+++ b/tests/disas/winch/x64/v128_ops/load_lane/load8.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x58
diff --git a/tests/disas/winch/x64/v128_ops/load_lane/zero_max_memory.wat b/tests/disas/winch/x64/v128_ops/load_lane/zero_max_memory.wat
index 697e8b76b4f2..ace258a79535 100644
--- a/tests/disas/winch/x64/v128_ops/load_lane/zero_max_memory.wat
+++ b/tests/disas/winch/x64/v128_ops/load_lane/zero_max_memory.wat
@@ -20,7 +20,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x67
diff --git a/tests/disas/winch/x64/v128_ops/not.wat b/tests/disas/winch/x64/v128_ops/not.wat
index cd75bc835c6b..633226965f5e 100644
--- a/tests/disas/winch/x64/v128_ops/not.wat
+++ b/tests/disas/winch/x64/v128_ops/not.wat
@@ -9,7 +9,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x49
diff --git a/tests/disas/winch/x64/v128_ops/or.wat b/tests/disas/winch/x64/v128_ops/or.wat
index de1a32165c29..2ee74f198bbc 100644
--- a/tests/disas/winch/x64/v128_ops/or.wat
+++ b/tests/disas/winch/x64/v128_ops/or.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/winch/x64/v128_ops/store_lane/store16.wat b/tests/disas/winch/x64/v128_ops/store_lane/store16.wat
index 64a778736ad8..88e2a0c3fbf3 100644
--- a/tests/disas/winch/x64/v128_ops/store_lane/store16.wat
+++ b/tests/disas/winch/x64/v128_ops/store_lane/store16.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/v128_ops/store_lane/store32.wat b/tests/disas/winch/x64/v128_ops/store_lane/store32.wat
index 5d0de5d2f9d8..e253a90f755f 100644
--- a/tests/disas/winch/x64/v128_ops/store_lane/store32.wat
+++ b/tests/disas/winch/x64/v128_ops/store_lane/store32.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/v128_ops/store_lane/store64.wat b/tests/disas/winch/x64/v128_ops/store_lane/store64.wat
index 88f6b69db736..a4aa3f28ae5f 100644
--- a/tests/disas/winch/x64/v128_ops/store_lane/store64.wat
+++ b/tests/disas/winch/x64/v128_ops/store_lane/store64.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/v128_ops/store_lane/store8.wat b/tests/disas/winch/x64/v128_ops/store_lane/store8.wat
index 8417c548459e..a6d95d29c313 100644
--- a/tests/disas/winch/x64/v128_ops/store_lane/store8.wat
+++ b/tests/disas/winch/x64/v128_ops/store_lane/store8.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x54
diff --git a/tests/disas/winch/x64/v128_ops/xor.wat b/tests/disas/winch/x64/v128_ops/xor.wat
index e6ae442d068c..86ff13edbd79 100644
--- a/tests/disas/winch/x64/v128_ops/xor.wat
+++ b/tests/disas/winch/x64/v128_ops/xor.wat
@@ -12,7 +12,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r11
-;;       movq    0x18(%r11), %r11
+;;       movq    0x20(%r11), %r11
 ;;       addq    $0x10, %r11
 ;;       cmpq    %rsp, %r11
 ;;       ja      0x50
diff --git a/tests/disas/x64-entry-trampoline.wat b/tests/disas/x64-entry-trampoline.wat
index ce6de4a91b92..9d23ccbe1ddb 100644
--- a/tests/disas/x64-entry-trampoline.wat
+++ b/tests/disas/x64-entry-trampoline.wat
@@ -15,11 +15,11 @@
 ;;       movq    %r15, 0x30(%rsp)
 ;;       movq    %rbp, %rcx
 ;;       movq    8(%rdi), %r8
-;;       movq    %rcx, 0x48(%r8)
+;;       movq    %rcx, 0x50(%r8)
 ;;       movq    %rsp, %rcx
-;;       movq    %rcx, 0x40(%r8)
+;;       movq    %rcx, 0x48(%r8)
 ;;       leaq    0x34(%rip), %rcx
-;;       movq    %rcx, 0x50(%r8)
+;;       movq    %rcx, 0x58(%r8)
 ;;       movq    %r8, (%rsp)
 ;;       callq   0
 ;;       ├─╼ exception frame offset: SP = FP - 0x40
@@ -35,7 +35,7 @@
 ;;       popq    %rbp
 ;;       retq
 ;;   77: movq    (%rsp), %r8
-;;   7b: movq    $1, 0x88(%r8)
+;;   7b: movq    $1, 0x90(%r8)
 ;;   86: xorl    %eax, %eax
 ;;   88: movq    0x10(%rsp), %rbx
 ;;   8d: movq    0x18(%rsp), %r12
diff --git a/tests/disas/x64-simd-round-without-sse41.wat b/tests/disas/x64-simd-round-without-sse41.wat
index fd2b51c303ee..7121d3ff445a 100644
--- a/tests/disas/x64-simd-round-without-sse41.wat
+++ b/tests/disas/x64-simd-round-without-sse41.wat
@@ -13,10 +13,10 @@
 )
 ;; function u0:0(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f32) -> f32 tail
 ;;     fn0 = colocated u805306368:28 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -46,10 +46,10 @@
 ;;
 ;; function u0:1(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f32) -> f32 tail
 ;;     fn0 = colocated u805306368:30 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -79,10 +79,10 @@
 ;;
 ;; function u0:2(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f32) -> f32 tail
 ;;     fn0 = colocated u805306368:32 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -112,10 +112,10 @@
 ;;
 ;; function u0:3(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f32) -> f32 tail
 ;;     fn0 = colocated u805306368:34 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -145,10 +145,10 @@
 ;;
 ;; function u0:4(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f64) -> f64 tail
 ;;     fn0 = colocated u805306368:29 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -172,10 +172,10 @@
 ;;
 ;; function u0:5(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f64) -> f64 tail
 ;;     fn0 = colocated u805306368:31 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -199,10 +199,10 @@
 ;;
 ;; function u0:6(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f64) -> f64 tail
 ;;     fn0 = colocated u805306368:33 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -226,10 +226,10 @@
 ;;
 ;; function u0:7(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     sig0 = (i64 vmctx, f64) -> f64 tail
 ;;     fn0 = colocated u805306368:35 sig0
 ;;     const0 = 0x00000000000000000000000000000000
@@ -253,10 +253,10 @@
 ;;
 ;; function u0:8(i64 vmctx, i64, i8x16) -> i8x16 tail {
 ;;     region0 = 8 "VMContext+0x8"
-;;     region1 = 67108888 "VMStoreContext+0x18"
+;;     region1 = 67108896 "VMStoreContext+0x20"
 ;;     gv0 = vmctx
 ;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
-;;     gv2 = load.i64 notrap aligned region1 gv1+24
+;;     gv2 = load.i64 notrap aligned region1 gv1+32
 ;;     const0 = 0x00000000000000000000000000000000
 ;;     stack_limit = gv2
 ;;
diff --git a/tests/disas/x64/call-indirect-with-gc.wat b/tests/disas/x64/call-indirect-with-gc.wat
index d053980e321a..bb3a240ebee3 100644
--- a/tests/disas/x64/call-indirect-with-gc.wat
+++ b/tests/disas/x64/call-indirect-with-gc.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x20, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x9d
diff --git a/tests/disas/x64/call-indirect-without-gc.wat b/tests/disas/x64/call-indirect-without-gc.wat
index 98c559ff2b4b..eb5982051a30 100644
--- a/tests/disas/x64/call-indirect-without-gc.wat
+++ b/tests/disas/x64/call-indirect-without-gc.wat
@@ -13,7 +13,7 @@
 ;;       pushq   %rbp
 ;;       movq    %rsp, %rbp
 ;;       movq    8(%rdi), %r10
-;;       movq    0x18(%r10), %r10
+;;       movq    0x20(%r10), %r10
 ;;       addq    $0x20, %r10
 ;;       cmpq    %rsp, %r10
 ;;       ja      0x9d