feat: improve nightly feature detection, reorganize cargo features

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

CHANGELOG.md

@@ -11,11 +11,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added WebAssembly threads support, including atomic wait/notify and cross-store shared memory with `MemoryShared`.
 - Added new `Memory::data` and `Memory::data_mut` methods for direct access to linear memory.
-- Added several internal methods to support a future c-api crate
+- Added an experimental C API in `tinywasm-c-api`.
+- Added parse-time resource limits and configurable fuel checkpoints.
+- Added `nightly` to enable all supported nightly optimizations, with automatic compiler capability detection.
 
-### Removed
+### Breaking Changes
 
-- Removed `resume_with_time_budget`. Use `resume_with_fuel` and check application deadlines between resumes.
+- Renamed the `simd-x86` Cargo feature to `simd-intrinsics`.
+- Enabled `nightly` and `simd-intrinsics` by default. `full` is unchanged.
+- Removed `resume_with_time_budget`. Use `resume_with_fuel` and application-managed deadlines.
+- Stack limits now enforce `StackConfig::max_size` even when the allocation has spare capacity.
+- Changed public bytecode/module types and the `.twasm` format. Regenerate archives created with 0.11.0.
 
 ### Fixed
 

Cargo.lock

@@ -5,12 +5,12 @@
 ## Why `tinywasm`?
 
 - **Tiny**: Small by design, while still passing the full WebAssembly 3.0 core test suite.
