deps: Upgrade wasmparser to 0.116

Author: theduke

Cargo.lock

@@ -87,6 +87,7 @@ version = "4.2.3"
 webc = { version = "5.5.1", default-features = false, features = ["package"] }
 wasmer-toml = "0.8.0"
 memoffset = "0.9.0"
+wasmparser = { version = "0.116.0", default-features = false }
 
 [build-dependencies]
 test-generator = { path = "tests/lib/test-generator" }

Cargo.toml

@@ -52,7 +52,7 @@ wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=4.2.3", optional
 wasm-bindgen = { version = "0.2.74", optional = true }
 js-sys = { version = "0.3.51", optional = true }
 rusty_jsc = { version = "0.1.0", optional = true }
-wasmparser = { version = "0.83", default-features = false, optional = true }
+wasmparser = { workspace = true, default-features = false, optional = true }
 
 # - Mandatory dependencies for `sys` on Windows.
 [target.'cfg(all(not(target_arch = "wasm32"), target_os = "windows"))'.dependencies]
@@ -72,7 +72,7 @@ wasm-bindgen = "0.2.74"
 js-sys = "0.3.51"
 wasmer-derive = { path = "../derive", version = "=4.2.3" }
 # - Optional dependencies for `js`.
-wasmparser = { version = "0.95", default-features = false, optional = true }
+wasmparser = { workspace = true, default-features = false, optional = true }
 hashbrown = { version = "0.11", optional = true }
 serde-wasm-bindgen = { version = "0.4.5" }
 serde = { version = "1.0", features = ["derive"] }

lib/api/Cargo.toml

@@ -537,6 +537,15 @@ pub enum wasmer_parser_operator_t {
     I16x8DotI8x16I7x16S,
     I32x4DotI8x16I7x16AddS,
     F32x4RelaxedDotBf16x8AddF32x4,
+    RefI31,
+    I31GetS,
+    I31GetU,
+    MemoryDiscard,
+    CallRef,
+    ReturnCallRef,
+    RefAsNonNull,
+    BrOnNull,
+    BrOnNonNull,
 }
 
 impl<'a> From<&Operator<'a>> for wasmer_parser_operator_t {
@@ -1058,14 +1067,14 @@ impl<'a> From<&Operator<'a>> for wasmer_parser_operator_t {
             O::I32x4TruncSatF64x2SZero => Self::I32x4TruncSatF64x2SZero,
             O::I32x4TruncSatF64x2UZero => Self::I32x4TruncSatF64x2UZero,
             O::I8x16RelaxedSwizzle => Self::I8x16RelaxedSwizzle,
-            O::I32x4RelaxedTruncSatF32x4S => Self::I32x4RelaxedTruncSatF32x4S,
-            O::I32x4RelaxedTruncSatF32x4U => Self::I32x4RelaxedTruncSatF32x4U,
-            O::I32x4RelaxedTruncSatF64x2SZero => Self::I32x4RelaxedTruncSatF64x2SZero,
-            O::I32x4RelaxedTruncSatF64x2UZero => Self::I32x4RelaxedTruncSatF64x2UZero,
-            O::F32x4RelaxedFma => Self::F32x4Fma,
-            O::F32x4RelaxedFnma => Self::F32x4Fms,
-            O::F64x2RelaxedFma => Self::F64x2Fma,
-            O::F64x2RelaxedFnma => Self::F64x2Fms,
+            O::I32x4RelaxedTruncF32x4S => Self::I32x4RelaxedTruncSatF32x4S,
+            O::I32x4RelaxedTruncF32x4U => Self::I32x4RelaxedTruncSatF32x4U,
+            O::I32x4RelaxedTruncF64x2SZero => Self::I32x4RelaxedTruncSatF64x2SZero,
+            O::I32x4RelaxedTruncF64x2UZero => Self::I32x4RelaxedTruncSatF64x2UZero,
+            O::F32x4RelaxedMadd => Self::F32x4Fma,
+            O::F32x4RelaxedNmadd => Self::F32x4Fms,
+            O::F64x2RelaxedMadd => Self::F64x2Fma,
+            O::F64x2RelaxedNmadd => Self::F64x2Fms,
             O::I8x16RelaxedLaneselect => Self::I8x16LaneSelect,
             O::I16x8RelaxedLaneselect => Self::I16x8LaneSelect,
             O::I32x4RelaxedLaneselect => Self::I32x4LaneSelect,
@@ -1075,9 +1084,17 @@ impl<'a> From<&Operator<'a>> for wasmer_parser_operator_t {
             O::F64x2RelaxedMin => Self::F64x2RelaxedMin,
             O::F64x2RelaxedMax => Self::F64x2RelaxedMax,
             O::I16x8RelaxedQ15mulrS => Self::I16x8RelaxedQ15mulrS,
-            O::I16x8DotI8x16I7x16S => Self::I16x8DotI8x16I7x16S,
-            O::I32x4DotI8x16I7x16AddS => Self::I32x4DotI8x16I7x16AddS,
-            O::F32x4RelaxedDotBf16x8AddF32x4 => Self::F32x4RelaxedDotBf16x8AddF32x4,
+            O::I16x8RelaxedDotI8x16I7x16S => Self::I16x8DotI8x16I7x16S,
+            O::I32x4RelaxedDotI8x16I7x16AddS => Self::I32x4DotI8x16I7x16AddS,
+            O::RefI31 => Self::RefI31,
+            O::I31GetS => Self::I31GetS,
+            O::I31GetU => Self::I31GetU,
+            O::MemoryDiscard { .. } => Self::MemoryDiscard,
+            O::CallRef { .. } => Self::CallRef,
+            O::ReturnCallRef { .. } => Self::ReturnCallRef,
+            O::RefAsNonNull => Self::RefAsNonNull,
+            O::BrOnNull { .. } => Self::BrOnNull,
+            O::BrOnNonNull { .. } => Self::BrOnNonNull,
         }
     }
 }

