deps: update to wasmparser@0.100.0

.github/workflows/main.yml

@@ -20,7 +20,7 @@ jobs:
     - uses: actions/checkout@v2
       with:
         repository: WebAssembly/wabt
-        ref: aa0515b3c808da880942db8658abeaa969534667
+        ref: f02fa321d5f8392fcb02f0a5d5ff72b901e29a78
         path: wabt
     - name: Build wabt
       run: |
@@ -51,8 +51,8 @@ jobs:
     - name: Install wabt
       run: |
         set -e
-        curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.13/wabt-1.0.13-linux.tar.gz | tar xzf -
-        echo "`pwd`/wabt-1.0.13" > $GITHUB_PATH
+        curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.33/wabt-1.0.33-ubuntu.tar.gz | tar xzf -
+        echo "`pwd`/wabt-1.0.33" > $GITHUB_PATH
     - name: Install binaryen
       run: |
         set -e
@@ -78,8 +78,8 @@ jobs:
     - name: Install wabt
       run: |
         set -e
-        curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.13/wabt-1.0.13-linux.tar.gz | tar xzf -
-        echo "`pwd`/wabt-1.0.13" > $GITHUB_PATH
+        curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.33/wabt-1.0.33-ubuntu.tar.gz | tar xzf -
+        echo "`pwd`/wabt-1.0.33" > $GITHUB_PATH
     - name: Install binaryen
       run: |
         set -e

Cargo.toml

@@ -30,7 +30,7 @@ log = "0.4.8"
 rayon = { version = "1.1.0", optional = true }
 walrus-macro = { path = './crates/macro', version = '=0.19.0' }
 wasm-encoder = "0.41.0"
-wasmparser = "0.80.2"
+wasmparser = "0.100.0"
 gimli = "0.26.0"
 
 [features]

crates/tests/tests/spec-tests.rs