-- **Portable**: Runs anywhere Rust can target, supports `no_std`, has minimal dependencies[^dependencies], and can itself compile to WebAssembly.
-- **Safe by default**: Written entirely in safe Rust[^unsafe].
+- **Portable**: Runs anywhere Rust can target, supports `no_std`, has minimal dependencies[^dependencies]
+- **Safe**: Written entirely in safe Rust[^unsafe].
 
 [^dependencies]: The two main external components are [`wasmparser`](https://crates.io/crates/wasmparser) for WebAssembly parsing and validation, and [`postcard`](https://crates.io/crates/postcard) for `.twasm` archives.
 
-[^unsafe]: The optional `simd-x86` feature is the only exception. It uses `unsafe` internally for selected x86 SIMD intrinsics.
+[^unsafe]: The `simd-intrinsics` feature uses `unsafe` internally for selected architecture-specific SIMD implementations.
 
 ## Installation
 
@@ -58,11 +58,10 @@ See the [examples](./examples) directory and [documentation](https://docs.rs/tin
 - **`canonicalize-nans`:** Uses a [canonical NaN](https://en.wikipedia.org/wiki/NaN#Canonical_NaN) for normalized NaN results.
 - **`debug`:** Derives `Debug` for runtime types. Enabled by default.
 - **`guest-debug`:** Exposes module-internal by-index inspection APIs (`*_by_index`).
-- **`nightly-tail-calls`:** Uses Rust's unstable explicit tail calls for interpreter dispatch. Requires nightly Rust (recommended for maximum performance).
-- **`nightly-rust-preserve-none`:** Uses Rust's experimental preserve-none ABI for x86_64 and 64-bit AArch64 tail-call handlers. Requires nightly Rust (recommended for maximum performance).
-- **`simd-x86`:** Enables x86-specific SIMD intrinsics and uses `unsafe` internally.
+- **`nightly`:** Enables all supported nightly-only optimizations. Enabled by default, with compiler capability detection and a stable fallback.
+- **`simd-intrinsics`:** Enables architecture-specific SIMD implementations where available, using `unsafe` internally. Enabled by default. Safe Wasm SIMD remains automatic.
 
-With default features disabled, `tinywasm` supports `no_std + alloc` and depends only on `libm`.
+With default features disabled, `tinywasm` supports `no_std + alloc` and its runtime depends only on `libm`.
 
 Use [`Engine`](https://docs.rs/tinywasm/latest/tinywasm/engine/struct.Engine.html) and [`engine::Config`](https://docs.rs/tinywasm/latest/tinywasm/engine/struct.Config.html) for non-default fuel accounting, stack sizing, or GC collection thresholds. A configured `ResourceLimiter` can allow, reject, or trap memory and table allocation or growth requests, and GC object allocations.
 

README.md

@@ -92,8 +92,11 @@ tinywasm-cli = { path = "../cli", features = ["tests", "wat"] }
 wasm-testsuite.workspace = true
 wat.workspace = true
 
+[build-dependencies]
+autocfg = "1.5"
+
 [features]
-default = ["full", "std"]
+default = ["full", "nightly", "simd-intrinsics", "std"]
 full = ["archive", "debug", "parallel-parser", "parser", "state", "validate"]
 
 log = ["dep:log", "tinywasm-parser?/log"]
@@ -129,16 +132,22 @@ debug = ["tinywasm-types/debug"]
 # expose module-internal by-index inspection APIs for non-exported entities (for testing and debugging)
 guest-debug = []
 
-# use explicit tail calls for interpreter dispatch (requires nightly Rust)
+# enable all supported nightly-only optimizations
+nightly = ["nightly-abort-immediate", "nightly-rust-preserve-none", "nightly-tail-calls"]
+
+# abort in place on internal invariant violations in release builds when supported by the compiler
+nightly-abort-immediate = []
+
+# use explicit tail calls for interpreter dispatch when supported by the compiler
 nightly-tail-calls = []
 
 # use the experimental preserve-none ABI for x86_64 and 64-bit AArch64 tail-call handlers
 nightly-rust-preserve-none = ["nightly-tail-calls"]
 
-# enable x86-specific SIMD intrinsics in Value128 (uses unsafe code)
+# enable architecture-specific SIMD intrinsics in Value128 (uses unsafe code internally)
 # note: for x86 backend selection, compile with x86-64-v3 target features
 # (for example: `RUSTFLAGS="-C target-cpu=x86-64-v3"`)
-simd-x86 = []
+simd-intrinsics = []
 
 [lints]
 workspace = true

crates/tinywasm/Cargo.toml

@@ -1,11 +1,41 @@
 use std::env;
 
+const TAIL_CALLS_PROBE: &str = r#"
+#![no_std]
+#![allow(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+#[inline(never)]
+pub fn callee(value: u32) -> u32 { value }
+pub fn caller(value: u32) -> u32 { become callee(value); }
+"#;
+
+const PRESERVE_NONE_PROBE: &str = r#"
+#![no_std]
+#![allow(incomplete_features)]
+#![feature(explicit_tail_calls, rust_preserve_none_cc)]
+
+#[inline(never)]
+pub extern "rust-preserve-none" fn callee(value: u32) -> u32 { value }
+pub extern "rust-preserve-none" fn caller(value: u32) -> u32 { become callee(value); }
+"#;
+
+const ABORT_IMMEDIATE_PROBE: &str = r#"
+#![no_std]
+#![feature(abort_immediate)]
+
+pub fn trap() -> ! { core::process::abort_immediate() }
+"#;
+
 fn main() {
     println!("cargo::rerun-if-changed=build.rs");
-    println!(
-        "cargo::rustc-check-cfg=cfg(tail_abi, values(\"Rust\", \"C-unwind\", \"sysv64-unwind\", \"rust-preserve-none\"))"
-    );
-    println!("cargo::rustc-check-cfg=cfg(simd_backend, values(\"generic\", \"wasm\", \"x86\"))");
+    println!("cargo::rerun-if-env-changed=RUSTC_BOOTSTRAP");
+    configure_simd();
+    configure_nightly();
+}
+
+fn configure_simd() {
+    println!("cargo::rustc-check-cfg=cfg(tw_simd_backend, values(\"generic\", \"wasm\", \"x86\"))");
 
     let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("Cargo target architecture");
     let features = env::var("CARGO_CFG_TARGET_FEATURE").unwrap_or_default();
@@ -14,23 +44,44 @@ fn main() {
         .all(|required| features.split(',').any(|enabled| enabled == *required));
     let simd = match arch.as_str() {
         "wasm32" | "wasm64" => "wasm",
-        "x86_64" if env::var_os("CARGO_FEATURE_SIMD_X86").is_some() && x86_v3 => "x86",
+        "x86_64" if env::var_os("CARGO_FEATURE_SIMD_INTRINSICS").is_some() && x86_v3 => "x86",
         _ => "generic",
     };
-    println!("cargo::rustc-cfg=simd_backend={simd:?}");
+    println!("cargo::rustc-cfg=tw_simd_backend={simd:?}");
+}
 
-    if env::var_os("CARGO_FEATURE_NIGHTLY_TAIL_CALLS").is_none() {
+fn configure_nightly() {
+    println!("cargo::rustc-check-cfg=cfg(tw_abort_immediate)");
+    println!("cargo::rustc-check-cfg=cfg(tw_tail_calls)");
+    println!(
+        "cargo::rustc-check-cfg=cfg(tw_tail_abi, values(\"Rust\", \"C-unwind\", \"sysv64-unwind\", \"rust-preserve-none\"))"
+    );
+    let mut compiler = autocfg::new();
+    compiler.set_edition(Some("2024".into()));
+    if env::var_os("CARGO_FEATURE_NIGHTLY_ABORT_IMMEDIATE").is_some()
+        && compiler.probe_raw(ABORT_IMMEDIATE_PROBE).is_ok()
+    {
+        println!("cargo::rustc-cfg=tw_abort_immediate");
+    }
+    if env::var_os("CARGO_FEATURE_NIGHTLY_TAIL_CALLS").is_none() || compiler.probe_raw(TAIL_CALLS_PROBE).is_err() {
         return;
     }
 
+    let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("Cargo target architecture");
     let width = env::var("CARGO_CFG_TARGET_POINTER_WIDTH").expect("Cargo target pointer width");
     let os = env::var("CARGO_CFG_TARGET_OS").expect("Cargo target OS");
-    let preserve_none = env::var_os("CARGO_FEATURE_NIGHTLY_RUST_PRESERVE_NONE").is_some();
-    let abi = match (arch.as_str(), width.as_str(), os.as_str(), preserve_none) {
-        ("aarch64", "32", _, _) => "C-unwind",
-        ("x86_64", _, _, true) | ("aarch64", "64", _, true) => "rust-preserve-none",
-        ("x86_64", _, "windows", _) => "sysv64-unwind",
-        _ => "Rust",
+    let preserve_none = env::var_os("CARGO_FEATURE_NIGHTLY_RUST_PRESERVE_NONE").is_some()
+        && matches!((arch.as_str(), width.as_str()), ("x86_64", "64") | ("aarch64", "64"))
+        && compiler.probe_raw(PRESERVE_NONE_PROBE).is_ok();
+    let abi = if preserve_none {
+        "rust-preserve-none"
+    } else {
+        match (arch.as_str(), width.as_str(), os.as_str()) {
+            ("aarch64", "32", _) => "C-unwind",
+            ("x86_64", _, "windows") => "sysv64-unwind",
+            _ => "Rust",
+        }
     };
-    println!("cargo::rustc-cfg=tail_abi={abi:?}");
+    println!("cargo::rustc-cfg=tw_tail_calls");
+    println!("cargo::rustc-cfg=tw_tail_abi={abi:?}");
 }

crates/tinywasm/build.rs

@@ -42,7 +42,7 @@ impl<T: Copy + Default> StackLane<T> {
     }
 
     /// Synchronizes the unchanged live height forwarded into a tail-dispatch handler.
-    #[cfg(feature = "nightly-tail-calls")]
+    #[cfg(tw_tail_calls)]
     #[inline(always)]
     pub(crate) fn set_height(&mut self, height: usize) {
         debug_assert_eq!(height, self.top);
@@ -357,7 +357,7 @@ mod tests {
         }
     }
 
-    #[cfg(any(debug_assertions, not(feature = "nightly-tail-calls")))]
+    #[cfg(any(debug_assertions, not(tw_tail_calls)))]
     #[test]
     #[should_panic(expected = "value stack index out of range")]
     fn get_rejects_popped_slots() {
@@ -367,7 +367,7 @@ mod tests {
         stack.get(0);
     }
 
-    #[cfg(any(debug_assertions, not(feature = "nightly-tail-calls")))]
+    #[cfg(any(debug_assertions, not(tw_tail_calls)))]
     #[test]
     #[should_panic(expected = "value stack index out of range")]
     fn set_rejects_popped_slots() {

crates/tinywasm/src/collections/stack.rs

@@ -84,13 +84,13 @@ macro_rules! define_tail_dispatch {
     };
 }
 
-#[cfg(tail_abi = "Rust")]
+#[cfg(tw_tail_abi = "Rust")]
 instruction_handlers!(define_tail_dispatch, "Rust");
-#[cfg(tail_abi = "C-unwind")]
+#[cfg(tw_tail_abi = "C-unwind")]
 instruction_handlers!(define_tail_dispatch, "C-unwind");
-#[cfg(tail_abi = "sysv64-unwind")]
+#[cfg(tw_tail_abi = "sysv64-unwind")]
 instruction_handlers!(define_tail_dispatch, "sysv64-unwind");
-#[cfg(tail_abi = "rust-preserve-none")]
+#[cfg(tw_tail_abi = "rust-preserve-none")]
 instruction_handlers!(define_tail_dispatch, "rust-preserve-none");
 
 impl Executor<'_> {

crates/tinywasm/src/interpreter/executor/dispatch_become.rs

@@ -23,9 +23,9 @@ mod budget;
 
 pub(crate) use budget::Budget;
 
-#[cfg(not(feature = "nightly-tail-calls"))]
+#[cfg(not(tw_tail_calls))]
 mod dispatch;
-#[cfg(feature = "nightly-tail-calls")]
+#[cfg(tw_tail_calls)]
 mod dispatch_become;
 
 const FUEL_COST_CALL_TOTAL: u32 = 5;

crates/tinywasm/src/interpreter/executor/mod.rs

@@ -10,7 +10,7 @@ use super::super::no_std_floats::NoStdFloatExt;
 use core::arch::wasm32 as wasm;
 #[cfg(target_arch = "wasm64")]
 use core::arch::wasm64 as wasm;
-#[cfg(simd_backend = "x86")]
+#[cfg(tw_simd_backend = "x86")]
 use core::arch::x86_64 as x86;
 
 impl Value128 {

crates/tinywasm/src/interpreter/simd/instructions.rs

@@ -3,8 +3,8 @@
 macro_rules! simd_impl {
     ($(wasm => $wasm:block)? $(x86 => $x86:block)? generic => $generic:block) => {
         cfg_select! {
-            simd_backend = "wasm" => { simd_impl!(@pick_wasm $( $wasm )? ; $generic) },
-            simd_backend = "x86" => { simd_impl!(@pick_x86 $( $x86 )? ; $generic) },
+            tw_simd_backend = "wasm" => { simd_impl!(@pick_wasm $( $wasm )? ; $generic) },
+            tw_simd_backend = "x86" => { simd_impl!(@pick_x86 $( $x86 )? ; $generic) },
             _ => { $generic }
         }
     };