feat: initial exception support

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

Author: explodingcamera

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added support for the WebAssembly function-references proposal
 - Added basic support for the WebAssembly garbage-collection proposal
+- Added support for the WebAssembly exception-handling proposal, including tags, `try_table`, `throw`, and `throw_ref`
 - Added `WasmValue::ty` and `WasmValue::matches_type`
 - Added `ValueLane` for mapping WebAssembly value types to their physical 32-bit, 64-bit, or 128-bit storage lane.
 - Added a `validate` feature to `tinywasm` and `tinywasm-parser` (enabled by default) to optionally skip wasmparser validation for faster parsing of trusted modules.

README.md

@@ -96,7 +96,7 @@ TinyWasm targets non-JavaScript core proposals through [phase 3](https://github.
 | [**Custom Page Sizes**](https://github.com/WebAssembly/custom-page-sizes)                                        | 🟢     | 0.9.0              |
 | [**Typed Function References**](https://github.com/WebAssembly/function-references)                              | 🟢     | `next`             |
 | [**Garbage Collection**](https://github.com/WebAssembly/gc)                                                      | 🟢     | `next`             |
-| [**Exception Handling**](https://github.com/WebAssembly/exception-handling)                                      | 🌑     | -                  |
+| [**Exception Handling**](https://github.com/WebAssembly/exception-handling)                                      | 🟢     | `next`             |
 | [**Stack Switching**](https://github.com/WebAssembly/stack-switching)                                            | 🌑     | -                  |
 | [**Compact Import Section**](https://github.com/WebAssembly/compact-import-section)                              | 🌑     | -                  |
 | [**Threads**](https://github.com/WebAssembly/threads)                                                            | 🌑     | -                  |

crates/cli/src/output.rs

@@ -77,6 +77,7 @@ pub fn format_export_type(ty: ExportType<'_>) -> String {
         ExportType::Memory(ty) => format_memory_type(ty),
         ExportType::Table(ty) => format_table_type(ty),
         ExportType::Global(ty) => format_global_type(ty),
+        ExportType::Tag(ty) => format!("tag {}", format_func_type(ty)),
     }
 }
 
@@ -86,5 +87,6 @@ pub fn format_import_type(ty: ImportType<'_>) -> String {
         ImportType::Memory(ty) => format_memory_type(ty),
         ImportType::Table(ty) => format_table_type(ty),
         ImportType::Global(ty) => format_global_type(ty),
+        ImportType::Tag(ty) => format!("tag {}", format_func_type(ty)),
     }
 }

crates/cli/src/wast_runner.rs

@@ -19,53 +19,63 @@ const TEST_MAX_SUSPENSIONS: u32 = 1000;
 
 #[derive(Default)]
 struct ModuleRegistry {
-    modules: HashMap<String, ModuleInstance>,
-    named_modules: HashMap<String, ModuleInstance>,
-    last_module: Option<ModuleInstance>,
+    definitions: HashMap<String, Module>,
+    instances: HashMap<String, ModuleInstance>,
+    registered: HashMap<String, ModuleInstance>,
+    last_definition: Option<Module>,
+    last_instance: Option<ModuleInstance>,
 }
 
 impl ModuleRegistry {
-    fn modules(&self) -> &HashMap<String, ModuleInstance> {
-        &self.modules
+    fn registered(&self) -> &HashMap<String, ModuleInstance> {
+        &self.registered
     }
 
-    fn update_last_module(&mut self, module: ModuleInstance, name: Option<String>) {
-        self.last_module = Some(module.clone());
+    fn define(&mut self, module: Module, name: Option<String>) {
+        self.last_definition = Some(module.clone());
         if let Some(name) = name {
-            self.named_modules.insert(name, module);
+            self.definitions.insert(name, module);
         }
     }
 
-    fn register(&mut self, name: String, module: ModuleInstance) {
+    fn definition(&self, id: Option<wast::token::Id<'_>>) -> Option<Module> {
+        match id {
+            Some(id) => self.definitions.get(id.name()).cloned(),
+            None => self.last_definition.clone(),
+        }
+    }
+
+    fn update_last_instance(&mut self, instance: ModuleInstance, name: Option<String>) {
+        self.last_instance = Some(instance.clone());
+        if let Some(name) = name {
+            self.instances.insert(name, instance);
+        }
+    }
+
+    fn register(&mut self, name: String, id: Option<wast::token::Id<'_>>) -> bool {
+        let Some(instance) = self.get(id) else { return false };
         debug!("registering module: {name}");
-        self.modules.insert(name.clone(), module.clone());
-        self.last_module = Some(module.clone());
-        self.named_modules.insert(name, module);
+        self.registered.insert(name, instance);
+        true
     }
 
     fn get_idx(&self, module_id: Option<wast::token::Id<'_>>) -> Option<u32> {
         match module_id {
-            Some(module) => self
-                .modules
-                .get(module.name())
-                .or_else(|| self.named_modules.get(module.name()))
-                .map(ModuleInstance::id),
-            None => self.last_module.as_ref().map(ModuleInstance::id),
+            Some(module) => {
+                self.registered.get(module.name()).or_else(|| self.instances.get(module.name())).map(ModuleInstance::id)
+            }
+            None => self.last_instance.as_ref().map(ModuleInstance::id),
         }
     }
 
     fn get(&self, module_id: Option<wast::token::Id<'_>>) -> Option<ModuleInstance> {
         match module_id {
             Some(module_id) => {
-                self.modules.get(module_id.name()).or_else(|| self.named_modules.get(module_id.name())).cloned()
+                self.registered.get(module_id.name()).or_else(|| self.instances.get(module_id.name())).cloned()
             }
-            None => self.last_module.clone(),
+            None => self.last_instance.clone(),
         }
     }
-
-    fn last(&self) -> Option<ModuleInstance> {
-        self.last_module.clone()
-    }
 }
 
 #[derive(Default)]
@@ -200,6 +210,11 @@ impl WastRunner {
         Ok(imports)
     }
 
+    fn instantiate_module(store: &mut Store, registry: &ModuleRegistry, module: &Module) -> Result<ModuleInstance> {
+        let imports = Self::imports(store, registry.registered())?;
+        Ok(ModuleInstance::instantiate(store, module, Some(&imports))?)
+    }
+
     pub fn run_file(&mut self, file: TestFile<'_>) -> Result<()> {
         let test_group = self.test_group(file.name(), file.parent());
         let wast_raw = file.raw();
@@ -213,51 +228,72 @@ impl WastRunner {
         for (i, directive) in directives.into_iter().enumerate() {
             let span = directive.span();
             use wast::WastDirective::{
-                AssertExhaustion, AssertInvalid, AssertMalformed, AssertReturn, AssertTrap, AssertUnlinkable, Invoke,
-                Module as Wat, ModuleDefinition, Register,
+                AssertException, AssertExhaustion, AssertInvalid, AssertMalformed, AssertReturn, AssertTrap,
+                AssertUnlinkable, Invoke, Module as Wat, ModuleDefinition, ModuleInstance as Instance, Register,
             };
 
             match directive {
-                Register { span, name, .. } => {
-                    let Some(last) = module_registry.last() else {
+                Register { span, name, module } => {
+                    if !module_registry.register(name.to_string(), module) {
                         test_group.add_result(
                             &format!("Register({i})"),
                             span.linecol_in(wast_raw),
-                            Err(eyre!("no module to register")),
+                            Err(eyre!("module instance to register was not found")),
                         );
                         continue;
-                    };
-                    module_registry.register(name.to_string(), last);
+                    }
                     test_group.add_result(&format!("Register({i})"), span.linecol_in(wast_raw), Ok(()));
                 }
                 Wat(module) => {
                     let result = catch_unwind_silent(|| {
-                        let (name, bytes) = encode_quote_wat(module);
-                        let module = parse_module_bytes(&bytes).expect("failed to parse module bytes");
-                        let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
-                        let module_instance = ModuleInstance::instantiate(&mut store, &module, Some(&imports))
+                        let (name, module) = parse_quote_module(module).expect("failed to parse module bytes");
+                        let instance = Self::instantiate_module(&mut store, &module_registry, &module)
                             .expect("failed to instantiate module");
-                        (name, module_instance)
+                        (name, instance)
                     })
                     .map_err(|e| eyre!("failed to parse wat module: {}", try_downcast_panic(e)));
 
                     match &result {
                         Err(err) => debug!("failed to parse module: {err:?}"),
-                        Ok((name, module)) => module_registry.update_last_module(module.clone(), name.clone()),
+                        Ok((name, instance)) => module_registry.update_last_instance(instance.clone(), name.clone()),
                     };
 
                     test_group.add_result(&format!("Wat({i})"), span.linecol_in(wast_raw), result.map(|_| ()));
                 }
                 ModuleDefinition(module) => {
+                    let result =
+                        catch_unwind_silent(|| parse_quote_module(module).expect("failed to parse module definition"))
+                            .map_err(|err| eyre!("failed to parse module definition: {}", try_downcast_panic(err)));
+
+                    if let Ok((name, module)) = &result {
+                        module_registry.define(module.clone(), name.clone());
+                    }
+
+                    test_group.add_result(
+                        &format!("ModuleDefinition({i})"),
+                        span.linecol_in(wast_raw),
+                        result.map(|_| ()),
+                    );
+                }
+                Instance { span, instance, module } => {
+                    let name = instance.map(|id| id.name().to_string());
                     let result = catch_unwind_silent(|| {
-                        let (_, bytes) = encode_quote_wat(module);
-                        parse_module_bytes(&bytes)
+                        let module = module_registry
+                            .definition(module)
+                            .ok_or_else(|| eyre!("module definition was not found"))?;
+                        Self::instantiate_module(&mut store, &module_registry, &module)
                     })
-                    .map_err(|err| eyre!("failed to parse module definition: {}", try_downcast_panic(err)))
-                    .and_then(|result| result)
-                    .map(|_| ());
+                    .map_err(|err| eyre!("failed to instantiate module definition: {}", try_downcast_panic(err)))
+                    .and_then(|result| result);
 
-                    test_group.add_result(&format!("ModuleDefinition({i})"), span.linecol_in(wast_raw), result);
+                    if let Ok(instance) = &result {
+                        module_registry.update_last_instance(instance.clone(), name);
+                    }
+                    test_group.add_result(
+                        &format!("ModuleInstance({i})"),
+                        span.linecol_in(wast_raw),
+                        result.map(|_| ()),
+                    );
                 }
                 AssertMalformed { span, mut module, message } => {
                     let Ok(encoded) = module.encode() else {
@@ -330,7 +366,7 @@ impl WastRunner {
                             wast::WastExecute::Wat(mut wat) => {
                                 let module = parse_module_bytes(&wat.encode().expect("failed to encode module"))
                                     .expect("failed to parse module");
-                                let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
+                                let imports = Self::imports(&mut store, module_registry.registered()).unwrap();
                                 ModuleInstance::instantiate(&mut store, &module, Some(&imports))?;
                                 return Ok(());
                             }
@@ -371,11 +407,37 @@ impl WastRunner {
                         ),
                     }
                 }
+                AssertException { exec, span } => {
+                    let res: Result<tinywasm::Result<()>, _> = catch_unwind_silent(|| {
+                        let invoke = match exec {
+                            wast::WastExecute::Wat(mut wat) => {
+                                let module = parse_module_bytes(&wat.encode().expect("failed to encode module"))
+                                    .expect("failed to parse module");
+                                let imports = Self::imports(&mut store, module_registry.registered()).unwrap();
+                                ModuleInstance::instantiate(&mut store, &module, Some(&imports))?;
+                                return Ok(());
+                            }
+                            wast::WastExecute::Get { .. } => panic!("get not supported"),
+                            wast::WastExecute::Invoke(invoke) => invoke,
+                        };
+                        let module = module_registry.get_idx(invoke.module);
+                        let args =
+                            convert_wastargs(invoke.args).map_err(|err| tinywasm::Error::Other(err.to_string()))?;
+                        exec_fn_instance(module, &mut store, invoke.name, &args).map(|_| ())
+                    });
+                    let result = match res {
+                        Err(err) => Err(eyre!("test panicked: {}", try_downcast_panic(err))),
+                        Ok(Err(tinywasm::Error::Exception(_))) => Ok(()),
+                        Ok(Err(err)) => Err(eyre!("expected exception, got: {err:?}")),
+                        Ok(Ok(())) => Err(eyre!("expected exception, got Ok")),
+                    };
+                    test_group.add_result(&format!("AssertException({i})"), span.linecol_in(wast_raw), result);
+                }
                 AssertUnlinkable { mut module, span, message } => {
                     let res = catch_unwind_silent(|| {
                         let module = parse_module_bytes(&module.encode().expect("failed to encode module"))
                             .expect("failed to parse module");
-                        let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
+                        let imports = Self::imports(&mut store, module_registry.registered()).unwrap();
                         ModuleInstance::instantiate(&mut store, &module, Some(&imports))
                     });
                     match res {
@@ -729,6 +791,11 @@ fn parse_module_bytes(bytes: &[u8]) -> Result<Module> {
     Ok(tinywasm::parse_bytes(bytes)?)
 }
 
+fn parse_quote_module(module: QuoteWat) -> Result<(Option<String>, Module)> {
+    let (name, bytes) = encode_quote_wat(module);
+    Ok((name, parse_module_bytes(&bytes)?))
+}
+
 fn convert_wastargs(args: Vec<wast::WastArg>) -> Result<Vec<WasmValue>> {
     args.into_iter().map(wastarg2tinywasmvalue).collect()
 }
@@ -947,4 +1014,26 @@ mod tests {
         let mut runner = WastRunner::new();
         runner.run_paths(&[path]).unwrap();
     }
+
+    #[test]
+    fn runs_module_definition_and_instance_directives() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("instance.wast");
+        std::fs::write(
+            &path,
+            r#"
+            (module definition $M (global (export "g") i32 (i32.const 42)))
+            (module instance $I $M)
+            (register "I" $I)
+            (module
+              (import "I" "g" (global $g i32))
+              (func (export "get") (result i32) global.get $g))
+            (assert_return (invoke "get") (i32.const 42))
+            "#,
+        )
+        .unwrap();
+
+        let mut runner = WastRunner::new();
+        runner.run_paths(&[path]).unwrap();
+    }
 }

crates/parser/src/conversion.rs

@@ -76,9 +76,7 @@ pub(crate) fn convert_module_import(import: wasmparser::Import<'_>) -> Result<Im
         wasmparser::TypeRef::Global(ty) => {
             ImportKind::Global(GlobalType::new(convert_valtype(&ty.content_type)?, ty.mutable))
         }
-        wasmparser::TypeRef::Tag(ty) => {
-            return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {ty:?}")));
-        }
+        wasmparser::TypeRef::Tag(ty) => ImportKind::Tag(convert_tag_type(ty)),
         _ => {
             return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {:?}", import.ty)));
         }
@@ -116,14 +114,19 @@ pub(crate) fn convert_module_export(export: wasmparser::Export<'_>) -> Result<Ex
         wasmparser::ExternalKind::Table => ExternalKind::Table,
         wasmparser::ExternalKind::Memory => ExternalKind::Memory,
         wasmparser::ExternalKind::Global => ExternalKind::Global,
-        wasmparser::ExternalKind::Tag | wasmparser::ExternalKind::FuncExact => {
+        wasmparser::ExternalKind::Tag => ExternalKind::Tag,
+        wasmparser::ExternalKind::FuncExact => {
             return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported export kind: {:?}", export.kind)));
         }
     };
 
     Ok(Export { index: export.index, name: Box::from(export.name), kind })
 }
 
+pub(crate) const fn convert_tag_type(ty: wasmparser::TagType) -> TagType {
+    TagType::new(ty.func_type_idx)
+}
+
 fn extend_local_types(local_types: &mut Vec<ValueLane>, count: u32, ty: wasmparser::ValType) -> Result<()> {
     let size = value_lane(ty);
     let count =

crates/parser/src/lib.rs

@@ -189,6 +189,7 @@ impl Parser {
                 | WasmFeatures::SIMD
                 | WasmFeatures::MEMORY64
                 | WasmFeatures::CUSTOM_PAGE_SIZES
+                | WasmFeatures::EXCEPTIONS
                 | WasmFeatures::WIDE_ARITHMETIC;
             self.options.validation().then(|| Validator::new_with_features(features))
         }

crates/parser/src/macros.rs

@@ -160,6 +160,7 @@ pub(crate) mod visit {
         (@@tail_call $($rest:tt)* ) => {};
         (@@function_references $($rest:tt)* ) => {};
         (@@gc $($rest:tt)* ) => {};
+        (@@exceptions $($rest:tt)* ) => {};
 
         (@@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*)) => {
             fn $visit(&mut self $($(,_: $argty)*)?) -> Self::Output {