lib/c-api/src/wasm_c_api/unstable/parser/operator.rs

@@ -13,7 +13,7 @@ use cranelift_codegen::ir::{AbiParam, ArgumentPurpose, Function, InstBuilder, Si
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
 use std::convert::TryFrom;
-use wasmer_compiler::wasmparser::ValType;
+use wasmer_compiler::wasmparser::HeapType;
 use wasmer_types::entity::EntityRef;
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::VMBuiltinFunctionIndex;
@@ -999,11 +999,11 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
     fn translate_ref_null(
         &mut self,
         mut pos: cranelift_codegen::cursor::FuncCursor,
-        ty: ValType,
+        ty: &HeapType,
     ) -> WasmResult<ir::Value> {
         Ok(match ty {
-            ValType::FuncRef => pos.ins().null(self.reference_type()),
-            ValType::ExternRef => pos.ins().null(self.reference_type()),
+            HeapType::Func => pos.ins().null(self.reference_type()),
+            HeapType::Extern => pos.ins().null(self.reference_type()),
             _ => {
                 return Err(WasmError::Unsupported(
                     "`ref.null T` that is not a `funcref` or an `externref`".into(),

lib/compiler-cranelift/src/func_environ.rs

@@ -236,14 +236,14 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
          *  possible `Block`'s arguments values.
          ***********************************************************************************/
         Operator::Block { blockty } => {
-            let (params, results) = module_translation_state.blocktype_params_results(*blockty)?;
-            let next = block_with_params(builder, results, environ)?;
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let next = block_with_params(builder, results.iter(), environ)?;
             state.push_block(next, params.len(), results.len());
         }
         Operator::Loop { blockty } => {
-            let (params, results) = module_translation_state.blocktype_params_results(*blockty)?;
-            let loop_body = block_with_params(builder, params, environ)?;
-            let next = block_with_params(builder, results, environ)?;
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let loop_body = block_with_params(builder, params.iter(), environ)?;
+            let next = block_with_params(builder, results.iter(), environ)?;
             canonicalise_then_jump(builder, loop_body, state.peekn(params.len()));
             state.push_loop(loop_body, next, params.len(), results.len());
 
@@ -260,23 +260,23 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::If { blockty } => {
             let val = state.pop1();
 
-            let (params, results) = module_translation_state.blocktype_params_results(*blockty)?;
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
             let (destination, else_data) = if params == results {
                 // It is possible there is no `else` block, so we will only
                 // allocate a block for it if/when we find the `else`. For now,
                 // we if the condition isn't true, then we jump directly to the
                 // destination block following the whole `if...end`. If we do end
                 // up discovering an `else`, then we will allocate a block for it
                 // and go back and patch the jump.
-                let destination = block_with_params(builder, results, environ)?;
+                let destination = block_with_params(builder, results.iter(), environ)?;
                 let branch_inst =
                     canonicalise_then_brz(builder, val, destination, state.peekn(params.len()));
                 (destination, ElseData::NoElse { branch_inst })
             } else {
                 // The `if` type signature is not valid without an `else` block,
                 // so we eagerly allocate the `else` block here.
-                let destination = block_with_params(builder, results, environ)?;
-                let else_block = block_with_params(builder, params, environ)?;
+                let destination = block_with_params(builder, results.iter(), environ)?;
+                let else_block = block_with_params(builder, params.iter(), environ)?;
                 canonicalise_then_brz(builder, val, else_block, state.peekn(params.len()));
                 builder.seal_block(else_block);
                 (destination, ElseData::WithElse { else_block })
@@ -326,10 +326,11 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                         // already been pre-allocated, see `ElseData` for details).
                         let else_block = match *else_data {
                             ElseData::NoElse { branch_inst } => {
-                                let (params, _results) =
-                                    module_translation_state.blocktype_params_results(blocktype)?;
+                                let (params, _results) = module_translation_state
+                                    .blocktype_params_results(&blocktype)?;
                                 debug_assert_eq!(params.len(), num_return_values);
-                                let else_block = block_with_params(builder, params, environ)?;
+                                let else_block =
+                                    block_with_params(builder, params.iter(), environ)?;
                                 canonicalise_then_jump(
                                     builder,
                                     destination,
@@ -1039,7 +1040,9 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::F32Le | Operator::F64Le => {
             translate_fcmp(FloatCC::LessThanOrEqual, builder, state)
         }
-        Operator::RefNull { ty } => state.push1(environ.translate_ref_null(builder.cursor(), *ty)?),
+        Operator::RefNull { hty } => {
+            state.push1(environ.translate_ref_null(builder.cursor(), hty)?)
+        }
         Operator::RefIsNull => {
             let value = state.pop1();
             state.push1(environ.translate_ref_is_null(builder.cursor(), value)?);
@@ -2032,14 +2035,14 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             return Err(wasm_unsupported!("proposed tail-call operator {:?}", op));
         }
         Operator::I8x16RelaxedSwizzle
-        | Operator::I32x4RelaxedTruncSatF32x4S
-        | Operator::I32x4RelaxedTruncSatF32x4U
-        | Operator::I32x4RelaxedTruncSatF64x2SZero
-        | Operator::I32x4RelaxedTruncSatF64x2UZero
-        | Operator::F32x4RelaxedFma
-        | Operator::F32x4RelaxedFnma
-        | Operator::F64x2RelaxedFma
-        | Operator::F64x2RelaxedFnma
+        | Operator::I32x4RelaxedTruncF32x4S
+        | Operator::I32x4RelaxedTruncF32x4U
+        | Operator::I32x4RelaxedTruncF64x2SZero
+        | Operator::I32x4RelaxedTruncF64x2UZero
+        | Operator::F32x4RelaxedMadd
+        | Operator::F32x4RelaxedNmadd
+        | Operator::F64x2RelaxedMadd
+        | Operator::F64x2RelaxedNmadd
         | Operator::I8x16RelaxedLaneselect
         | Operator::I16x8RelaxedLaneselect
         | Operator::I32x4RelaxedLaneselect
@@ -2048,12 +2051,44 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::F32x4RelaxedMax
         | Operator::F64x2RelaxedMin
         | Operator::F64x2RelaxedMax
-        | Operator::F32x4RelaxedDotBf16x8AddF32x4
-        | Operator::I16x8RelaxedQ15mulrS
-        | Operator::I16x8DotI8x16I7x16S
-        | Operator::I32x4DotI8x16I7x16AddS => {
+        | Operator::I16x8RelaxedDotI8x16I7x16S => todo!(),
+        Operator::I32x4RelaxedDotI8x16I7x16AddS => todo!(),
+        Operator::I16x8RelaxedQ15mulrS => {
             return Err(wasm_unsupported!("proposed relaxed-simd operator {:?}", op));
         }
+        Operator::RefI31 | Operator::I31GetS | Operator::I31GetU => {
+            return Err(wasm_unsupported!("proposed i31 operator {:?}", op));
+        }
+        Operator::MemoryDiscard { mem: _ } => {
+            return Err(wasm_unsupported!(
+                "proposed memory-discard operator {:?}",
+                op
+            ));
+        }
+        Operator::CallRef { type_index: _ } => {
+            return Err(wasm_unsupported!("proposed call-ref operator {:?}", op));
+        }
+        Operator::ReturnCallRef { type_index: _ } => {
+            return Err(wasm_unsupported!(
+                "proposed return-call-ref operator {:?}",
+                op
+            ));
+        }
+        Operator::RefAsNonNull => {
+            return Err(wasm_unsupported!(
+                "proposed ref-as-non-null operator {:?}",
+                op
+            ));
+        }
+        Operator::BrOnNull { relative_depth: _ } => {
+            return Err(wasm_unsupported!("proposed br-on-null operator {:?}", op));
+        }
+        Operator::BrOnNonNull { relative_depth: _ } => {
+            return Err(wasm_unsupported!(
+                "proposed br-on-non-null operator {:?}",
+                op
+            ));
+        }
     };
     Ok(())
 }
@@ -2107,9 +2142,10 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
 
                         let else_block = match *else_data {
                             ElseData::NoElse { branch_inst } => {
-                                let (params, _results) =
-                                    module_translation_state.blocktype_params_results(blocktype)?;
-                                let else_block = block_with_params(builder, params, environ)?;
+                                let (params, _results) = module_translation_state
+                                    .blocktype_params_results(&blocktype)?;
+                                let else_block =
+                                    block_with_params(builder, params.iter(), environ)?;
                                 let frame = state.control_stack.last().unwrap();
                                 frame.truncate_value_stack_to_else_params(&mut state.stack);
 

lib/compiler-cranelift/src/translator/code_translator.rs

@@ -12,7 +12,7 @@ use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
-use wasmer_compiler::wasmparser::{Operator, ValType};
+use wasmer_compiler::wasmparser::{HeapType, Operator};
 use wasmer_types::{
     FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
     TableIndex, Type as WasmerType, WasmResult,
@@ -359,7 +359,7 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// null sentinel is not a null reference type pointer for your type. If you
     /// override this method, then you should also override
     /// `translate_ref_is_null` as well.
-    fn translate_ref_null(&mut self, pos: FuncCursor, ty: ValType) -> WasmResult<ir::Value>;
+    fn translate_ref_null(&mut self, pos: FuncCursor, ty: &HeapType) -> WasmResult<ir::Value>;
     // {
     //     let _ = ty;
     //     Ok(pos.ins().null(self.reference_type(ty)))

lib/compiler-cranelift/src/translator/func_environ.rs

@@ -15,9 +15,9 @@ use cranelift_codegen::entity::EntityRef;
 use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
-use wasmer_compiler::wasmparser;
+use wasmer_compiler::wasmparser::{self, RefType};
 use wasmer_compiler::{wptype_to_type, FunctionBinaryReader, ModuleTranslationState};
-use wasmer_types::{LocalFunctionIndex, WasmResult};
+use wasmer_types::{LocalFunctionIndex, WasmError, WasmResult};
 
 /// WebAssembly to Cranelift IR function translator.
 ///
@@ -194,8 +194,16 @@ fn declare_locals<FE: FuncEnvironment + ?Sized>(
             let constant_handle = builder.func.dfg.constants.insert([0; 16].to_vec().into());
             builder.ins().vconst(ir::types::I8X16, constant_handle)
         }
-        ExternRef => builder.ins().null(environ.reference_type()),
-        FuncRef => builder.ins().null(environ.reference_type()),
+        Ref(rt) => match rt {
+            RefType::FUNC => builder.ins().null(environ.reference_type()),
+            RefType::EXTERN => builder.ins().null(environ.reference_type()),
+            other => {
+                return Err(WasmError::Unsupported(format!(
+                    "Unsupported reference type: {:?}",
+                    other
+                )))
+            }
+        },
     };
 
     let wasmer_ty = wptype_to_type(wasm_type).unwrap();