Update wasm spec test suite, add exception feature flags (#10553)

* Update wasm spec test suite, add exception feature flags

This commit performs an update of the spec test suite submodule to the
next-to-latest commit. The latest commit will require updating the
`wast` dependency which isn't published yet.

This update brings in the `wasm-3.0` folder of tests since it's been
awhile since the last update. That update notably means that the
exception-handling proposal is mixed in with all the others with various
tests. Getting tests as flagged as passing or failing as a result was
unexpectedly difficult.

The solution I ended up settling on was to preemptively implement some
infrastructure for the exceptions proposal:

* `wasmtime::Config` methods
* `wasmtime` CLI flags
* integration with wast testing
* various updates to `should_fail`

It turns out we can run a few tests with the exception proposal, notably
due to tags being implemented for stack switching. That meant that this
couldn't blanket ignore the exceptions proposal and say it's expected to
fail. Instead the proposal is said "this passes!" and tests are
individually listed as "this is expected to fail".

This then required changing an `unsupported!` panic to plumbing errors
around to avoid actually implementing the exceptions proposal here.

* Review comments

Author: alexcrichton

crates/cli-flags/src/lib.rs

@@ -380,6 +380,10 @@ wasmtime_option_group! {
         pub wide_arithmetic: Option<bool>,
         /// Configure support for the extended-const proposal.
         pub extended_const: Option<bool>,
+        /// Configure support for the exceptions proposal.
+        pub exceptions: Option<bool>,
+        /// DEPRECATED: Configure support for the legacy exceptions proposal.
+        pub legacy_exceptions: Option<bool>,
     }
 
     enum Wasm {
@@ -983,6 +987,13 @@ impl CommonOptions {
         if let Some(enable) = self.wasm.extended_const.or(all) {
             config.wasm_extended_const(enable);
         }
+        if let Some(enable) = self.wasm.exceptions.or(all) {
+            config.wasm_exceptions(enable);
+        }
+        if let Some(enable) = self.wasm.legacy_exceptions.or(all) {
+            #[expect(deprecated, reason = "forwarding CLI flag")]
+            config.wasm_legacy_exceptions(enable);
+        }
 
         macro_rules! handle_conditionally_compiled {
             ($(($feature:tt, $field:tt, $method:tt))*) => ($(

crates/cranelift/src/translate/code_translator.rs

@@ -1237,7 +1237,7 @@ pub fn translate_operator(
             translate_fcmp(FloatCC::LessThanOrEqual, builder, state)
         }
         Operator::RefNull { hty } => {
-            let hty = environ.convert_heap_type(*hty);
+            let hty = environ.convert_heap_type(*hty)?;
             state.push1(environ.translate_ref_null(builder.cursor(), hty)?)
         }
         Operator::RefIsNull => {
@@ -2748,7 +2748,7 @@ pub fn translate_operator(
         }
         Operator::RefTestNonNull { hty } => {
             let r = state.pop1();
-            let heap_type = environ.convert_heap_type(*hty);
+            let heap_type = environ.convert_heap_type(*hty)?;
             let result = environ.translate_ref_test(
                 builder,
                 WasmRefType {
@@ -2761,7 +2761,7 @@ pub fn translate_operator(
         }
         Operator::RefTestNullable { hty } => {
             let r = state.pop1();
-            let heap_type = environ.convert_heap_type(*hty);
+            let heap_type = environ.convert_heap_type(*hty)?;
             let result = environ.translate_ref_test(
                 builder,
                 WasmRefType {
@@ -2774,7 +2774,7 @@ pub fn translate_operator(
         }
         Operator::RefCastNonNull { hty } => {
             let r = state.pop1();
-            let heap_type = environ.convert_heap_type(*hty);
+            let heap_type = environ.convert_heap_type(*hty)?;
             let cast_okay = environ.translate_ref_test(
                 builder,
                 WasmRefType {
@@ -2788,7 +2788,7 @@ pub fn translate_operator(
         }
         Operator::RefCastNullable { hty } => {
             let r = state.pop1();
-            let heap_type = environ.convert_heap_type(*hty);
+            let heap_type = environ.convert_heap_type(*hty)?;
             let cast_okay = environ.translate_ref_test(
                 builder,
                 WasmRefType {
@@ -2809,7 +2809,7 @@ pub fn translate_operator(
         } => {
             let r = state.peek1();
 
-            let to_ref_type = environ.convert_ref_type(*to_ref_type);
+            let to_ref_type = environ.convert_ref_type(*to_ref_type)?;
             let cast_is_okay = environ.translate_ref_test(builder, to_ref_type, r)?;
 
             let (cast_succeeds_block, inputs) = translate_br_if_args(*relative_depth, state);
@@ -2842,7 +2842,7 @@ pub fn translate_operator(
         } => {
             let r = state.peek1();
 
-            let to_ref_type = environ.convert_ref_type(*to_ref_type);
+            let to_ref_type = environ.convert_ref_type(*to_ref_type)?;
             let cast_is_okay = environ.translate_ref_test(builder, to_ref_type, r)?;
 
             let (cast_fails_block, inputs) = translate_br_if_args(*relative_depth, state);

crates/cranelift/src/translate/func_translator.rs

@@ -202,7 +202,7 @@ fn declare_locals(
             )
         }
         Ref(rt) => {
-            let hty = environ.convert_heap_type(rt.heap_type());
+            let hty = environ.convert_heap_type(rt.heap_type())?;
             let (ty, needs_stack_map) = environ.reference_type(hty);
             let init = if rt.is_nullable() {
                 Some(environ.translate_ref_null(builder.cursor(), hty)?)

crates/cranelift/src/translate/translation_utils.rs

@@ -63,7 +63,7 @@ pub fn block_with_params<PE: TargetEnvironment + ?Sized>(
                 builder.append_block_param(block, ir::types::F64);
             }
             wasmparser::ValType::Ref(rt) => {
-                let hty = environ.convert_heap_type(rt.heap_type());
+                let hty = environ.convert_heap_type(rt.heap_type())?;
                 let (ty, needs_stack_map) = environ.reference_type(hty);
                 let val = builder.append_block_param(block, ty);
                 if needs_stack_map {

crates/environ/src/compile/module_environ.rs

@@ -312,7 +312,7 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> {
                         }
                         TypeRef::Global(ty) => {
                             self.result.module.num_imported_globals += 1;
-                            EntityType::Global(self.convert_global_type(&ty))
+                            EntityType::Global(self.convert_global_type(&ty)?)
                         }
                         TypeRef::Table(ty) => {
                             self.result.module.num_imported_tables += 1;
@@ -408,7 +408,7 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> {
                     for f in escaped {
                         self.flag_func_escaped(f);
                     }
-                    let ty = self.convert_global_type(&ty);
+                    let ty = self.convert_global_type(&ty)?;
                     self.result.module.globals.push(ty);
                     self.result.module.global_initializers.push(initializer);
                 }
@@ -545,7 +545,7 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> {
                     let mut locals = Vec::new();
                     for pair in body.get_locals_reader()? {
                         let (cnt, ty) = pair?;
-                        let ty = self.convert_valtype(ty);
+                        let ty = self.convert_valtype(ty)?;
                         locals.push((cnt, ty));
                     }
                     self.result

crates/environ/src/compile/module_types.rs

@@ -114,7 +114,7 @@ impl ModuleTypesBuilder {
                 unreachable!("no need to lookup indexes; we already have core type IDs")
             })
             .with_rec_group(validator_types, rec_group_id)
-            .convert_sub_type(ty);
+            .convert_sub_type(ty)?;
             self.wasm_sub_type_in_rec_group(id, wasm_ty);
         }
 

crates/environ/src/component/translate.rs

@@ -540,7 +540,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                 for ty in s {
                     match ty? {
                         wasmparser::ComponentType::Resource { rep, dtor } => {
-                            let rep = self.types.convert_valtype(rep);
+                            let rep = self.types.convert_valtype(rep)?;
                             let id = types
                                 .component_any_type_at(component_type_index)
                                 .unwrap_resource();

crates/environ/src/component/types_builder.rs

@@ -382,7 +382,7 @@ impl ComponentTypesBuilder {
             }),
             Table(ty) => EntityType::Table(self.convert_table_type(ty)?),
             Memory(ty) => EntityType::Memory((*ty).into()),
-            Global(ty) => EntityType::Global(self.convert_global_type(ty)),
+            Global(ty) => EntityType::Global(self.convert_global_type(ty)?),
             Tag(_) => bail!("exceptions proposal not implemented"),
         })
     }

crates/environ/src/types.rs

@@ -2089,11 +2089,11 @@ impl TypeTrace for Tag {
 #[expect(missing_docs, reason = "self-describing functions")]
 pub trait TypeConvert {
     /// Converts a wasmparser table type into a wasmtime type
-    fn convert_global_type(&self, ty: &wasmparser::GlobalType) -> Global {
-        Global {
-            wasm_ty: self.convert_valtype(ty.content_type),
+    fn convert_global_type(&self, ty: &wasmparser::GlobalType) -> WasmResult<Global> {
+        Ok(Global {
+            wasm_ty: self.convert_valtype(ty.content_type)?,
             mutability: ty.mutable,
-        }
+        })
     }
 
     /// Converts a wasmparser table type into a wasmtime type
@@ -2109,37 +2109,40 @@ pub trait TypeConvert {
         Ok(Table {
             idx_type,
             limits,
-            ref_type: self.convert_ref_type(ty.element_type),
+            ref_type: self.convert_ref_type(ty.element_type)?,
         })
     }
 
-    fn convert_sub_type(&self, ty: &wasmparser::SubType) -> WasmSubType {
-        WasmSubType {
+    fn convert_sub_type(&self, ty: &wasmparser::SubType) -> WasmResult<WasmSubType> {
+        Ok(WasmSubType {
             is_final: ty.is_final,
             supertype: ty.supertype_idx.map(|i| self.lookup_type_index(i.unpack())),
-            composite_type: self.convert_composite_type(&ty.composite_type),
-        }
+            composite_type: self.convert_composite_type(&ty.composite_type)?,
+        })
     }
 
-    fn convert_composite_type(&self, ty: &wasmparser::CompositeType) -> WasmCompositeType {
+    fn convert_composite_type(
+        &self,
+        ty: &wasmparser::CompositeType,
+    ) -> WasmResult<WasmCompositeType> {
         let inner = match &ty.inner {
             wasmparser::CompositeInnerType::Func(f) => {
-                WasmCompositeInnerType::Func(self.convert_func_type(f))
+                WasmCompositeInnerType::Func(self.convert_func_type(f)?)
             }
             wasmparser::CompositeInnerType::Array(a) => {
-                WasmCompositeInnerType::Array(self.convert_array_type(a))
+                WasmCompositeInnerType::Array(self.convert_array_type(a)?)
             }
             wasmparser::CompositeInnerType::Struct(s) => {
-                WasmCompositeInnerType::Struct(self.convert_struct_type(s))
+                WasmCompositeInnerType::Struct(self.convert_struct_type(s)?)
             }
             wasmparser::CompositeInnerType::Cont(c) => {
                 WasmCompositeInnerType::Cont(self.convert_cont_type(c))
             }
         };
-        WasmCompositeType {
+        Ok(WasmCompositeType {
             inner,
             shared: ty.shared,
-        }
+        })
     }
 
     /// Converts a wasmparser continuation type to a wasmtime type
@@ -2151,73 +2154,73 @@ pub trait TypeConvert {
         }
     }
 
-    fn convert_struct_type(&self, ty: &wasmparser::StructType) -> WasmStructType {
-        WasmStructType {
+    fn convert_struct_type(&self, ty: &wasmparser::StructType) -> WasmResult<WasmStructType> {
+        Ok(WasmStructType {
             fields: ty
                 .fields
                 .iter()
                 .map(|f| self.convert_field_type(f))
-                .collect(),
-        }
+                .collect::<WasmResult<_>>()?,
+        })
     }
 
-    fn convert_array_type(&self, ty: &wasmparser::ArrayType) -> WasmArrayType {
-        WasmArrayType(self.convert_field_type(&ty.0))
+    fn convert_array_type(&self, ty: &wasmparser::ArrayType) -> WasmResult<WasmArrayType> {
+        Ok(WasmArrayType(self.convert_field_type(&ty.0)?))
     }
 
-    fn convert_field_type(&self, ty: &wasmparser::FieldType) -> WasmFieldType {
-        WasmFieldType {
-            element_type: self.convert_storage_type(&ty.element_type),
+    fn convert_field_type(&self, ty: &wasmparser::FieldType) -> WasmResult<WasmFieldType> {
+        Ok(WasmFieldType {
+            element_type: self.convert_storage_type(&ty.element_type)?,
             mutable: ty.mutable,
-        }
+        })
     }
 
-    fn convert_storage_type(&self, ty: &wasmparser::StorageType) -> WasmStorageType {
-        match ty {
+    fn convert_storage_type(&self, ty: &wasmparser::StorageType) -> WasmResult<WasmStorageType> {
+        Ok(match ty {
             wasmparser::StorageType::I8 => WasmStorageType::I8,
             wasmparser::StorageType::I16 => WasmStorageType::I16,
-            wasmparser::StorageType::Val(v) => WasmStorageType::Val(self.convert_valtype(*v)),
-        }
+            wasmparser::StorageType::Val(v) => WasmStorageType::Val(self.convert_valtype(*v)?),
+        })
     }
 
     /// Converts a wasmparser function type to a wasmtime type
-    fn convert_func_type(&self, ty: &wasmparser::FuncType) -> WasmFuncType {
+    fn convert_func_type(&self, ty: &wasmparser::FuncType) -> WasmResult<WasmFuncType> {
         let params = ty
             .params()
             .iter()
             .map(|t| self.convert_valtype(*t))
-            .collect();
+            .collect::<WasmResult<_>>()?;
         let results = ty
             .results()
             .iter()
             .map(|t| self.convert_valtype(*t))
-            .collect();
-        WasmFuncType::new(params, results)
+            .collect::<WasmResult<_>>()?;
+        Ok(WasmFuncType::new(params, results))
     }
 
     /// Converts a wasmparser value type to a wasmtime type
-    fn convert_valtype(&self, ty: wasmparser::ValType) -> WasmValType {
-        match ty {
+    fn convert_valtype(&self, ty: wasmparser::ValType) -> WasmResult<WasmValType> {
+        Ok(match ty {
             wasmparser::ValType::I32 => WasmValType::I32,
             wasmparser::ValType::I64 => WasmValType::I64,
             wasmparser::ValType::F32 => WasmValType::F32,
             wasmparser::ValType::F64 => WasmValType::F64,
             wasmparser::ValType::V128 => WasmValType::V128,
-            wasmparser::ValType::Ref(t) => WasmValType::Ref(self.convert_ref_type(t)),
-        }
+            wasmparser::ValType::Ref(t) => WasmValType::Ref(self.convert_ref_type(t)?),
+        })
     }
 
     /// Converts a wasmparser reference type to a wasmtime type
-    fn convert_ref_type(&self, ty: wasmparser::RefType) -> WasmRefType {
-        WasmRefType {
+    fn convert_ref_type(&self, ty: wasmparser::RefType) -> WasmResult<WasmRefType> {
+        Ok(WasmRefType {
             nullable: ty.is_nullable(),
-            heap_type: self.convert_heap_type(ty.heap_type()),
-        }
+            heap_type: self.convert_heap_type(ty.heap_type())?,
+        })
     }
 
     /// Converts a wasmparser heap type to a wasmtime type
-    fn convert_heap_type(&self, ty: wasmparser::HeapType) -> WasmHeapType {
-        match ty {
+    fn convert_heap_type(&self, ty: wasmparser::HeapType) -> WasmResult<WasmHeapType> {
+        Ok(match ty {
             wasmparser::HeapType::Concrete(i) => self.lookup_heap_type(i),
             wasmparser::HeapType::Abstract { ty, shared: false } => match ty {
                 wasmparser::AbstractHeapType::Extern => WasmHeapType::Extern,
@@ -2235,11 +2238,11 @@ pub trait TypeConvert {
                 | wasmparser::AbstractHeapType::NoExn
                 | wasmparser::AbstractHeapType::Cont
                 | wasmparser::AbstractHeapType::NoCont => {
-                    unimplemented!("unsupported heap type {ty:?}");
+                    return Err(wasm_unsupported!("unsupported heap type {ty:?}"))
                 }
             },
-            _ => unimplemented!("unsupported heap type {ty:?}"),
-        }
+            _ => return Err(wasm_unsupported!("unsupported heap type {ty:?}")),
+        })
     }
 
     /// Converts the specified type index from a heap type into a canonicalized

crates/fuzzing/src/generators/config.rs

@@ -142,6 +142,8 @@ impl Config {
             component_model_async_builtins,
             component_model_async_stackful,
             simd,
+            exceptions,
+            legacy_exceptions,
 
             hogs_memory: _,
             nan_canonicalization: _,
@@ -157,6 +159,7 @@ impl Config {
             component_model_async_builtins.unwrap_or(false);
         self.module_config.component_model_async_stackful =
             component_model_async_stackful.unwrap_or(false);
+        self.module_config.legacy_exceptions = legacy_exceptions.unwrap_or(false);
 
         // Enable/disable proposals that wasm-smith has knobs for which will be
         // read when creating `wasmtime::Config`.
@@ -175,6 +178,7 @@ impl Config {
             || self.module_config.function_references_enabled
             || reference_types.unwrap_or(false);
         config.extended_const_enabled = extended_const.unwrap_or(false);
+        config.exceptions_enabled = exceptions.unwrap_or(false);
         if multi_memory.unwrap_or(false) {
             config.max_memories = limits::MEMORIES_PER_MODULE as usize;
         } else {
@@ -294,6 +298,8 @@ impl Config {
         cfg.wasm.tail_call = Some(self.module_config.config.tail_call_enabled);
         cfg.wasm.threads = Some(self.module_config.config.threads_enabled);
         cfg.wasm.wide_arithmetic = Some(self.module_config.config.wide_arithmetic_enabled);
+        cfg.wasm.exceptions = Some(self.module_config.config.exceptions_enabled);
+        cfg.wasm.legacy_exceptions = Some(self.module_config.legacy_exceptions);
         if !self.module_config.config.simd_enabled {
             cfg.wasm.relaxed_simd = Some(false);
         }