Get tests working for globals and shims

captbaritone · captbaritone · commit 144bed9b325c · 2021-04-02T09:41:35.000-07:00
diff --git a/compiler-rs/Cargo.toml b/compiler-rs/Cargo.toml
@@ -32,7 +32,8 @@ wee_alloc = { version = "0.4.5", optional = true }
 
 
 [dev-dependencies]
-wasmi = "0.8.0"
+# https://github.com/paritytech/wasmi/issues/252
+wasmi = { git = "https://github.com/paritytech/wasmi", branch = "master" }
 wabt = "0.9.0"
 wasm-bindgen-test = "0.3.13"
 wasmprinter = "0.2.0"
diff --git a/compiler-rs/src/emitter.rs b/compiler-rs/src/emitter.rs
@@ -54,7 +54,9 @@ impl Emitter {
             imports.push(make_import_entry(self.current_pool.clone(), global.clone()));
         }
 
-        let (function_exports, function_bodies, funcs) = self.emit_programs(programs)?;
+        self.shims.get(Shim::Sin);
+
+        let (function_exports, function_bodies, funcs) = self.emit_programs(programs, 1)?;
 
         for shim in self.shims.keys() {
             let type_index = self.function_types.get(shim.get_type());
@@ -143,13 +145,17 @@ impl Emitter {
     fn emit_programs(
         &mut self,
         programs: Vec<(String, Program, String)>,
+        offset: u32,
     ) -> EmitterResult<(Vec<ExportEntry>, Vec<FuncBody>, Vec<Func>)> {
         let mut exports = Vec::new();
         let mut function_bodies = Vec::new();
         let mut function_definitions = Vec::new();
         for (i, (name, program, pool_name)) in programs.into_iter().enumerate() {
             self.current_pool = pool_name;
-            exports.push(ExportEntry::new(name, Internal::Function(i as u32)));
+            exports.push(ExportEntry::new(
+                name,
+                Internal::Function(i as u32 + offset),
+            ));
             let locals = Vec::new();
             function_bodies.push(FuncBody::new(locals, self.emit_program(program)?));
 
diff --git a/compiler-rs/src/index_store.rs b/compiler-rs/src/index_store.rs
@@ -29,3 +29,18 @@ impl<T: Eq + Hash> IndexStore<T> {
         self.map.keys().collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::EelFunctionType;
+    #[test]
+    fn tuple() {
+        let mut function_types: IndexStore<EelFunctionType> = IndexStore::new();
+        let one_arg_one_return = function_types.get((1, 1));
+        let no_arg_one_return = function_types.get((0, 1));
+
+        assert_eq!(one_arg_one_return, 0);
+        assert_eq!(no_arg_one_return, 1);
+    }
+}
diff --git a/compiler-rs/tests/compatibility_test.rs b/compiler-rs/tests/compatibility_test.rs
@@ -1,17 +1,23 @@
+use common::GlobalPool;
 use eel_wasm::compile;
-use wasmi::{ImportsBuilder, ModuleInstance, NopExternals, RuntimeValue};
+use wasmi::{ImportsBuilder, ModuleInstance, RuntimeValue};
+mod common;
 
 fn run(body: &[u8]) -> Result<f64, String> {
     let wasm_binary = body;
     let module = wasmi::Module::from_buffer(&wasm_binary).expect("failed to load wasm");
-    let instance = ModuleInstance::new(&module, &ImportsBuilder::default())
+    let mut global_imports = GlobalPool {};
+    let mut imports = ImportsBuilder::default();
+    imports.push_resolver("pool", &global_imports);
+    imports.push_resolver("shims", &global_imports);
+    let instance = ModuleInstance::new(&module, &imports)
         .expect("failed to instantiate wasm module")
         .assert_no_start();
 
     // Finally, invoke the exported function "test" with no parameters
     // and empty external function executor.
     match instance
-        .invoke_export("test", &[], &mut NopExternals)
+        .invoke_export("test", &[], &mut global_imports)
         .expect("failed to execute export")
     {
         Some(RuntimeValue::F64(val)) => Ok(val.into()),
@@ -540,7 +546,10 @@ fn compatibility_tests() {
     ];
 
     for (name, code, expected) in test_cases {
-        match compile(vec![("test".to_string(), code, "pool".to_string())], vec![]) {
+        match compile(
+            vec![("test".to_string(), code, "pool".to_string())],
+            vec![("pool".to_string(), "g".to_string())],
+        ) {
             Ok(binary) => {
                 if expected_failing.contains(name) {
                     panic!(format!("Expected {} to fail, but it passed!", name));
diff --git a/compiler-rs/tests/fixtures/wat/one_plus_one.snapshot b/compiler-rs/tests/fixtures/wat/one_plus_one.snapshot
@@ -2,8 +2,10 @@
 ========================================================================
 (module
   (type (;0;) (func (result f64)))
-  (func (;0;) (type 0) (result f64)
+  (type (;1;) (func (param f64) (result f64)))
+  (import "shims" "sin" (func (;0;) (type 1)))
+  (func (;1;) (type 0) (result f64)
     f64.const 0x1p+0 (;=1;)
     f64.const 0x1p+0 (;=1;)
     f64.add)
-  (export "test" (func 0)))
+  (export "test" (func 1)))
diff --git a/compiler-rs/tests/fixtures/wat/reg.snapshot b/compiler-rs/tests/fixtures/wat/reg.snapshot
@@ -2,9 +2,11 @@ reg00=10
 ========================================================================
 (module
   (type (;0;) (func (result f64)))
-  (func (;0;) (type 0) (result f64)
+  (type (;1;) (func (param f64) (result f64)))
+  (import "shims" "sin" (func (;0;) (type 1)))
+  (func (;1;) (type 0) (result f64)
     f64.const 0x1.4p+3 (;=10;)
     global.set 0
     global.get 0)
   (global (;0;) (mut f64) (f64.const 0x0p+0 (;=0;)))
-  (export "test" (func 0)))
+  (export "test" (func 1)))
diff --git a/compiler-rs/tests/fixtures/wat/sin.snapshot b/compiler-rs/tests/fixtures/wat/sin.snapshot
@@ -7,4 +7,4 @@ sin(100)
   (func (;1;) (type 0) (result f64)
     f64.const 0x1.9p+6 (;=100;)
     call 0)
-  (export "test" (func 0)))
+  (export "test" (func 1)))
diff --git a/compiler-rs/tests/intagration_test.rs b/compiler-rs/tests/intagration_test.rs
@@ -1,27 +1,24 @@
 extern crate eel_wasm;
+mod common;
 
-use std::{collections::HashMap, io};
-
+use common::GlobalPool;
 use eel_wasm::compile;
-use wasmi::nan_preserving_float::F64;
-use wasmi::RuntimeValue;
-use wasmi::{
-    Error as WasmiError, Externals, FuncInstance, FuncRef, GlobalDescriptor, GlobalInstance,
-    GlobalRef, ImportsBuilder, ModuleImportResolver, ModuleInstance, NopExternals, RuntimeArgs,
-    Signature, Trap, ValueType,
-};
+use wasmi::{ImportsBuilder, ModuleInstance, RuntimeValue};
 
 fn run(body: &[u8]) -> Result<f64, String> {
     let wasm_binary = body;
     let module = wasmi::Module::from_buffer(&wasm_binary).expect("failed to load wasm");
-    let instance = ModuleInstance::new(&module, &ImportsBuilder::default())
+
+    let mut global_imports = GlobalPool {};
+    let mut imports = ImportsBuilder::default();
+    imports.push_resolver("pool", &global_imports);
+    imports.push_resolver("shims", &global_imports);
+    let instance = ModuleInstance::new(&module, &imports)
         .expect("failed to instantiate wasm module")
         .assert_no_start();
 
-    // Finally, invoke the exported function "test" with no parameters
-    // and empty external function executor.
     match instance
-        .invoke_export("test", &[], &mut NopExternals)
+        .invoke_export("test", &[], &mut global_imports)
         .expect("failed to execute export")
     {
         Some(RuntimeValue::F64(val)) => Ok(val.into()),
@@ -42,18 +39,6 @@ fn test_run(program: &str, expected_output: f64) {
     );
 }
 
-#[test]
-fn build_one() -> io::Result<()> {
-    assert_eq!(
-        &compile(vec![("test".to_string(), "1", "pool".to_string())], vec![]).unwrap(),
-        &[
-            0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 7, 8, 1, 4, 116, 101,
-            115, 116, 0, 0, 10, 13, 1, 11, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11,
-        ]
-    );
-    Ok(())
-}
-
 #[test]
 fn execute_one() {
     test_run("1", 1.0);
@@ -65,142 +50,14 @@ fn execute_one() {
     test_run("1+1*2", 3.0);
 }
 
-struct GlobalPool {
-    globals: HashMap<String, GlobalRef>,
-}
-
-impl ModuleImportResolver for GlobalPool {
-    fn resolve_global(
-        &self,
-        field_name: &str,
-        _global_type: &GlobalDescriptor,
-    ) -> Result<GlobalRef, WasmiError> {
-        let global = GlobalInstance::alloc(RuntimeValue::F64(F64::from_float(0.0)), true);
-        Ok(global)
-    }
-    fn resolve_func(&self, field_name: &str, signature: &Signature) -> Result<FuncRef, WasmiError> {
-        println!("Calling function: {}", field_name);
-        let index = match field_name {
-            "sin" => SIN_FUNC_INDEX,
-            _ => {
-                return Err(WasmiError::Instantiation(format!(
-                    "Export {} not found",
-                    field_name
-                )))
-            }
-        };
-
-        if !self.check_signature(index, signature) {
-            return Err(WasmiError::Instantiation(format!(
-                "Export {} has a bad signature",
-                field_name
-            )));
-        }
-
-        println!("PAssed sig check: {}", field_name);
-
-        Ok(FuncInstance::alloc_host(
-            Signature::new(&[ValueType::F64][..], Some(ValueType::F64)),
-            index,
-        ))
-    }
-}
-
-const SIN_FUNC_INDEX: usize = 0;
-
-impl Externals for GlobalPool {
-    fn invoke_index(
-        &mut self,
-        index: usize,
-        args: RuntimeArgs,
-    ) -> Result<Option<RuntimeValue>, Trap> {
-        println!("Calling index {}", index);
-        match index {
-            SIN_FUNC_INDEX => {
-                let a: F64 = args.nth_checked(0)?;
-                println!("First arg was {:?}", a);
-
-                let result = a * 2;
-
-                Ok(Some(RuntimeValue::F64(F64::from(result))))
-            }
-            _ => panic!("Unimplemented function at {}", index),
-        }
-    }
-}
-
-impl GlobalPool {
-    fn check_signature(&self, index: usize, signature: &Signature) -> bool {
-        println!("Checking sig of {}", index);
-        let (params, ret_ty): (&[ValueType], Option<ValueType>) = match index {
-            SIN_FUNC_INDEX => (&[ValueType::F64], Some(ValueType::F64)),
-            _ => return false,
-        };
-        signature.params() == params && signature.return_type() == ret_ty
-    }
-}
-
 #[test]
-#[ignore]
 fn with_global() {
-    let global_imports = GlobalPool {
-        globals: HashMap::default(),
-    };
-    let wasm_binary = compile(
-        vec![("test".to_string(), "g=1", "pool".to_string())],
-        vec![("g".to_string(), "pool".to_string())],
-    )
-    .expect("Expect to compile");
-    // TODO: This will fail becuase wasmi 0.8.0 depends upon wasmi-validaiton
-    // 0.3.0 which does not include https://github.com/paritytech/wasmi/pull/228
-    // which allows mutable globals.
-    // 0.3.1 has the PR, but wasmi has not shipped a new version that includes it.
-    // parity-wasm already depends upon 0.3.1 (I _think_)
-    let module = wasmi::Module::from_buffer(&wasm_binary).expect("No validation errors");
-    let mut imports = ImportsBuilder::default();
-    imports.push_resolver("pool", &global_imports);
-    let instance = ModuleInstance::new(&module, &imports)
-        .expect("failed to instantiate wasm module")
-        .assert_no_start();
-
-    // Finally, invoke the exported function "test" with no parameters
-    // and empty external function executor.
-    instance
-        .invoke_export("test", &[], &mut NopExternals)
-        .expect("failed to execute export")
-        .expect("Ran");
+    test_run("g=1", 1.0);
 }
 
 #[test]
-#[ignore]
 fn with_shims() {
-    let global_imports = GlobalPool {
-        globals: HashMap::default(),
-    };
-    let wasm_binary = compile(
-        vec![("test".to_string(), "sin(10)", "pool".to_string())],
-        vec![],
-    )
-    .expect("Expect to compile");
-    // TODO: This will fail becuase wasmi 0.8.0 depends upon wasmi-validaiton
-    // 0.3.0 which does not include https://github.com/paritytech/wasmi/pull/228
-    // which allows mutable globals.
-    // 0.3.1 has the PR, but wasmi has not shipped a new version that includes it.
-    // parity-wasm already depends upon 0.3.1 (I _think_)
-    let module = wasmi::Module::from_buffer(&wasm_binary).expect("No validation errors");
-    let mut imports = ImportsBuilder::default();
-    imports.push_resolver("pool", &global_imports);
-    imports.push_resolver("shims", &global_imports);
-    let instance = ModuleInstance::new(&module, &imports)
-        .expect("failed to instantiate wasm module")
-        .assert_no_start();
-
-    // Finally, invoke the exported function "test" with no parameters
-    // and empty external function executor.
-    instance
-        .invoke_export("test", &[], &mut NopExternals)
-        .expect("failed to execute export")
-        .expect("Ran");
+    test_run("sin(10)", 10.0_f64.sin());
 }
 
 #[test]
@@ -219,17 +76,22 @@ fn multiple_functions() {
     // 0.3.1 has the PR, but wasmi has not shipped a new version that includes it.
     // parity-wasm already depends upon 0.3.1 (I _think_)
     let module = wasmi::Module::from_buffer(&wasm_binary).expect("No validation errors");
-    let instance = ModuleInstance::new(&module, &ImportsBuilder::default())
+    let mut global_imports = GlobalPool {};
+    let mut imports = ImportsBuilder::default();
+    imports.push_resolver("pool", &global_imports);
+    imports.push_resolver("shims", &global_imports);
+
+    let instance = ModuleInstance::new(&module, &imports)
         .expect("failed to instantiate wasm module")
         .assert_no_start();
 
     instance
-        .invoke_export("one", &[], &mut NopExternals)
+        .invoke_export("one", &[], &mut global_imports)
         .expect("failed to execute export")
         .expect("Ran");
 
     instance
-        .invoke_export("two", &[], &mut NopExternals)
+        .invoke_export("two", &[], &mut global_imports)
         .expect("failed to execute export")
         .expect("Ran");
 }
