fix(no_std)!: respect std feature when target is windows/unix (#11152)

* fix(no_std)!: respect `std` feature when target is windows/unix

BREAKING CHANGE: the fix disables standard features for dependents that use wasmtime with `default-features = false`.

* fix cargo check workflow

* Don't require `std` feature for invalid faults

Fill out the `compile_error!` to avoid failing a build.

* addressing review comments

* add `std` to `stack-switching` feature

* remove `rustix/mm` from `std` feature dependencies

* add `std` feature flag to `jit-icache-coherence`
- The `std` feature gates the use of standard library for icache coherence in Windows; otherwise, defaults to the `libc` implementation.
- The `std` feature of Wasmtime now depends on the `wasmtime-jit-icache-coherence/std`

* Only include jit-icache-coherence on `std` builds

prtest:full

* Fix some idiom issues

* More idiom issues

* Require `std` for loading native code

---------

Co-authored-by: Alex Crichton <[email protected]>

Author: salmans

crates/jit-icache-coherence/src/lib.rs

@@ -74,9 +74,7 @@
 //!
 //! [ARM Community - Caches and Self-Modifying Code]: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/caches-and-self-modifying-code
 
-#![no_std]
-
-use core::ffi::c_void;
+use std::ffi::c_void;
 
 cfg_if::cfg_if! {
     if #[cfg(target_os = "windows")] {

crates/jit-icache-coherence/src/libc.rs

@@ -1,7 +1,5 @@
-use core::ffi::c_void;
+use std::ffi::c_void;
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-extern crate std;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub use std::io::Result;
 
@@ -13,7 +11,6 @@ pub use anyhow::Result;
     any(target_os = "linux", target_os = "android")
 ))]
 mod details {
-    extern crate std;
 
     use super::*;
     use libc::{EINVAL, EPERM, syscall};
@@ -107,15 +104,13 @@ mod details {
 fn riscv_flush_icache(start: u64, end: u64) -> Result<()> {
     cfg_if::cfg_if! {
         if #[cfg(feature = "one-core")] {
-            use core::arch::asm;
+            use std::arch::asm;
             let _ = (start, end);
             unsafe {
                 asm!("fence.i");
             };
             Ok(())
         } else {
-            extern crate std;
-
             #[expect(non_upper_case_globals, reason = "matching C style")]
             match unsafe {
                 libc::syscall(

crates/jit-icache-coherence/src/miri.rs

@@ -1,5 +1,5 @@
 pub use anyhow::Result;
-use core::ffi::c_void;
+use std::ffi::c_void;
 
 pub(crate) fn pipeline_flush_mt() -> Result<()> {
     Ok(())

crates/jit-icache-coherence/src/win.rs

@@ -1,5 +1,3 @@
-extern crate std;
-
 use std::ffi::c_void;
 use std::io::Error;
 use windows_sys::Win32::System::Diagnostics::Debug::FlushInstructionCache;

crates/wasmtime/Cargo.toml

@@ -254,10 +254,7 @@ runtime = [
   "dep:wasmtime-slab",
   "dep:wasmtime-versioned-export-macros",
   "dep:windows-sys",
-  "dep:rustix",
-  "rustix/mm",
   "pulley-interpreter/interp",
-  "dep:wasmtime-jit-icache-coherence",
   "dep:wasmtime-unwinder",
 ]
 
@@ -309,6 +306,7 @@ threads = [
 
 stack-switching = [
   "runtime",
+  "std",
   "wasmtime-environ/stack-switching",
   "wasmtime-cranelift?/stack-switching",
   "wasmtime-winch?/stack-switching",
@@ -333,6 +331,8 @@ std = [
   'pulley-interpreter/std',
   'wasmtime-math/std',
   'addr2line?/std',
+  "dep:rustix",
+  "wasmtime-jit-icache-coherence",
 ]
 
 # Enables support for the `Store::call_hook` API which enables injecting custom

crates/wasmtime/src/lib.rs

@@ -295,7 +295,7 @@
 #![expect(clippy::allow_attributes_without_reason, reason = "crate not migrated")]
 #![expect(unsafe_op_in_unsafe_fn, reason = "crate isn't migrated yet")]
 
-#[cfg(any(feature = "std", unix, windows))]
+#[cfg(feature = "std")]
 #[macro_use]
 extern crate std;
 extern crate alloc;

crates/wasmtime/src/runtime.rs

@@ -60,6 +60,8 @@ pub mod component;
 cfg_if::cfg_if! {
     if #[cfg(miri)] {
         // no extensions on miri
+    } else if #[cfg(not(feature = "std"))] {
+        // no extensions on no-std
     } else if #[cfg(unix)] {
         pub mod unix;
     } else if #[cfg(windows)] {

crates/wasmtime/src/runtime/code_memory.rs

@@ -319,8 +319,15 @@ impl CodeMemory {
                     if !self.mmap.supports_virtual_memory() {
                         bail!("this target requires virtual memory to be enabled");
                     }
+                    if !cfg!(feature = "std") {
+                        bail!(
+                            "with the `std` feature disabled at compile time \
+                             there must be a custom implementation of publishing \
+                             code memory"
+                        );
+                    }
 
-                    #[cfg(has_virtual_memory)]
+                    #[cfg(all(has_virtual_memory, feature = "std"))]
                     {
                         let text = self.text();
 

crates/wasmtime/src/runtime/fiber.rs

@@ -343,9 +343,7 @@ impl<T> StoreContextMut<'_, T> {
         self,
         f: impl FnOnce(StoreContextMut<'_, T>) -> Pin<Box<dyn Future<Output = R> + Send + '_>>,
     ) -> Result<R> {
-        BlockingContext::with(self.0, |store, cx| {
-            cx.block_on(f(StoreContextMut(store)).as_mut())
-        })
+        self.with_blocking(|store, cx| cx.block_on(f(store).as_mut()))
     }
 
     /// Creates a `BlockingContext` suitable for blocking on futures or

crates/wasmtime/src/runtime/store.rs

@@ -1847,7 +1847,7 @@ impl StoreOpaque {
         }
 
         cfg_if::cfg_if! {
-            if #[cfg(any(feature = "std", unix, windows))] {
+            if #[cfg(feature = "std")] {
                 // With the standard library a rich error can be printed here
                 // to stderr and the native abort path is used.
                 eprintln!(
@@ -1879,14 +1879,23 @@ at https://bytecodealliance.org/security.
                 let _ = pc;
                 panic!("invalid fault");
             } else {
-                // Without `std` and with `panic = "unwind"` there's no way to
-                // abort the process portably, so flag a compile time error.
-                //
-                // NB: if this becomes a problem in the future one option would
-                // be to extend the `capi.rs` module for no_std platforms, but
-                // it remains yet to be seen at this time if this is hit much.
-                compile_error!("either `std` or `panic=abort` must be enabled");
-                None
+                // Without `std` and with `panic = "unwind"` there's no
+                // dedicated API to abort the process portably, so manufacture
+                // this with a double-panic.
+                let _ = pc;
+
+                struct PanicAgainOnDrop;
+
+                impl Drop for PanicAgainOnDrop {
+                    fn drop(&mut self) {
+                        panic!("panicking again to trigger a process abort");
+                    }
+
+                }
+
+                let _bomb = PanicAgainOnDrop;
+
+                panic!("invalid fault");
             }
         }
     }