@@ -22,18 +22,29 @@ fn run(wast: &Path) -> Result<(), anyhow::Error> {
         .skip(1)
         .next()
         .map(|s| s.to_str().unwrap());
+
+    let mut config = walrus::ModuleConfig::new();
     let extra_args: &[&str] = match proposal {
         // stable features
-        None
-        | Some("multi-value")
+        Some("multi-value")
         | Some("nontrapping-float-to-int-conversions")
         | Some("sign-extension-ops")
-        | Some("mutable-global") => &[],
+        | Some("mutable-global")
+        | Some("simd") => {
+            config.only_stable_features(true);
+            &[]
+        }
+
+        None | Some("bulk-memory-operations") => &[],
+
+        Some("multi-memory") => &["--enable-multi-memory"],
 
-        Some("simd") => &["--enable-simd"],
-        Some("bulk-memory-operations") => &["--enable-bulk-memory"],
+        Some("reference-types") => &[],
 
-        Some("reference-types") => &["--enable-reference-types", "--enable-bulk-memory"],
+        Some("extended-const") => &["--enable-extended-const"],
+
+        Some("relaxed-simd") => return Ok(()),
+        Some("gc") => return Ok(()),
 
         // TODO: should get threads working
         Some("threads") => return Ok(()),
@@ -69,11 +80,6 @@ fn run(wast: &Path) -> Result<(), anyhow::Error> {
     let test: Test = serde_json::from_str(&contents).context("failed to parse file")?;
     let mut files = Vec::new();
 
-    let mut config = walrus::ModuleConfig::new();
-    if extra_args.len() == 0 {
-        config.only_stable_features(true);
-    }
-
     for command in test.commands {
         let filename = match command.get("filename") {
             Some(name) => name.as_str().unwrap().to_string(),

src/init_expr.rs

@@ -22,7 +22,7 @@ pub enum InitExpr {
 }
 
 impl InitExpr {
-    pub(crate) fn eval(init: &wasmparser::InitExpr, ids: &IndicesToIds) -> Result<InitExpr> {
+    pub(crate) fn eval(init: &wasmparser::ConstExpr, ids: &IndicesToIds) -> Result<InitExpr> {
         use wasmparser::Operator::*;
         let mut reader = init.get_operators_reader();
         let val = match reader.read()? {

src/ir/mod.rs

@@ -496,7 +496,7 @@ pub enum Instr {
     },
 
     /// The `atomic.fence` instruction
-    AtomicFence {},
+    AtomicFence,
 
     /// `table.get`
     TableGet {
@@ -717,6 +717,10 @@ pub enum BinaryOp {
     I64x2ReplaceLane { idx: u8 },
     F32x4ReplaceLane { idx: u8 },
     F64x2ReplaceLane { idx: u8 },
+    I8x16RelaxedLaneselect,
+    I16x8RelaxedLaneselect,
+    I32x4RelaxedLaneselect,
+    I64x2RelaxedLaneselect,
 
     I8x16Eq,
     I8x16Ne,
@@ -817,6 +821,8 @@ pub enum BinaryOp {
     F32x4Max,
     F32x4PMin,
     F32x4PMax,
+    F32x4RelaxedFma,
+    F32x4RelaxedFnma,
     F64x2Add,
     F64x2Sub,
     F64x2Mul,
@@ -825,13 +831,18 @@ pub enum BinaryOp {
     F64x2Max,
     F64x2PMin,
     F64x2PMax,
+    F64x2RelaxedFma,
+    F64x2RelaxedFnma,
+    F64x2MinRelaxed,
+    F64x2MaxRelaxed,
 
+    I8x16RelaxedSwizzle,
     I8x16NarrowI16x8S,
     I8x16NarrowI16x8U,
     I16x8NarrowI32x4S,
     I16x8NarrowI32x4U,
-    I8x16RoundingAverageU,
-    I16x8RoundingAverageU,
+    I8x16AvgrU,
+    I16x8AvgrU,
 
     I8x16MinS,
     I8x16MinU,
@@ -970,6 +981,10 @@ pub enum UnaryOp {
     F32x4Floor,
     F32x4Trunc,
     F32x4Nearest,
+    F32x4FmaRelaxed,
+    F32x4FmsRelaxed,
+    F32x4MinRelaxed,
+    F32x4MaxRelaxed,
     F64x2Abs,
     F64x2Neg,
     F64x2Sqrt,
@@ -982,6 +997,10 @@ pub enum UnaryOp {
     I16x8ExtAddPairwiseI8x16U,
     I32x4ExtAddPairwiseI16x8S,
     I32x4ExtAddPairwiseI16x8U,
+    I32x4TruncSatF32x4SRelaxed,
+    I32x4TruncSatF32x4URelaxed,
+    I32x4TruncSatF64x2SZeroRelaxed,
+    I32x4TruncSatF64x2UZeroRelaxed,
     I64x2ExtendLowI32x4S,
     I64x2ExtendHighI32x4S,
     I64x2ExtendLowI32x4U,

src/module/data.rs

@@ -1,10 +1,11 @@
 //! Data segments within a wasm module.
 
 use crate::emit::{Emit, EmitContext};
+use crate::init_expr::InitExpr;
 use crate::ir::Value;
 use crate::parse::IndicesToIds;
 use crate::tombstone_arena::{Id, Tombstone, TombstoneArena};
-use crate::{GlobalId, InitExpr, MemoryId, Module, Result, ValType};
+use crate::{GlobalId, MemoryId, Module, Result, ValType};
 use anyhow::{bail, Context};
 
 /// A passive element segment identifier
@@ -222,15 +223,15 @@ impl Module {
                 }
                 wasmparser::DataKind::Active {
                     memory_index,
-                    init_expr,
+                    offset_expr,
                 } => {
                     data.value = segment.data.to_vec();
 
                     let memory_id = ids.get_memory(memory_index)?;
                     let memory = self.memories.get_mut(memory_id);
                     memory.data_segments.insert(data.id);
 
-                    let offset = InitExpr::eval(&init_expr, ids)
+                    let offset = InitExpr::eval(&offset_expr, ids)
                         .with_context(|| format!("in segment {}", i))?;
                     data.kind = DataKind::Active(ActiveData {
                         memory: memory_id,

src/module/debug/expression.rs

@@ -1,6 +1,6 @@
 use crate::{CodeTransform, Function, InstrLocId, ModuleFunctions};
 use id_arena::Id;
-use std::cmp::Ordering;
+use std::{cmp::Ordering, ops::Range};
 
 use super::dwarf::AddressSearchPreference;
 
@@ -22,7 +22,7 @@ pub(crate) enum CodeAddress {
 /// Converts original code address to CodeAddress
 pub(crate) struct CodeAddressGenerator {
     /// Function range based convert table
-    address_convert_table: Vec<(wasmparser::Range, Id<Function>)>,
+    address_convert_table: Vec<(Range<usize>, Id<Function>)>,
     /// Instrument based convert table
     instrument_address_convert_table: Vec<(usize, InstrLocId)>,
 }
@@ -31,7 +31,7 @@ impl CodeAddressGenerator {
     pub(crate) fn new(funcs: &ModuleFunctions) -> Self {
         let mut address_convert_table = funcs
             .iter_local()
-            .filter_map(|(func_id, func)| func.original_range.map(|range| (range, func_id)))
+            .filter_map(|(func_id, func)| func.original_range.clone().map(|range| (range, func_id)))
             .collect::<Vec<_>>();
 
         let mut instrument_address_convert_table = funcs
@@ -75,7 +75,7 @@ impl CodeAddressGenerator {
         };
 
         // If the address is not mapped to any instruction, falling back to function-range-based comparison.
-        let inclusive_range_comparor = |range: &(wasmparser::Range, Id<Function>)| {
+        let inclusive_range_comparor = |range: &(Range<usize>, Id<Function>)| {
             // range.start < address <= range.end
             if range.0.end < address {
                 Ordering::Less
@@ -85,7 +85,7 @@ impl CodeAddressGenerator {
                 Ordering::Equal
             }
         };
-        let exclusive_range_comparor = |range: &(wasmparser::Range, Id<Function>)| {
+        let exclusive_range_comparor = |range: &(Range<usize>, Id<Function>)| {
             // normal comparison: range.start <= address < range.end
             if range.0.end <= address {
                 Ordering::Less
@@ -189,7 +189,7 @@ mod tests {
             crate::FunctionBuilder::new(&mut module.types, &[], &[]),
         );
 
-        func1.original_range = Some(wasmparser::Range { start: 20, end: 30 });
+        func1.original_range = Some(Range { start: 20, end: 30 });
 
         let id1 = module.funcs.add_local(func1);
 
@@ -198,7 +198,7 @@ mod tests {
             crate::FunctionBuilder::new(&mut module.types, &[], &[]),
         );
 
-        func2.original_range = Some(wasmparser::Range { start: 30, end: 50 });
+        func2.original_range = Some(Range { start: 30, end: 50 });
 
         let id2 = module.funcs.add_local(func2);
 
@@ -262,7 +262,7 @@ mod tests {
         {
             code_transform
                 .function_ranges
-                .push((id1, wasmparser::Range { start: 50, end: 80 }));
+                .push((id1, Range { start: 50, end: 80 }));
             code_transform.instruction_map.push((instr_id1, 60));
             code_transform.instruction_map.push((instr_id2, 65));
         }

src/module/elements.rs

@@ -1,9 +1,10 @@
 //! Table elements within a wasm module.
 
 use crate::emit::{Emit, EmitContext};
+use crate::init_expr::InitExpr;
 use crate::parse::IndicesToIds;
 use crate::tombstone_arena::{Id, Tombstone, TombstoneArena};
-use crate::{ir::Value, FunctionId, InitExpr, Module, Result, TableId, ValType};
+use crate::{ir::Value, FunctionId, Module, Result, TableId, ValType};
 use anyhow::{bail, Context};
 
 /// A passive element segment identifier
@@ -116,30 +117,28 @@ impl Module {
                 ValType::Funcref => {}
                 _ => bail!("only funcref type allowed in element segments"),
             }
-            let members = segment
-                .items
-                .get_items_reader()?
-                .into_iter()
-                .map(|e| -> Result<_> {
-                    Ok(match e? {
-                        wasmparser::ElementItem::Func(f) => Some(ids.get_func(f)?),
-                        wasmparser::ElementItem::Null(_) => None,
-                    })
-                })
-                .collect::<Result<_>>()?;
+            let members = match segment.items {
+                wasmparser::ElementItems::Functions(funcs) => funcs
+                    .into_iter()
+                    .map(|f| Ok(Some(ids.get_func(f?)?)))
+                    .collect::<Result<_>>()?,
+                wasmparser::ElementItems::Expressions(exprs) => {
+                    exprs.into_iter().map(|_| Ok(None)).collect::<Result<_>>()?
+                }
+            };
             let id = self.elements.arena.next_id();
 
             let kind = match segment.kind {
                 wasmparser::ElementKind::Passive => ElementKind::Passive,
                 wasmparser::ElementKind::Declared => ElementKind::Declared,
                 wasmparser::ElementKind::Active {
                     table_index,
-                    init_expr,
+                    offset_expr,
                 } => {
                     let table = ids.get_table(table_index)?;
                     self.tables.get_mut(table).elem_segments.insert(id);
 
-                    let offset = InitExpr::eval(&init_expr, ids)
+                    let offset = InitExpr::eval(&offset_expr, ids)
                         .with_context(|| format!("in segment {}", i))?;
                     match offset {
                         InitExpr::Value(Value::I32(_)) => {}

src/module/exports.rs

@@ -164,20 +164,17 @@ impl Module {
         for entry in section {
             let entry = entry?;
             let item = match entry.kind {
-                Function => ExportItem::Function(ids.get_func(entry.index)?),
+                Func => ExportItem::Function(ids.get_func(entry.index)?),
                 Table => ExportItem::Table(ids.get_table(entry.index)?),
                 Memory => ExportItem::Memory(ids.get_memory(entry.index)?),
                 Global => ExportItem::Global(ids.get_global(entry.index)?),
-                Type | Module | Instance => {
-                    unimplemented!("module linking not supported");
-                }
                 Tag => {
                     unimplemented!("exception handling not supported");
                 }
             };
             self.exports.arena.alloc_with_id(|id| Export {
                 id,
-                name: entry.field.to_string(),
+                name: entry.name.to_string(),
                 item,
             });
         }