fix: fix remaining issues with extended-const

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

Author: explodingcamera

crates/parser/src/conversion.rs

@@ -235,29 +235,45 @@ pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> ValType {
     }
 }
 
-pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<ConstInstruction> {
+pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<Box<[ConstInstruction]>> {
     let ops = ops.into_iter().collect::<wasmparser::Result<Vec<_>>>()?;
     // In practice, the len can never be something other than 2,
     // but we'll keep this here since it's part of the spec
     // Invalid modules will be rejected by the validator anyway (there are also tests for this in the testsuite)
     assert!(ops.len() >= 2);
     assert!(matches!(ops[ops.len() - 1], wasmparser::Operator::End));
 
-    match &ops[ops.len() - 2] {
-        wasmparser::Operator::RefNull { hty } => match convert_heaptype(*hty) {
-            ValType::RefFunc => Ok(ConstInstruction::RefFunc(None)),
-            ValType::RefExtern => Ok(ConstInstruction::RefExtern(None)),
-            _ => unimplemented!("Unsupported heap type: {:?}", hty),
-        },
-        wasmparser::Operator::RefFunc { function_index } => Ok(ConstInstruction::RefFunc(Some(*function_index))),
-        wasmparser::Operator::I32Const { value } => Ok(ConstInstruction::I32Const(*value)),
-        wasmparser::Operator::I64Const { value } => Ok(ConstInstruction::I64Const(*value)),
-        wasmparser::Operator::F32Const { value } => Ok(ConstInstruction::F32Const(f32::from_bits(value.bits()))),
-        wasmparser::Operator::F64Const { value } => Ok(ConstInstruction::F64Const(f64::from_bits(value.bits()))),
-        wasmparser::Operator::V128Const { value } => Ok(ConstInstruction::V128Const(value.i128())),
-        wasmparser::Operator::GlobalGet { global_index } => Ok(ConstInstruction::GlobalGet(*global_index)),
-        op => Err(crate::ParseError::UnsupportedOperator(format!("Unsupported const instruction: {op:?}"))),
+    let mut out = Vec::with_capacity(ops.len().saturating_sub(1));
+    for op in ops.iter().take(ops.len() - 1) {
+        let instr = match op {
+            wasmparser::Operator::RefNull { hty } => match convert_heaptype(*hty) {
+                ValType::RefFunc => ConstInstruction::RefFunc(None),
+                ValType::RefExtern => ConstInstruction::RefExtern(None),
+                _ => unimplemented!("Unsupported heap type: {:?}", hty),
+            },
+            wasmparser::Operator::RefFunc { function_index } => ConstInstruction::RefFunc(Some(*function_index)),
+            wasmparser::Operator::I32Const { value } => ConstInstruction::I32Const(*value),
+            wasmparser::Operator::I64Const { value } => ConstInstruction::I64Const(*value),
+            wasmparser::Operator::F32Const { value } => ConstInstruction::F32Const(f32::from_bits(value.bits())),
+            wasmparser::Operator::F64Const { value } => ConstInstruction::F64Const(f64::from_bits(value.bits())),
+            wasmparser::Operator::V128Const { value } => ConstInstruction::V128Const(value.i128()),
+            wasmparser::Operator::GlobalGet { global_index } => ConstInstruction::GlobalGet(*global_index),
+            wasmparser::Operator::I32Add => ConstInstruction::I32Add,
+            wasmparser::Operator::I32Sub => ConstInstruction::I32Sub,
+            wasmparser::Operator::I32Mul => ConstInstruction::I32Mul,
+            wasmparser::Operator::I64Add => ConstInstruction::I64Add,
+            wasmparser::Operator::I64Sub => ConstInstruction::I64Sub,
+            wasmparser::Operator::I64Mul => ConstInstruction::I64Mul,
+            other => {
+                return Err(crate::ParseError::UnsupportedOperator(format!(
+                    "Unsupported const instruction: {other:?}"
+                )));
+            }
+        };
+        out.push(instr);
     }
+
+    Ok(out.into_boxed_slice())
 }
 
 pub(crate) fn convert_heaptype(heap: wasmparser::HeapType) -> ValType {

crates/parser/src/lib.rs

@@ -90,6 +90,7 @@ impl Parser {
             | WasmFeatures::BULK_MEMORY
             | WasmFeatures::SATURATING_FLOAT_TO_INT
             | WasmFeatures::SIGN_EXTENSION
+            | WasmFeatures::EXTENDED_CONST
             | WasmFeatures::FUNCTION_REFERENCES
             | WasmFeatures::TAIL_CALL
             | WasmFeatures::MULTI_MEMORY

crates/tinywasm/Cargo.toml

@@ -98,7 +98,6 @@ harness=false
 [[test]]
 name="test-wasm-extended-const"
 harness=false
-test=false
 
 [[test]]
 name="test-wasm-relaxed-simd"

crates/tinywasm/src/instance.rs

@@ -152,7 +152,8 @@ impl ModuleInstance {
         let global_addrs = store.init_globals(addrs.globals, &module.0.globals, &addrs.funcs, idx)?;
         let (elem_addrs, elem_trapped) =
             store.init_elements(&addrs.tables, &addrs.funcs, &global_addrs, &module.0.elements, idx)?;
-        let (data_addrs, data_trapped) = store.init_data(&addrs.memories, &module.0.data, idx)?;
+        let (data_addrs, data_trapped) =
+            store.init_data(&addrs.memories, &global_addrs, &addrs.funcs, &module.0.data, idx)?;
 
         let instance = ModuleInstanceInner {
             store_id: store.id(),

crates/tinywasm/src/module.rs

@@ -1,32 +1,6 @@
 use crate::{Imports, ModuleInstance, Result, Store};
 use tinywasm_types::{ExternalKind, FuncType, TinyWasmModule};
 
-fn imported_func_type(module: &TinyWasmModule, function_index: usize) -> Option<&FuncType> {
-    let mut seen = 0usize;
-    for import in module.imports.iter() {
-        if let tinywasm_types::ImportKind::Function(type_idx) = import.kind {
-            if seen == function_index {
-                return module.func_types.get(type_idx as usize);
-            }
-            seen += 1;
-        }
-    }
-    None
-}
-
-fn imported_global_type(module: &TinyWasmModule, global_index: usize) -> Option<&tinywasm_types::GlobalType> {
-    let mut seen = 0usize;
-    for import in module.imports.iter() {
-        if let tinywasm_types::ImportKind::Global(global_ty) = &import.kind {
-            if seen == global_index {
-                return Some(global_ty);
-            }
-            seen += 1;
-        }
-    }
-    None
-}
-
 /// A module import descriptor.
 pub struct ModuleImport<'a> {
     /// Importing module name.
@@ -146,33 +120,24 @@ impl Module {
     /// The returned data mirrors the module's export section and preserves order.
     pub fn exports(&self) -> impl Iterator<Item = ModuleExport<'_>> {
         self.0.exports.iter().filter_map(|export| {
+            let imports = self.0.imports.iter();
+            let idx = export.index as usize;
             let ty = match export.kind {
                 ExternalKind::Func => {
-                    let idx = export.index as usize;
-                    let imported_funcs = self
-                        .0
-                        .imports
-                        .iter()
-                        .filter(|import| matches!(import.kind, tinywasm_types::ImportKind::Function(_)))
-                        .count();
-
+                    let imported_funcs =
+                        imports.filter(|import| matches!(import.kind, tinywasm_types::ImportKind::Function(_))).count();
                     if idx < imported_funcs {
                         ExportType::Func(imported_func_type(&self.0, idx)?)
                     } else {
                         let local_idx = idx - imported_funcs;
                         ExportType::Func(&self.0.funcs.get(local_idx)?.ty)
                     }
                 }
-                ExternalKind::Table => ExportType::Table(self.0.table_types.get(export.index as usize)?),
-                ExternalKind::Memory => ExportType::Memory(self.0.memory_types.get(export.index as usize)?),
+                ExternalKind::Table => ExportType::Table(self.0.table_types.get(idx)?),
+                ExternalKind::Memory => ExportType::Memory(self.0.memory_types.get(idx)?),
                 ExternalKind::Global => {
-                    let idx = export.index as usize;
-                    let imported_globals = self
-                        .0
-                        .imports
-                        .iter()
-                        .filter(|import| matches!(import.kind, tinywasm_types::ImportKind::Global(_)))
-                        .count();
+                    let imported_globals =
+                        imports.filter(|import| matches!(import.kind, tinywasm_types::ImportKind::Global(_))).count();
                     if idx < imported_globals {
                         ExportType::Global(imported_global_type(&self.0, idx)?)
                     } else {
@@ -186,3 +151,29 @@ impl Module {
         })
     }
 }
+
+fn imported_func_type(module: &TinyWasmModule, function_index: usize) -> Option<&FuncType> {
+    let mut seen = 0usize;
+    for import in module.imports.iter() {
+        if let tinywasm_types::ImportKind::Function(type_idx) = import.kind {
+            if seen == function_index {
+                return module.func_types.get(type_idx as usize);
+            }
+            seen += 1;
+        }
+    }
+    None
+}
+
+fn imported_global_type(module: &TinyWasmModule, global_index: usize) -> Option<&tinywasm_types::GlobalType> {
+    let mut seen = 0usize;
+    for import in module.imports.iter() {
+        if let tinywasm_types::ImportKind::Global(global_ty) = &import.kind {
+            if seen == global_index {
+                return Some(global_ty);
+            }
+            seen += 1;
+        }
+    }
+    None
+}