Update wasmparser: 0.83.0 => 0.90.0 (#415)

* update wasmparser 0.83 -> 0.90 * fix doc link
wasmi-labs · Aug 26, 2022 · e9b0463 · e9b0463
1 parent 944a88a
commit e9b0463
Show file tree

Hide file tree

Showing 12 changed files with 138 additions and 163 deletions.
diff --git a/wasmi_v1/Cargo.toml b/wasmi_v1/Cargo.toml
@@ -12,7 +12,7 @@ keywords = ["wasm", "webassembly", "bytecode", "interpreter"]
 exclude = [ "tests/*", "benches/*" ]
 
 [dependencies]
-wasmparser = { version = "0.83", package = "wasmparser-nostd", default-features = false }
+wasmparser = { version = "0.90", package = "wasmparser-nostd", default-features = false }
 wasmi_core = { version = "0.3", path = "../core", default-features = false }
 spin = { version = "0.9", default-features = false, features = ["mutex", "spin_mutex"] }
 

diff --git a/wasmi_v1/src/engine/config.rs b/wasmi_v1/src/engine/config.rs
@@ -100,7 +100,7 @@ impl Config {
             sign_extension: self.sign_extension,
             reference_types: false,
             bulk_memory: false,
-            module_linking: false,
+            component_model: false,
             simd: false,
             relaxed_simd: false,
             threads: false,

diff --git a/wasmi_v1/src/module/compile/block_type.rs b/wasmi_v1/src/module/compile/block_type.rs
@@ -19,22 +19,22 @@ pub enum BlockTypeInner {
 }
 
 impl BlockType {
-    /// Creates a new [`BlockType`] from the given [`wasmparser::TypeOrFuncType`].
+    /// Creates a new [`BlockType`] from the given [`wasmparser::BlockType`].
     ///
     /// # Errors
     ///
     /// If the conversion is not valid or unsupported.
     pub(super) fn try_from_wasmparser(
-        type_or_func_type: wasmparser::TypeOrFuncType,
+        type_or_func_type: wasmparser::BlockType,
         res: ModuleResources,
     ) -> Result<Self, ModuleError> {
         let block_type = match type_or_func_type {
-            wasmparser::TypeOrFuncType::Type(wasmparser::Type::EmptyBlockType) => Self::empty(),
-            wasmparser::TypeOrFuncType::Type(return_type) => {
+            wasmparser::BlockType::Empty => Self::empty(),
+            wasmparser::BlockType::Type(return_type) => {
                 let return_type = value_type_from_wasmparser(&return_type)?;
                 Self::returns(return_type)
             }
-            wasmparser::TypeOrFuncType::FuncType(func_type_idx) => {
+            wasmparser::BlockType::FuncType(func_type_idx) => {
                 let dedup_func_type = res.get_func_type(FuncTypeIdx(func_type_idx));
                 Self::func_type(dedup_func_type)
             }

diff --git a/wasmi_v1/src/module/compile/mod.rs b/wasmi_v1/src/module/compile/mod.rs
@@ -128,9 +128,11 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
             Operator::BrTable { table } => self.translate_br_table(table),
             Operator::Return => self.translate_return(),
             Operator::Call { function_index } => self.translate_call(function_index),
-            Operator::CallIndirect { index, table_index } => {
-                self.translate_call_indirect(index, table_index)
-            }
+            Operator::CallIndirect {
+                index,
+                table_index,
+                table_byte: _,
+            } => self.translate_call_indirect(index, table_index),
             Operator::ReturnCall { .. }
             | Operator::ReturnCallIndirect { .. }
             | Operator::Delegate { .. }

diff --git a/wasmi_v1/src/module/compile/operator.rs b/wasmi_v1/src/module/compile/operator.rs
@@ -4,7 +4,7 @@ use crate::{
     module::{export::TableIdx, import::FuncTypeIdx, FuncIdx, GlobalIdx, MemoryIdx},
     ModuleError,
 };
-use wasmparser::{Ieee32, Ieee64, TypeOrFuncType};
+use wasmparser::{Ieee32, Ieee64};
 
 impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `nop` (no operation) instruction.
@@ -17,21 +17,21 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `block` control flow operator.
-    pub fn translate_block(&mut self, ty: TypeOrFuncType) -> Result<(), ModuleError> {
+    pub fn translate_block(&mut self, ty: wasmparser::BlockType) -> Result<(), ModuleError> {
         let block_type = BlockType::try_from_wasmparser(ty, self.res)?;
         self.func_builder.translate_block(block_type)?;
         Ok(())
     }
 
     /// Translate a Wasm `loop` control flow operator.
-    pub fn translate_loop(&mut self, ty: TypeOrFuncType) -> Result<(), ModuleError> {
+    pub fn translate_loop(&mut self, ty: wasmparser::BlockType) -> Result<(), ModuleError> {
         let block_type = BlockType::try_from_wasmparser(ty, self.res)?;
         self.func_builder.translate_loop(block_type)?;
         Ok(())
     }
 
     /// Translate a Wasm `if` control flow operator.
-    pub fn translate_if(&mut self, ty: TypeOrFuncType) -> Result<(), ModuleError> {
+    pub fn translate_if(&mut self, ty: wasmparser::BlockType) -> Result<(), ModuleError> {
         let block_type = BlockType::try_from_wasmparser(ty, self.res)?;
         self.func_builder.translate_if(block_type)?;
         Ok(())
@@ -117,54 +117,39 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `i32.load` instruction.
-    pub fn translate_i32_load(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i32_load(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_i32_load(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `i64.load` instruction.
-    pub fn translate_i64_load(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i64_load(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_i64_load(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `f32.load` instruction.
-    pub fn translate_f32_load(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_f32_load(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_f32_load(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `f64.load` instruction.
-    pub fn translate_f64_load(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_f64_load(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_f64_load(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `i32.load_i8` instruction.
-    pub fn translate_i32_load_i8(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i32_load_i8(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder
@@ -173,10 +158,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `i32.load_u8` instruction.
-    pub fn translate_i32_load_u8(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i32_load_u8(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder
@@ -187,7 +169,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i32.load_i16` instruction.
     pub fn translate_i32_load_i16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -199,7 +181,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i32.load_u16` instruction.
     pub fn translate_i32_load_u16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -209,10 +191,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `i64.load_i8` instruction.
-    pub fn translate_i64_load_i8(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i64_load_i8(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder
@@ -221,10 +200,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `i64.load_u8` instruction.
-    pub fn translate_i64_load_u8(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i64_load_u8(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder
@@ -235,7 +211,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.load_i16` instruction.
     pub fn translate_i64_load_i16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -247,7 +223,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.load_u16` instruction.
     pub fn translate_i64_load_u16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -259,7 +235,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.load_i32` instruction.
     pub fn translate_i64_load_i32(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -271,7 +247,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.load_u32` instruction.
     pub fn translate_i64_load_u32(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -281,43 +257,31 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     }
 
     /// Translate a Wasm `i32.store` instruction.
-    pub fn translate_i32_store(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i32_store(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_i32_store(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `i64.store` instruction.
-    pub fn translate_i64_store(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_i64_store(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_i64_store(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `f32.store` instruction.
-    pub fn translate_f32_store(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_f32_store(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_f32_store(memory_idx, offset)?;
         Ok(())
     }
 
     /// Translate a Wasm `f64.store` instruction.
-    pub fn translate_f64_store(
-        &mut self,
-        memarg: wasmparser::MemoryImmediate,
-    ) -> Result<(), ModuleError> {
+    pub fn translate_f64_store(&mut self, memarg: wasmparser::MemArg) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
         self.func_builder.translate_f64_store(memory_idx, offset)?;
@@ -327,7 +291,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i32.store_i8` instruction.
     pub fn translate_i32_store_i8(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -339,7 +303,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i32.store_i16` instruction.
     pub fn translate_i32_store_i16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -351,7 +315,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.store_i8` instruction.
     pub fn translate_i64_store_i8(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -363,7 +327,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.store_i16` instruction.
     pub fn translate_i64_store_i16(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;
@@ -375,7 +339,7 @@ impl<'alloc, 'parser> FunctionTranslator<'alloc, 'parser> {
     /// Translate a Wasm `i64.store_i32` instruction.
     pub fn translate_i64_store_i32(
         &mut self,
-        memarg: wasmparser::MemoryImmediate,
+        memarg: wasmparser::MemArg,
     ) -> Result<(), ModuleError> {
         let memory_idx = MemoryIdx(memarg.memory);
         let offset = memarg.offset as u32;

diff --git a/wasmi_v1/src/module/data.rs b/wasmi_v1/src/module/data.rs
@@ -18,10 +18,10 @@ impl TryFrom<wasmparser::Data<'_>> for DataSegment {
         let (memory_index, offset) = match data.kind {
             wasmparser::DataKind::Active {
                 memory_index,
-                init_expr,
+                offset_expr,
             } => {
                 let memory_index = MemoryIdx(memory_index);
-                let offset = InitExpr::try_from(init_expr)?;
+                let offset = InitExpr::try_from(offset_expr)?;
                 (memory_index, offset)
             }
             wasmparser::DataKind::Passive => {

diff --git a/wasmi_v1/src/module/element.rs b/wasmi_v1/src/module/element.rs
@@ -17,16 +17,16 @@ impl TryFrom<wasmparser::Element<'_>> for ElementSegment {
     type Error = ModuleError;
 
     fn try_from(element: wasmparser::Element<'_>) -> Result<Self, Self::Error> {
-        if !matches!(element.ty, wasmparser::Type::FuncRef) {
+        if !matches!(element.ty, wasmparser::ValType::FuncRef) {
             return Err(ModuleError::unsupported(element.ty));
         }
         let (table_index, offset) = match element.kind {
             wasmparser::ElementKind::Active {
                 table_index,
-                init_expr,
+                offset_expr,
             } => {
                 let table_index = TableIdx(table_index);
-                let offset = InitExpr::try_from(init_expr)?;
+                let offset = InitExpr::try_from(offset_expr)?;
                 (table_index, offset)
             }
             wasmparser::ElementKind::Passive | wasmparser::ElementKind::Declared => {

diff --git a/wasmi_v1/src/module/export.rs b/wasmi_v1/src/module/export.rs
@@ -71,7 +71,7 @@ impl TryFrom<wasmparser::Export<'_>> for Export {
     type Error = ModuleError;
 
     fn try_from(export: wasmparser::Export<'_>) -> Result<Self, Self::Error> {
-        let field = export.field.into();
+        let field = export.name.into();
         let external = (export.kind, export.index).try_into()?;
         Ok(Export { field, external })
     }
@@ -117,14 +117,11 @@ impl TryFrom<(wasmparser::ExternalKind, u32)> for External {
 
     fn try_from((kind, index): (wasmparser::ExternalKind, u32)) -> Result<Self, Self::Error> {
         match kind {
-            wasmparser::ExternalKind::Function => Ok(External::Func(FuncIdx(index))),
+            wasmparser::ExternalKind::Func => Ok(External::Func(FuncIdx(index))),
             wasmparser::ExternalKind::Table => Ok(External::Table(TableIdx(index))),
             wasmparser::ExternalKind::Memory => Ok(External::Memory(MemoryIdx(index))),
             wasmparser::ExternalKind::Global => Ok(External::Global(GlobalIdx(index))),
-            wasmparser::ExternalKind::Tag
-            | wasmparser::ExternalKind::Type
-            | wasmparser::ExternalKind::Module
-            | wasmparser::ExternalKind::Instance => Err(ModuleError::unsupported(kind)),
+            wasmparser::ExternalKind::Tag => Err(ModuleError::unsupported(kind)),
         }
     }
 }