Use a runtime setting for debug checks (#11604)

* Update test expectations

* Use a runtime setting for debug checks

This commit updates Wasmtime's trampoline compilation to insert debug
checks when a runtime setting is configured instead of the compile-time
`debug_assertions` setting. Using a compile-time variable can be
confusing because it means that different builds of Wasmtime can produce
different output when the builds only differ in optimization settings.
An example of this is that `cargo test --test disas --release` is broken
before this PR. By using a runtime setting this won't be enabled as
often but we'll still enable it for all `wast` testing, for example.

* Fix a test with Winch

Author: alexcrichton

crates/cranelift/src/builder.rs

@@ -18,6 +18,7 @@ use wasmtime_environ::{CacheStore, CompilerBuilder, Setting, Tunables};
 struct Builder {
     tunables: Option<Tunables>,
     inner: IsaBuilder<CodegenResult<OwnedTargetIsa>>,
+    emit_debug_checks: bool,
     linkopts: LinkOptions,
     cache_store: Option<Arc<dyn CacheStore>>,
     clif_dir: Option<path::PathBuf>,
@@ -45,6 +46,7 @@ pub fn builder(triple: Option<Triple>) -> Result<Box<dyn CompilerBuilder>> {
         cache_store: None,
         clif_dir: None,
         wmemcheck: false,
+        emit_debug_checks: false,
     }))
 }
 
