feat: add no_std compatibility verification package

Signed-off-by: Ho Kim <ho.kim@ulagbulag.io>

Author: HoKim98

.github/workflows/main.yml

@@ -459,6 +459,7 @@ jobs:
     - uses: ./.github/actions/install-rust
     - run: cargo test -p wasmtime-internal-fiber --no-default-features
     - run: cargo test -p cranelift-tools --test logged-filetests
+    - run: CARGO_PROFILE_DEV_PANIC=abort cargo build -p nostd-tests
 
   # Check that Clippy lints are passing.
   clippy:

Cargo.lock

@@ -160,6 +160,7 @@ members = [
   "crates/c-api/artifact",
   "crates/environ/fuzz",
   "crates/misc/component-async-tests",
+  "crates/misc/nostd-tests",
   "crates/test-programs",
   "crates/wasi-preview1-component-adapter",
   "crates/wasi-preview1-component-adapter/verify",
@@ -319,6 +320,7 @@ wasmtime-test-util = { path = "crates/test-util" }
 byte-array-literals = { path = "crates/wasi-preview1-component-adapter/byte-array-literals" }
 pulley-interpreter-fuzz = { path = 'pulley/fuzz' }
 component-async-tests = { path = "crates/misc/component-async-tests" }
+nostd-tests = { path = "crates/misc/nostd-tests" }
 
 # Bytecode Alliance maintained dependencies:
 # ---------------------------

Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "nostd-tests"
+authors = ["The Wasmtime Project Developers"]
+license = "Apache-2.0 WITH LLVM-exception"
+version = "0.0.0"
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[lints]
+workspace = true
+
+[dependencies]
+wasmtime = { workspace = true, features = ["async", "runtime"] }

crates/misc/nostd-tests/Cargo.toml

@@ -0,0 +1,50 @@
+This is a verification package for the CI (Continuous Integration) of
+crates that support `#![no_std]` environments. It works by statically
+linking packages that need to be checked for `std` library dependencies
+and detecting whether duplicate implementations of `panic_impl` exist.
+
+Since `panic_impl` is provided by the std package and multiple
+implementations cannot coexist, the compilation will fail with a duplicate
+implementation error if even a single package depends on std. If this
+package builds successfully with the std feature disabled, it guarantees
+that the given feature set supports the `#![no_std]` environment.
+
+Another way to verify this is by checking if the successfully compiled
+binary is statically linked. In environments like Linux, you can use the
+`ldd` command to ensure that no dynamic libraries are linked.
+
+## Key Technical Terms Used
+
+- `#![no_std]`: The attribute used to indicate the crate does not link the
+  standard library.
+- Static Linking: Combining all necessary libraries into the executable at
+  compile time.
+- `panic_impl`: The language item used to define the strategy for handling
+  panics.
+- Feature Set: The specific combination of Cargo features enabled during
+  compilation.
+
+## Why this works
+
+In Rust, the `std` crate provides a default panic handler. If you are
+building for a bare-metal or restricted environment (no_std), you must
+provide your own `#[panic_handler]`. By attempting to link both, you
+create a conflict. This "conflict by design" is a simple way to use the
+compiler as a gatekeeper to ensure no hidden std dependencies creep into
+your embedded or kernel-level code.
+
+## How to use
+
+Since unwinding panics are not supported in a `#![no_std]` environment and
+we don't need to worry about panic behavior, you should disable them by
+setting the environment variable `CARGO_PROFILE_DEV_PANIC=abort`.
+
+```bash
+# Compile
+export CARGO_PROFILE_DEV_PANIC='abort'
+cargo build -p nostd-tests
+
+# Validate
+ldd ./target/debug/libnostd_tests.so |
+    grep -Posq '^\tstatically linked$'
+```

crates/misc/nostd-tests/README.md

@@ -0,0 +1,45 @@
+//! This is a verification package for the CI (Continuous Integration) of
+//! crates that support `#![no_std]` environments. It works by statically
+//! linking packages that need to be checked for `std` library dependencies
+//! and detecting whether duplicate implementations of `panic_impl` exist.
+
+#![deny(clippy::all)]
+#![deny(missing_docs)]
+#![no_std]
+
+// Below is a list of crates that support the `#![no_std]` environment.
+// Declaring a package as "extern crate" ensures that the package is
+// statically linked during the build phase. This step also detects `std`
+// dependencies.
+extern crate wasmtime as _;
+
+/// Boilerplate implementation required for cases where there is no `std`
+/// dependency, such as embedded environments.
+mod no_std {
+    #[global_allocator]
+    static GLOBAL_ALLOC: DummyAlloc = DummyAlloc;
+
+    use core::{
+        alloc::{GlobalAlloc, Layout},
+        panic,
+    };
+
+    /// A no-op allocator for providing functionality `#[global_allocator]`.
+    struct DummyAlloc;
+
+    unsafe impl GlobalAlloc for DummyAlloc {
+        unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
+            unreachable!()
+        }
+
+        unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+            unreachable!()
+        }
+    }
+
+    /// A no-op panic handler for providing functionality `#[panic_handler]`.
+    #[panic_handler]
+    fn panic_handler(_info: &panic::PanicInfo) -> ! {
+        loop {}
+    }
+}