feat: pass full wasm 1.0 testsuite

explodingcamera · explodingcamera · commit 64ed1bf86950 · 2024-01-25T01:01:25.000+01:00
Signed-off-by: Henry Gressmann &lt;mail@henrygressmann.de&gt;
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
@@ -27,6 +27,9 @@ jobs:
       - name: Run tests (stable)
         run: cargo +stable test --workspace --exclude wasm-testsuite
 
+      - name: Run MVP testsuite
+        run: cargo +stable test-mvp
+
   test-no-std:
     name: Test without default features on nightly Rust
     runs-on: ubuntu-latest
@@ -43,3 +46,6 @@ jobs:
 
       - name: Run tests (nightly, no default features)
         run: cargo +nightly test --workspace --exclude wasm-testsuite --no-default-features
+
+      - name: Run MVP testsuite (nightly)
+        run: cargo +nightly test-mvp
diff --git a/crates/cli/src/args.rs b/crates/cli/src/args.rs
@@ -17,29 +17,14 @@ impl From<WasmArg> for WasmValue {
 impl FromStr for WasmArg {
     type Err = String;
     fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {
-        let [ty, val]: [&str; 2] = s
-            .split(':')
-            .collect::<Vec<_>>()
-            .try_into()
-            .map_err(|e| format!("invalid arguments: {:?}", e))?;
+        let [ty, val]: [&str; 2] =
+            s.split(':').collect::<Vec<_>>().try_into().map_err(|e| format!("invalid arguments: {:?}", e))?;
 
         let arg: WasmValue = match ty {
-            "i32" => val
-                .parse::<i32>()
-                .map_err(|e| format!("invalid argument value for i32: {e:?}"))?
-                .into(),
-            "i64" => val
-                .parse::<i64>()
-                .map_err(|e| format!("invalid argument value for i64: {e:?}"))?
-                .into(),
-            "f32" => val
-                .parse::<f32>()
-                .map_err(|e| format!("invalid argument value for f32: {e:?}"))?
-                .into(),
-            "f64" => val
-                .parse::<f64>()
-                .map_err(|e| format!("invalid argument value for f64: {e:?}"))?
-                .into(),
+            "i32" => val.parse::<i32>().map_err(|e| format!("invalid argument value for i32: {e:?}"))?.into(),
+            "i64" => val.parse::<i64>().map_err(|e| format!("invalid argument value for i64: {e:?}"))?.into(),
+            "f32" => val.parse::<f32>().map_err(|e| format!("invalid argument value for f32: {e:?}"))?.into(),
+            "f64" => val.parse::<f64>().map_err(|e| format!("invalid argument value for f64: {e:?}"))?.into(),
             t => return Err(format!("Invalid arg type: {}", t)),
         };
 
diff --git a/crates/cli/src/bin.rs b/crates/cli/src/bin.rs
@@ -84,12 +84,7 @@ fn main() -> Result<()> {
     let cwd = std::env::current_dir()?;
 
     match args.nested {
-        TinyWasmSubcommand::Run(Run {
-            wasm_file,
-            engine,
-            args,
-            func,
-        }) => {
+        TinyWasmSubcommand::Run(Run { wasm_file, engine, args, func }) => {
             debug!("args: {:?}", args);
 
             let path = cwd.join(wasm_file.clone());
diff --git a/crates/parser/src/error.rs b/crates/parser/src/error.rs
@@ -43,10 +43,7 @@ impl crate::std::error::Error for ParseError {}
 
 impl From<wasmparser::BinaryReaderError> for ParseError {
     fn from(value: wasmparser::BinaryReaderError) -> Self {
-        Self::ParseError {
-            message: value.message().to_string(),
-            offset: value.offset(),
-        }
+        Self::ParseError { message: value.message().to_string(), offset: value.offset() }
     }
 }
 
diff --git a/crates/tinywasm/src/error.rs b/crates/tinywasm/src/error.rs
@@ -70,6 +70,10 @@ impl LinkingError {
     pub(crate) fn incompatible_import_type(import: &tinywasm_types::Import) -> Self {
         Self::IncompatibleImportType { module: import.module.to_string(), name: import.name.to_string() }
     }
+
+    pub(crate) fn unknown_import(import: &tinywasm_types::Import) -> Self {
+        Self::UnknownImport { module: import.module.to_string(), name: import.name.to_string() }
+    }
 }
 
 #[derive(Debug)]
diff --git a/crates/tinywasm/src/func.rs b/crates/tinywasm/src/func.rs
@@ -168,8 +168,6 @@ macro_rules! impl_from_wasm_value_tuple {
                 #[allow(unused_variables, unused_mut)]
                 let mut iter = values.into_iter();
 
-                log::error!("from_wasm_value_tuple: {:?}", iter);
-
                 Ok((
                     $(
                         $T::try_from(
diff --git a/crates/tinywasm/src/imports.rs b/crates/tinywasm/src/imports.rs
@@ -162,10 +162,8 @@ impl Extern {
         R: IntoWasmValueTuple + ValTypesFromTuple + Debug,
     {
         let inner_func = move |ctx: FuncContext<'_>, args: &[WasmValue]| -> Result<Vec<WasmValue>> {
-            log::error!("args: {:?}", args);
             let args = P::from_wasm_value_tuple(args.to_vec())?;
             let result = func(ctx, args)?;
-            log::error!("result: {:?}", result);
             Ok(result.into_wasm_value_tuple())
         };
 
@@ -290,18 +288,6 @@ impl Imports {
             _ => {}
         }
 
-        // if expected.size_max.is_none() && actual.size_max.is_some() {
-        //     return Err(LinkingError::incompatible_import_type(import).into());
-        // }
-
-        // if expected.size_max.unwrap_or(0) < actual.size_max.unwrap_or(0) {
-        //     return Err(LinkingError::incompatible_import_type(import).into());
-        // }
-
-        log::error!("size_initial: expected: {:?} got: {:?}", expected.size_initial, actual.size_initial);
-        log::error!("size_max: expected: {:?} got: {:?}", expected.size_max, actual.size_max);
-        // TODO: check limits
-
         Ok(())
     }
 
@@ -331,11 +317,6 @@ impl Imports {
             _ => {}
         }
 
-        log::error!("size_initial: {:?} {:?}", expected.page_count_initial, actual.page_count_initial);
-        log::error!("size_max: {:?} {:?}", expected.page_count_max, actual.page_count_max);
-
-        // TODO: check limits
-
         Ok(())
     }
 
@@ -348,13 +329,7 @@ impl Imports {
         let mut imports = ResolvedImports::new();
 
         for import in module.data.imports.iter() {
-            let Some(val) = self.take(store, import) else {
-                return Err(crate::LinkingError::UnknownImport {
-                    module: import.module.to_string(),
-                    name: import.name.to_string(),
-                }
-                .into());
-            };
+            let val = self.take(store, import).ok_or_else(|| LinkingError::unknown_import(import))?;
 
             match val {
                 // A link to something that needs to be added to the store
@@ -364,42 +339,31 @@ impl Imports {
                         imports.globals.push(store.add_global(extern_global.ty, extern_global.val.into(), idx)?);
                     }
                     (Extern::Table(extern_table), ImportKind::Table(ty)) => {
-                        Self::compare_table_types(import, &extern_table.ty, &ty)?;
+                        Self::compare_table_types(import, &extern_table.ty, ty)?;
                         imports.tables.push(store.add_table(extern_table.ty, idx)?);
                     }
                     (Extern::Memory(extern_memory), ImportKind::Memory(ty)) => {
-                        Self::compare_memory_types(import, &extern_memory.ty, &ty, None)?;
+                        Self::compare_memory_types(import, &extern_memory.ty, ty, None)?;
                         imports.memories.push(store.add_mem(extern_memory.ty, idx)?);
                     }
                     (Extern::Function(extern_func), ImportKind::Function(ty)) => {
-                        let import_func_type = module.data.func_types.get(*ty as usize).ok_or_else(|| {
-                            crate::LinkingError::IncompatibleImportType {
-                                module: import.module.to_string(),
-                                name: import.name.to_string(),
-                            }
-                        })?;
+                        let import_func_type = module
+                            .data
+                            .func_types
+                            .get(*ty as usize)
+                            .ok_or_else(|| LinkingError::incompatible_import_type(import))?;
 
                         Self::compare_types(import, extern_func.ty(), import_func_type)?;
                         imports.funcs.push(store.add_func(extern_func, *ty, idx)?);
                     }
-                    _ => {
-                        return Err(crate::LinkingError::IncompatibleImportType {
-                            module: import.module.to_string(),
-                            name: import.name.to_string(),
-                        }
-                        .into());
-                    }
+                    _ => return Err(LinkingError::incompatible_import_type(import).into()),
                 },
 
                 // A link to something already in the store
                 ResolvedExtern::Store(val) => {
                     // check if the kind matches
                     if val.kind() != (&import.kind).into() {
-                        return Err(crate::LinkingError::IncompatibleImportType {
-                            module: import.module.to_string(),
-                            name: import.name.to_string(),
-                        }
-                        .into());
+                        return Err(LinkingError::incompatible_import_type(import).into());
                     }
 
                     match (val, &import.kind) {
@@ -410,37 +374,30 @@ impl Imports {
                         }
                         (ExternVal::Table(table_addr), ImportKind::Table(ty)) => {
                             let table = store.get_table(table_addr as usize)?;
-                            Self::compare_table_types(import, &table.borrow().kind, &ty)?;
+                            Self::compare_table_types(import, &table.borrow().kind, ty)?;
                             imports.tables.push(table_addr);
                         }
                         (ExternVal::Mem(memory_addr), ImportKind::Memory(ty)) => {
                             let mem = store.get_mem(memory_addr as usize)?;
                             let (size, kind) = {
                                 let mem = mem.borrow();
-                                (mem.page_count(), mem.kind.clone())
+                                (mem.page_count(), mem.kind)
                             };
-                            Self::compare_memory_types(import, &kind, &ty, Some(size))?;
+                            Self::compare_memory_types(import, &kind, ty, Some(size))?;
                             imports.memories.push(memory_addr);
                         }
                         (ExternVal::Func(func_addr), ImportKind::Function(ty)) => {
                             let func = store.get_func(func_addr as usize)?;
-                            let import_func_type = module.data.func_types.get(*ty as usize).ok_or_else(|| {
-                                crate::LinkingError::IncompatibleImportType {
-                                    module: import.module.to_string(),
-                                    name: import.name.to_string(),
-                                }
-                            })?;
+                            let import_func_type = module
+                                .data
+                                .func_types
+                                .get(*ty as usize)
+                                .ok_or_else(|| LinkingError::incompatible_import_type(import))?;
 
                             Self::compare_types(import, func.func.ty(), import_func_type)?;
                             imports.funcs.push(func_addr);
                         }
-                        _ => {
-                            return Err(crate::LinkingError::IncompatibleImportType {
-                                module: import.module.to_string(),
-                                name: import.name.to_string(),
-                            }
-                            .into());
-                        }
+                        _ => return Err(LinkingError::incompatible_import_type(import).into()),
                     }
                 }
             }
diff --git a/crates/tinywasm/src/instance.rs b/crates/tinywasm/src/instance.rs
@@ -70,7 +70,7 @@ impl ModuleInstance {
         addrs.tables.extend(store.init_tables(data.table_types.into(), idx)?);
         addrs.memories.extend(store.init_memories(data.memory_types.into(), idx)?);
 
-        let global_addrs = store.init_globals(addrs.globals, data.globals.into(), idx)?;
+        let global_addrs = store.init_globals(addrs.globals, data.globals.into(), &addrs.funcs, idx)?;
         let (elem_addrs, elem_trapped) =
             store.init_elements(&addrs.tables, &addrs.funcs, &global_addrs, data.elements.into(), idx)?;
         let (data_addrs, data_trapped) = store.init_datas(&addrs.memories, data.data.into(), idx)?;
diff --git a/crates/tinywasm/src/runtime/executor/mod.rs b/crates/tinywasm/src/runtime/executor/mod.rs
@@ -139,7 +139,6 @@ fn exec_one(
         }
 
         Call(v) => {
-            log::info!("start call");
             // prepare the call frame
             let func_idx = module.resolve_func_addr(*v);
             let func_inst = store.get_func(func_idx as usize)?.clone();
@@ -148,19 +147,14 @@ fn exec_one(
                 crate::Function::Wasm(ref f) => (f.locals.to_vec(), f.ty.clone()),
                 crate::Function::Host(host_func) => {
                     let func = host_func.func.clone();
-                    log::info!("Getting params: {:?}", host_func.ty.params);
                     let params = stack.values.pop_params(&host_func.ty.params)?;
-                    log::error!("Calling host function, params: {:?}", params);
                     let res = (func)(FuncContext { store, module }, &params)?;
                     stack.values.extend_from_typed(&res);
                     return Ok(ExecResult::Ok);
                 }
             };
 
             let params = stack.values.pop_n_rev(ty.params.len())?;
-            log::info!("call: current fn owner: {:?}", module.id());
-            log::info!("call: func owner: {:?}", func_inst.owner);
-
             let call_frame = CallFrame::new_raw(func_inst, &params, locals);
 
             // push the call frame
diff --git a/crates/tinywasm/src/runtime/stack/blocks.rs b/crates/tinywasm/src/runtime/stack/blocks.rs
@@ -72,10 +72,9 @@ impl LabelArgs {
         Ok(match args {
             BlockArgs::Empty => LabelArgs { params: 0, results: 0 },
             BlockArgs::Type(_) => LabelArgs { params: 0, results: 1 },
-            BlockArgs::FuncType(t) => LabelArgs {
-                params: module.func_ty(t).params.len(),
-                results: module.func_ty(t).results.len(),
-            },
+            BlockArgs::FuncType(t) => {
+                LabelArgs { params: module.func_ty(t).params.len(), results: module.func_ty(t).results.len() }
+            }
         })
     }
 }
diff --git a/crates/tinywasm/src/store.rs b/crates/tinywasm/src/store.rs
diff --git a/crates/tinywasm/tests/generated/mvp.csv b/crates/tinywasm/tests/generated/mvp.csv
diff --git a/crates/tinywasm/tests/testsuite/indexmap.rs b/crates/tinywasm/tests/testsuite/indexmap.rs

Original file line number	Diff line number	Diff line change
`@@ -43,10 +43,7 @@ impl crate::std::error::Error for ParseError {}`
`43`	`43`
`44`	`44`	`impl From<wasmparser::BinaryReaderError> for ParseError {`
`45`	`45`	`fn from(value: wasmparser::BinaryReaderError) -> Self {`
`46`		`- Self::ParseError {`
`47`		`- message: value.message().to_string(),`
`48`		`- offset: value.offset(),`
`49`		`- }`
	`46`	`+ Self::ParseError { message: value.message().to_string(), offset: value.offset() }`
`50`	`47`	`}`
`51`	`48`	`}`
`52`	`49`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,10 @@ impl LinkingError {`
`70`	`70`	`pub(crate) fn incompatible_import_type(import: &tinywasm_types::Import) -> Self {`
`71`	`71`	`Self::IncompatibleImportType { module: import.module.to_string(), name: import.name.to_string() }`
`72`	`72`	`}`
	`73`	`+`
	`74`	`+ pub(crate) fn unknown_import(import: &tinywasm_types::Import) -> Self {`
	`75`	`+ Self::UnknownImport { module: import.module.to_string(), name: import.name.to_string() }`
	`76`	`+ }`
`73`	`77`	`}`
`74`	`78`
`75`	`79`	`#[derive(Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -72,10 +72,9 @@ impl LabelArgs {`
`72`	`72`	`Ok(match args {`
`73`	`73`	`BlockArgs::Empty => LabelArgs { params: 0, results: 0 },`
`74`	`74`	`BlockArgs::Type(_) => LabelArgs { params: 0, results: 1 },`
`75`		`- BlockArgs::FuncType(t) => LabelArgs {`
`76`		`- params: module.func_ty(t).params.len(),`
`77`		`- results: module.func_ty(t).results.len(),`
`78`		`- },`
	`75`	`+ BlockArgs::FuncType(t) => {`
	`76`	`+ LabelArgs { params: module.func_ty(t).params.len(), results: module.func_ty(t).results.len() }`
	`77`	`+ }`
`79`	`78`	`})`
`80`	`79`	`}`
`81`	`80`	`}`