chore: put debug impl behind feature flag, cleanup

explodingcamera · explodingcamera · commit 065dc608ab25 · 2026-04-03T17:24:38.000+02:00
Signed-off-by: Henry &lt;mail@henrygressmann.de&gt;
diff --git a/README.md b/README.md
@@ -46,7 +46,7 @@ Safety wise, TinyWasm doesn't use any unsafe code and is designed to be complete
 | [**Custom Page Sizes**](https://github.com/WebAssembly/custom-page-sizes/blob/main/proposals/custom-page-sizes/Overview.md) | 🟢     | `next`           |
 | [**Tail Call**](https://github.com/WebAssembly/tail-call/blob/main/proposals/tail-call/Overview.md)                         | 🟢     | `next`           |
 | [**Memory64**](https://github.com/WebAssembly/memory64/blob/master/proposals/memory64/Overview.md)                          | 🟢     | `next`           |
-| [**Fixed-Width SIMD**](https://github.com/webassembly/simd)                                                                 | 🚧     | N/A              |
+| [**Fixed-Width SIMD**](https://github.com/webassembly/simd)                                                                 | 🟢     | `next`           |
 
 ## Usage
 
diff --git a/crates/tinywasm/Cargo.toml b/crates/tinywasm/Cargo.toml
@@ -34,7 +34,7 @@ serde_json.workspace=true
 serde.workspace=true
 
 [features]
-default=["std", "parser", "log", "archive", "canonicalize_nans"]
+default=["std", "parser", "log", "archive", "canonicalize_nans", "debug"]
 
 log=["dep:log", "tinywasm-parser?/log", "tinywasm-types/log"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
@@ -48,6 +48,9 @@ archive=["tinywasm-types/archive"]
 # canonicalize all NaN values to a single representation
 canonicalize_nans=[]
 
+# derive Debug for runtime/types structs
+debug=["tinywasm-types/debug"]
+
 [[test]]
 name="test-wasm-1"
 harness=false
diff --git a/crates/tinywasm/src/engine.rs b/crates/tinywasm/src/engine.rs
@@ -40,9 +40,9 @@ pub(crate) struct EngineInner {
 }
 
 /// Fuel accounting policy for budgeted execution.
-#[derive(Debug, Clone, Copy)]
 #[non_exhaustive]
-#[derive(Default)]
+#[derive(Default, Clone, Copy)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub enum FuelPolicy {
     /// Charge one fuel unit per retired instruction.
     #[default]
@@ -67,7 +67,8 @@ pub const DEFAULT_VALUE_STACK_REF_SIZE: usize = 4 * 1024; // 4k slots
 pub const DEFAULT_CALL_STACK_SIZE: usize = 2048; // 1024 frames
 
 /// Configuration for the WebAssembly interpreter
-#[derive(Debug, Clone)]
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[non_exhaustive]
 pub struct Config {
     /// Initial size of the 32-bit value stack (i32, f32 values).
diff --git a/crates/tinywasm/src/error.rs b/crates/tinywasm/src/error.rs
@@ -8,7 +8,7 @@ use tinywasm_types::archive::TwasmError;
 pub use tinywasm_parser::ParseError;
 
 /// Errors that can occur for `TinyWasm` operations
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[non_exhaustive]
 pub enum Error {
     /// A WebAssembly trap occurred
diff --git a/crates/tinywasm/src/func.rs b/crates/tinywasm/src/func.rs
@@ -13,7 +13,8 @@ pub enum ExecProgress<T> {
     Suspended,
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Clone, Copy)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct ExecutionState {
     pub(crate) callframe: CallFrame,
 }
@@ -33,7 +34,7 @@ pub struct FuncExecution<'store> {
     state: FuncExecutionState,
 }
 
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 enum FuncExecutionState {
     Running { exec_state: ExecutionState, root_func_addr: u32 },
     Completed { result: Option<Vec<WasmValue>> },
diff --git a/crates/tinywasm/src/imports.rs b/crates/tinywasm/src/imports.rs
@@ -10,7 +10,8 @@ use crate::{LinkingError, MemoryRef, MemoryRefMut, Result, log};
 use tinywasm_types::*;
 
 /// The internal representation of a function
-#[derive(Debug, Clone)]
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub enum Function {
     /// A host function
     Host(Rc<HostFunction>),
@@ -49,7 +50,7 @@ impl HostFunction {
 pub(crate) type HostFuncInner = Box<dyn Fn(FuncContext<'_>, &[WasmValue]) -> Result<Vec<WasmValue>>>;
 
 /// The context of a host-function call
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct FuncContext<'a> {
     pub(crate) store: &'a mut crate::Store,
     pub(crate) module_addr: ModuleInstanceAddr,
diff --git a/crates/tinywasm/src/instance.rs b/crates/tinywasm/src/instance.rs
@@ -10,11 +10,12 @@ use crate::{Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, MemoryRefMut
 /// Backed by an Rc, so cloning is cheap
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#module-instances>
-#[derive(Debug, Clone)]
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct ModuleInstance(pub(crate) Rc<ModuleInstanceInner>);
 
 #[expect(dead_code)]
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct ModuleInstanceInner {
     pub(crate) failed_to_instantiate: bool,
 
diff --git a/crates/tinywasm/src/interpreter/mod.rs b/crates/tinywasm/src/interpreter/mod.rs
@@ -11,7 +11,8 @@ use crate::{Result, Store, interpreter::stack::CallFrame};
 pub(crate) use value128::*;
 pub(crate) use values::*;
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Clone, Copy)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) enum ExecState {
     Completed,
     Suspended(CallFrame),
@@ -20,7 +21,8 @@ pub(crate) enum ExecState {
 /// The main `TinyWasm` runtime.
 ///
 /// This is the default runtime used by `TinyWasm`.
-#[derive(Debug, Default)]
+#[derive(Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct InterpreterRuntime;
 
 impl InterpreterRuntime {
diff --git a/crates/tinywasm/src/interpreter/stack/call_stack.rs b/crates/tinywasm/src/interpreter/stack/call_stack.rs
@@ -3,7 +3,7 @@ use crate::{Result, Trap, unlikely};
 use alloc::vec::Vec;
 use tinywasm_types::{FuncAddr, ModuleInstanceAddr, ValueCountsSmall};
 
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct CallStack {
     stack: Vec<CallFrame>,
 }
@@ -32,7 +32,8 @@ impl CallStack {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Clone, Copy, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct CallFrame {
     pub(crate) instr_ptr: u32,
     pub(crate) module_addr: ModuleInstanceAddr,
@@ -41,7 +42,8 @@ pub(crate) struct CallFrame {
     pub(crate) stack_offset: ValueCountsSmall,
 }
 
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Clone, Copy, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct StackBase {
     pub(crate) s32: u32,
     pub(crate) s64: u32,
diff --git a/crates/tinywasm/src/interpreter/stack/mod.rs b/crates/tinywasm/src/interpreter/stack/mod.rs
@@ -7,7 +7,7 @@ pub(crate) use value_stack::ValueStack;
 use crate::engine::Config;
 
 /// A WebAssembly Stack
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct Stack {
     pub(crate) values: ValueStack,
     pub(crate) call_stack: CallStack,
diff --git a/crates/tinywasm/src/interpreter/stack/value_stack.rs b/crates/tinywasm/src/interpreter/stack/value_stack.rs
@@ -6,15 +6,15 @@ use crate::{Result, Trap, engine::Config, interpreter::*, unlikely};
 
 use super::{CallFrame, StackBase};
 
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct ValueStack {
     pub(crate) stack_32: Stack<Value32>,
     pub(crate) stack_64: Stack<Value64>,
     pub(crate) stack_128: Stack<Value128>,
     pub(crate) stack_ref: Stack<ValueRef>,
 }
 
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct Stack<T: Copy + Default> {
     data: Box<[T]>,
     len: usize,
diff --git a/crates/tinywasm/src/module.rs b/crates/tinywasm/src/module.rs
@@ -4,7 +4,8 @@ use tinywasm_types::TinyWasmModule;
 /// A WebAssembly Module
 ///
 /// See <https://webassembly.github.io/spec/core/syntax/modules.html#syntax-module>
-#[derive(Debug, Clone)]
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct Module(pub(crate) alloc::sync::Arc<TinyWasmModule>);
 
 impl From<&TinyWasmModule> for Module {
diff --git a/crates/tinywasm/src/reference.rs b/crates/tinywasm/src/reference.rs
@@ -8,11 +8,11 @@ use crate::{MemoryInstance, Result};
 // This module essentially contains the public APIs to interact with the data stored in the store
 
 /// A reference to a memory instance
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct MemoryRef<'a>(pub(crate) &'a MemoryInstance);
 
 /// A borrowed reference to a memory instance
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct MemoryRefMut<'a>(pub(crate) &'a mut MemoryInstance);
 
 impl MemoryRefLoad for MemoryRef<'_> {
diff --git a/crates/tinywasm/src/store/data.rs b/crates/tinywasm/src/store/data.rs
@@ -1,18 +1,16 @@
 use alloc::vec::Vec;
-use tinywasm_types::*;
 
 /// A WebAssembly Data Instance
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#data-instances>
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct DataInstance {
     pub(crate) data: Option<Vec<u8>>,
-    pub(crate) _owner: ModuleInstanceAddr, // index into store.module_instances
 }
 
 impl DataInstance {
-    pub(crate) fn new(data: Option<Vec<u8>>, owner: ModuleInstanceAddr) -> Self {
-        Self { data, _owner: owner }
+    pub(crate) fn new(data: Option<Vec<u8>>) -> Self {
+        Self { data }
     }
 
     pub(crate) fn drop(&mut self) {
diff --git a/crates/tinywasm/src/store/element.rs b/crates/tinywasm/src/store/element.rs
@@ -5,16 +5,15 @@ use tinywasm_types::*;
 /// A WebAssembly Element Instance
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#element-instances>
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct ElementInstance {
     pub(crate) kind: ElementKind,
     pub(crate) items: Option<Vec<TableElement>>, // none is the element was dropped
-    pub(crate) _owner: ModuleInstanceAddr,       // index into store.module_instances
 }
 
 impl ElementInstance {
-    pub(crate) fn new(kind: ElementKind, owner: ModuleInstanceAddr, items: Option<Vec<TableElement>>) -> Self {
-        Self { kind, _owner: owner, items }
+    pub(crate) fn new(kind: ElementKind, items: Option<Vec<TableElement>>) -> Self {
+        Self { kind, items }
     }
 
     pub(crate) fn drop(&mut self) {
diff --git a/crates/tinywasm/src/store/global.rs b/crates/tinywasm/src/store/global.rs
@@ -5,15 +5,14 @@ use tinywasm_types::*;
 /// A WebAssembly Global Instance
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct GlobalInstance {
     pub(crate) value: Cell<TinyWasmValue>,
     pub(crate) ty: GlobalType,
-    pub(crate) _owner: ModuleInstanceAddr, // index into store.module_instances
 }
 
 impl GlobalInstance {
-    pub(crate) fn new(ty: GlobalType, value: TinyWasmValue, owner: ModuleInstanceAddr) -> Self {
-        Self { ty, value: value.into(), _owner: owner }
+    pub(crate) fn new(ty: GlobalType, value: TinyWasmValue) -> Self {
+        Self { ty, value: value.into() }
     }
 }
diff --git a/crates/tinywasm/src/store/memory.rs b/crates/tinywasm/src/store/memory.rs
@@ -1,31 +1,24 @@
 use alloc::vec;
 use alloc::vec::Vec;
-use tinywasm_types::{MemoryArch, MemoryType, ModuleInstanceAddr};
+use tinywasm_types::{MemoryArch, MemoryType};
 
 use crate::{Error, Result, cold, interpreter::Value128, log};
 
 /// A WebAssembly Memory Instance
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances>
-#[derive(Debug)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct MemoryInstance {
     pub(crate) kind: MemoryType,
     pub(crate) data: Vec<u8>,
     pub(crate) page_count: usize,
-    pub(crate) _owner: ModuleInstanceAddr, // index into store.module_instances
 }
 
 impl MemoryInstance {
-    pub(crate) fn new(kind: MemoryType, owner: ModuleInstanceAddr) -> Self {
+    pub(crate) fn new(kind: MemoryType) -> Self {
         assert!(kind.page_count_initial() <= kind.page_count_max());
         log::debug!("initializing memory with {} pages of {} bytes", kind.page_count_initial(), kind.page_size());
-
-        Self {
-            kind,
-            data: vec![0; kind.initial_size() as usize],
-            page_count: kind.page_count_initial() as usize,
-            _owner: owner,
-        }
+        Self { kind, data: vec![0; kind.initial_size() as usize], page_count: kind.page_count_initial() as usize }
     }
 
     pub(crate) const fn is_64bit(&self) -> bool {
@@ -189,8 +182,7 @@ mod memory_instance_tests {
 
     fn create_test_memory() -> MemoryInstance {
         let kind = MemoryType::new(MemoryArch::I32, 1, Some(2), None);
-        let owner = ModuleInstanceAddr::default();
-        MemoryInstance::new(kind, owner)
+        MemoryInstance::new(kind)
     }
 
     #[test]
@@ -269,8 +261,7 @@ mod memory_instance_tests {
     #[test]
     fn test_memory_custom_page_size_out_of_bounds() {
         let kind = MemoryType::new(MemoryArch::I32, 1, Some(2), Some(1));
-        let owner = ModuleInstanceAddr::default();
-        let mut memory = MemoryInstance::new(kind, owner);
+        let mut memory = MemoryInstance::new(kind);
 
         let data_to_store = [1, 2];
         assert!(memory.store(0, data_to_store.len(), &data_to_store).is_err());
@@ -279,8 +270,7 @@ mod memory_instance_tests {
     #[test]
     fn test_memory_custom_page_size_grow() {
         let kind = MemoryType::new(MemoryArch::I32, 1, Some(2), Some(1));
-        let owner = ModuleInstanceAddr::default();
-        let mut memory = MemoryInstance::new(kind, owner);
+        let mut memory = MemoryInstance::new(kind);
 
         assert_eq!(memory.grow(1), Some(1));
 
diff --git a/crates/tinywasm/src/store/mod.rs b/crates/tinywasm/src/store/mod.rs
diff --git a/crates/tinywasm/src/store/table.rs b/crates/tinywasm/src/store/table.rs
diff --git a/crates/types/Cargo.toml b/crates/types/Cargo.toml
diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs
diff --git a/crates/types/src/lib.rs b/crates/types/src/lib.rs
diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,8 @@ pub enum ExecProgress<T> {`
`13`	`13`	`Suspended,`
`14`	`14`	`}`
`15`	`15`
`16`		`-#[derive(Debug, Clone, Copy)]`
	`16`	`+#[derive(Clone, Copy)]`
	`17`	`+#[cfg_attr(feature = "debug", derive(Debug))]`
`17`	`18`	`pub(crate) struct ExecutionState {`
`18`	`19`	`pub(crate) callframe: CallFrame,`
`19`	`20`	`}`
`@@ -33,7 +34,7 @@ pub struct FuncExecution<'store> {`
`33`	`34`	`state: FuncExecutionState,`
`34`	`35`	`}`
`35`	`36`
`36`		`-#[derive(Debug)]`
	`37`	`+#[cfg_attr(feature = "debug", derive(Debug))]`
`37`	`38`	`enum FuncExecutionState {`
`38`	`39`	`Running { exec_state: ExecutionState, root_func_addr: u32 },`
`39`	`40`	`Completed { result: Option<Vec<WasmValue>> },`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use crate::{Result, Trap, unlikely};`
`3`	`3`	`use alloc::vec::Vec;`
`4`	`4`	`use tinywasm_types::{FuncAddr, ModuleInstanceAddr, ValueCountsSmall};`
`5`	`5`
`6`		`-#[derive(Debug)]`
	`6`	`+#[cfg_attr(feature = "debug", derive(Debug))]`
`7`	`7`	`pub(crate) struct CallStack {`
`8`	`8`	`stack: Vec<CallFrame>,`
`9`	`9`	`}`
`@@ -32,7 +32,8 @@ impl CallStack {`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`-#[derive(Debug, Clone, Copy, Default)]`
	`35`	`+#[derive(Clone, Copy, Default)]`
	`36`	`+#[cfg_attr(feature = "debug", derive(Debug))]`
`36`	`37`	`pub(crate) struct CallFrame {`
`37`	`38`	`pub(crate) instr_ptr: u32,`
`38`	`39`	`pub(crate) module_addr: ModuleInstanceAddr,`
`@@ -41,7 +42,8 @@ pub(crate) struct CallFrame {`
`41`	`42`	`pub(crate) stack_offset: ValueCountsSmall,`
`42`	`43`	`}`
`43`	`44`
`44`		`-#[derive(Debug, Clone, Copy, Default)]`
	`45`	`+#[derive(Clone, Copy, Default)]`
	`46`	`+#[cfg_attr(feature = "debug", derive(Debug))]`
`45`	`47`	`pub(crate) struct StackBase {`
`46`	`48`	`pub(crate) s32: u32,`
`47`	`49`	`pub(crate) s64: u32,`