@@ -81,6 +83,9 @@ impl CompilerBuilder for Builder {
             "wasmtime_inlining_sum_size_threshold" => {
                 self.tunables.as_mut().unwrap().inlining_sum_size_threshold = value.parse()?;
             }
+            "wasmtime_debug_checks" => {
+                self.emit_debug_checks = true;
+            }
             _ => {
                 self.inner.set(name, value)?;
             }
@@ -106,6 +111,7 @@ impl CompilerBuilder for Builder {
                 .clone(),
             isa,
             self.cache_store.clone(),
+            self.emit_debug_checks,
             self.linkopts.clone(),
             self.clif_dir.clone(),
             self.wmemcheck,

crates/cranelift/src/compiler.rs

@@ -87,6 +87,7 @@ pub struct Compiler {
     tunables: Tunables,
     contexts: Mutex<Vec<CompilerContext>>,
     isa: OwnedTargetIsa,
+    emit_debug_checks: bool,
     linkopts: LinkOptions,
     cache_store: Option<Arc<dyn CacheStore>>,
     clif_dir: Option<path::PathBuf>,
@@ -127,6 +128,7 @@ impl Compiler {
         tunables: Tunables,
         isa: OwnedTargetIsa,
         cache_store: Option<Arc<dyn CacheStore>>,
+        emit_debug_checks: bool,
         linkopts: LinkOptions,
         clif_dir: Option<path::PathBuf>,
         wmemcheck: bool,
@@ -136,6 +138,7 @@ impl Compiler {
             contexts: Default::default(),
             tunables,
             isa,
+            emit_debug_checks,
             linkopts,
             cache_store,
             clif_dir,
@@ -392,7 +395,7 @@ impl wasmtime_environ::Compiler for Compiler {
         //
         // Assert that we were really given a core Wasm vmctx, since that's
         // what we are assuming with our offsets below.
-        debug_assert_vmctx_kind(isa, &mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
+        self.debug_assert_vmctx_kind(&mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
         let offsets = VMOffsets::new(isa.pointer_bytes(), &translation.module);
         let vm_store_context_offset = offsets.ptr.vmctx_store_context();
         save_last_wasm_entry_fp(
@@ -456,8 +459,7 @@ impl wasmtime_environ::Compiler for Compiler {
         //
         // Assert that the caller vmctx really is a core Wasm vmctx, since
         // that's what we are assuming with our offsets below.
-        debug_assert_vmctx_kind(
-            isa,
+        self.debug_assert_vmctx_kind(
             &mut builder,
             caller_vmctx,
             wasmtime_environ::VMCONTEXT_MAGIC,
@@ -707,7 +709,7 @@ impl wasmtime_environ::Compiler for Compiler {
         // Debug-assert that this is the right kind of vmctx, and then
         // additionally perform the "routine of the exit trampoline" of saving
         // fp/pc/etc.
-        debug_assert_vmctx_kind(isa, &mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
+        self.debug_assert_vmctx_kind(&mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
         let vm_store_context = builder.ins().load(
             pointer_type,
             MemFlags::trusted(),
@@ -1034,7 +1036,7 @@ impl Compiler {
         values_vec_capacity: Value,
     ) {
         debug_assert_eq!(types.len(), values.len());
-        debug_assert_enough_capacity_for_length(builder, types.len(), values_vec_capacity);
+        self.debug_assert_enough_capacity_for_length(builder, types.len(), values_vec_capacity);
 
         // Note that loads and stores are unconditionally done in the
         // little-endian format rather than the host's native-endianness,
@@ -1074,7 +1076,7 @@ impl Compiler {
         let isa = &*self.isa;
         let value_size = mem::size_of::<u128>();
 
-        debug_assert_enough_capacity_for_length(builder, types.len(), values_vec_capacity);
+        self.debug_assert_enough_capacity_for_length(builder, types.len(), values_vec_capacity);
 
         // Note that this is little-endian like `store_values_to_array` above,
         // see notes there for more information.
@@ -1197,6 +1199,46 @@ impl Compiler {
     pub fn tunables(&self) -> &Tunables {
         &self.tunables
     }
+
+    fn debug_assert_enough_capacity_for_length(
+        &self,
+        builder: &mut FunctionBuilder,
+        length: usize,
+        capacity: ir::Value,
+    ) {
+        if !self.emit_debug_checks {
+            return;
+        }
+        let enough_capacity = builder.ins().icmp_imm(
+            ir::condcodes::IntCC::UnsignedGreaterThanOrEqual,
+            capacity,
+            ir::immediates::Imm64::new(length.try_into().unwrap()),
+        );
+        builder.ins().trapz(enough_capacity, TRAP_INTERNAL_ASSERT);
+    }
+
+    fn debug_assert_vmctx_kind(
+        &self,
+        builder: &mut FunctionBuilder,
+        vmctx: ir::Value,
+        expected_vmctx_magic: u32,
+    ) {
+        if !self.emit_debug_checks {
+            return;
+        }
+        let magic = builder.ins().load(
+            ir::types::I32,
+            MemFlags::trusted().with_endianness(self.isa.endianness()),
+            vmctx,
+            0,
+        );
+        let is_expected_vmctx = builder.ins().icmp_imm(
+            ir::condcodes::IntCC::Equal,
+            magic,
+            i64::from(expected_vmctx_magic),
+        );
+        builder.ins().trapz(is_expected_vmctx, TRAP_INTERNAL_ASSERT);
+    }
 }
 
 struct FunctionCompiler<'a> {
@@ -1381,43 +1423,6 @@ fn declare_and_call(
     builder.ins().call(callee, &args)
 }
 
-fn debug_assert_enough_capacity_for_length(
-    builder: &mut FunctionBuilder,
-    length: usize,
-    capacity: ir::Value,
-) {
-    if cfg!(debug_assertions) {
-        let enough_capacity = builder.ins().icmp_imm(
-            ir::condcodes::IntCC::UnsignedGreaterThanOrEqual,
-            capacity,
-            ir::immediates::Imm64::new(length.try_into().unwrap()),
-        );
-        builder.ins().trapz(enough_capacity, TRAP_INTERNAL_ASSERT);
-    }
-}
-
-fn debug_assert_vmctx_kind(
-    isa: &dyn TargetIsa,
-    builder: &mut FunctionBuilder,
-    vmctx: ir::Value,
-    expected_vmctx_magic: u32,
-) {
-    if cfg!(debug_assertions) {
-        let magic = builder.ins().load(
-            ir::types::I32,
-            MemFlags::trusted().with_endianness(isa.endianness()),
-            vmctx,
-            0,
-        );
-        let is_expected_vmctx = builder.ins().icmp_imm(
-            ir::condcodes::IntCC::Equal,
-            magic,
-            i64::from(expected_vmctx_magic),
-        );
-        builder.ins().trapz(is_expected_vmctx, TRAP_INTERNAL_ASSERT);
-    }
-}
-
 fn save_last_wasm_entry_fp(
     builder: &mut FunctionBuilder,
     pointer_type: ir::Type,

crates/cranelift/src/compiler/component.rs

@@ -1060,7 +1060,7 @@ impl<'a> TrampolineCompiler<'a> {
                 vmctx,
                 i32::try_from(self.offsets.resource_destructor(index)).unwrap(),
             );
-            if cfg!(debug_assertions) {
+            if self.compiler.emit_debug_checks {
                 self.builder
                     .ins()
                     .trapz(dtor_func_ref, TRAP_INTERNAL_ASSERT);
@@ -1304,8 +1304,7 @@ impl ComponentCompiler for Compiler {
             // always hold.
             let vmctx = c.builder.block_params(c.block0)[0];
             let pointer_type = self.isa.pointer_type();
-            super::debug_assert_vmctx_kind(
-                &*self.isa,
+            self.debug_assert_vmctx_kind(
                 &mut c.builder,
                 vmctx,
                 wasmtime_environ::component::VMCOMPONENT_MAGIC,

crates/misc/component-async-tests/tests/scenario/util.rs

@@ -31,6 +31,7 @@ pub fn config() -> Config {
         config.signals_based_traps(false);
     } else {
         config.cranelift_debug_verifier(true);
+        config.cranelift_wasmtime_debug_checks(true);
     }
     config.wasm_component_model(true);
     config.wasm_component_model_async(true);

crates/wasmtime/src/config.rs

@@ -1269,6 +1269,15 @@ impl Config {
         self
     }
 
+    /// Configures whether extra debug checks are inserted into
+    /// Wasmtime-generated code by Cranelift.
+    ///
+    /// The default value for this is `false`
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn cranelift_wasmtime_debug_checks(&mut self, enable: bool) -> &mut Self {
+        unsafe { self.cranelift_flag_set("wasmtime_debug_checks", &enable.to_string()) }
+    }
+
     /// Configures the Cranelift code generator optimization level.
     ///
     /// When the Cranelift code generator is used you can configure the

tests/disas/aarch64-entry-trampoline.wat

@@ -7,20 +7,12 @@
 ;; wasm[0]::array_to_wasm_trampoline[0]:
 ;;       stp     x29, x30, [sp, #-0x10]!
 ;;       mov     x29, sp
-;;       ldr     w10, [x0]
-;;       mov     w9, #0x6f63
-;;       movk    w9, #0x6572, lsl #16
-;;       cmp     w10, w9
-;;       cset    x13, eq
-;;       uxtb    w11, w13
-;;       cbz     x11, #0x58
-;;   34: ldr     x12, [x0, #8]
-;;       mov     x13, x29
-;;       str     x13, [x12, #0x38]
+;;       ldr     x5, [x0, #8]
+;;       mov     x6, x29
+;;       str     x6, [x5, #0x38]
 ;;       mov     x2, x0
 ;;       mov     x3, x1
 ;;       bl      #0
-;;   4c: mov     w0, #1
+;;   30: mov     w0, #1
 ;;       ldp     x29, x30, [sp], #0x10
 ;;       ret
-;;   58: .byte   0x1f, 0xc1, 0x00, 0x00

tests/disas/epoch-interruption-x86.wat

@@ -28,12 +28,12 @@
 ;;       jae     0x64
 ;;       jmp     0x46
 ;;   57: movq    %r15, %rdi
-;;       callq   0xf2
+;;       callq   0xe1
 ;;       jmp     0x46
 ;;   64: movq    8(%r13), %rax
 ;;       cmpq    %rax, %r11
 ;;       jb      0x46
 ;;   71: movq    %r15, %rdi
-;;       callq   0xf2
+;;       callq   0xe1
 ;;       jmp     0x46
 ;;   7e: ud2

tests/disas/exceptions.wat

@@ -33,14 +33,14 @@
 ;;       movq    %rdi, %r12
 ;;       movq    %rcx, %r13
 ;;       movq    %rdx, %r15
-;;       callq   0x3c9
+;;       callq   0x360
 ;;       movq    %rax, %r14
 ;;       movl    $0x4000000, %esi
 ;;       movl    $3, %edx
 ;;       movl    $0x30, %ecx
 ;;       movl    $8, %r8d
 ;;       movq    %r12, %rdi
-;;       callq   0x355
+;;       callq   0x2fd
 ;;       movq    8(%r12), %r8
 ;;       movq    0x18(%r8), %r8
 ;;       movl    %eax, %r9d
@@ -54,7 +54,7 @@
 ;;       movq    %rax, %rsi
 ;;       movq    %r12, %rdi
 ;;       movq    %r12, (%rsp)
-;;       callq   0x405
+;;       callq   0x38c
 ;;       ud2
 ;;       ud2
 ;;

tests/disas/gc/struct-new-stack-map.wat

@@ -32,7 +32,7 @@
 ;;       movl    $0x28, %ecx
 ;;       movl    $8, %r8d
 ;;       movq    %rdi, %r13
-;;       callq   0x161
+;;       callq   0x14b
 ;;       movq    8(%r13), %r8
 ;;       ╰─╼ stack_map: frame_size=64, frame_offsets=[0]
 ;;       movq    0x18(%r8), %r8

tests/disas/pulley-entry-trampoline.wat

@@ -6,13 +6,10 @@
 
 ;; wasm[0]::array_to_wasm_trampoline[0]:
 ;;       push_frame
-;;       xload32le_o32 x6, x0, 0
-;;       br_if_xneq32_i32 x6, 1701998435, 0x25    // target = 0x30
-;;   15: xload64le_o32 x7, x0, 8
-;;       xmov_fp x8
-;;       xstore64le_o32 x7, 56, x8
-;;       call -0x27    // target = 0x0
+;;       xload64le_o32 x5, x0, 8
+;;       xmov_fp x6
+;;       xstore64le_o32 x5, 56, x6
+;;       call -0x16    // target = 0x0
 ;;       xone x0
 ;;       pop_frame
 ;;       ret
-;;   30: trap