use linker struct to provide multiple imports

cranelift/filetests/src/test_zkasm.rs

@@ -244,44 +244,15 @@ mod tests {
         let engine = Engine::default();
         let binary = wat::parse_file(path)?;
         let module = Module::new(&engine, &binary)?;
-
-        let import = module
-            .imports()
-            .find(|imp| imp.name() == "assert_eq")
-            .unwrap();
-
-        let params: Vec<ValType> = import.ty().unwrap_func().params().collect();
-
-        let assert_type = if params == [ValType::I32, ValType::I32] {
-            32
-        } else if params == [ValType::I64, ValType::I64] {
-            64
-        } else {
-            panic!(
-                "Incorrect assert_eq type in file {}",
-                path.to_str().unwrap()
-            )
-        };
-        if assert_type == 64 {
-            // 4 a magic number which we must provide for Store initialization, but not important in our case
-            // a searched ways to use some default numbers, but unsuccesfully, so took a number same as in
-            // example in docs
-            // TODO: find a way to do it without magic numbers
-            let mut store = Store::new(&engine, 4);
-            let host_func = Func::wrap(&mut store, |_: Caller<'_, i64>, a: i64, b: i64| {
-                assert_eq!(a, b);
-            });
-            let _instance = Instance::new(&mut store, &module, &[host_func.into()])?;
-        } else {
-            // assert type is i32
-            // same about 4 as in other branch
-            // TODO: find a way to do it without magic numbers
-            let mut store = Store::new(&engine, 4);
-            let host_func = Func::wrap(&mut store, |_: Caller<'_, i32>, a: i32, b: i32| {
-                assert_eq!(a, b);
-            });
-            let _instance = Instance::new(&mut store, &module, &[host_func.into()])?;
-        }
+        let mut store = Store::new(&engine, ());
+        let mut linker = Linker::<()>::new(&engine);
+        linker.func_wrap("env", "assert_eq_i32", |a: i32, b: i32| {
+            assert_eq!(a, b);
+        })?;
+        linker.func_wrap("env", "assert_eq_i64", |a: i64, b: i64| {
+            assert_eq!(a, b);
+        })?;
+        linker.instantiate(&mut store, &module)?;
         Ok(())
     }
 
@@ -350,7 +321,7 @@ mod tests {
             let count = test_counters.entry(function_name.to_string()).or_insert(0);
             *count += 1;
             let mut testcase = String::new();
-            testcase.push_str(&format!("(module\n (import \"env\" \"assert_eq\" (func $assert_eq (param {}) (param {})))\n (func $main\n", assert_type, assert_type));
+            testcase.push_str(&format!("(module\n (import \"env\" \"assert_eq_{}\" (func $assert_eq_{} (param {}) (param {})))\n (func $main\n", assert_type, assert_type, assert_type, assert_type));
             testcase.push_str(&format!(
                 "\t{}\n",
                 arguments
@@ -370,8 +341,9 @@ mod tests {
                 testcase.push_str(&format!("\t{function_type}.{}\n", function_name));
             }
             testcase.push_str(&format!(
-                "\t{}\n\tcall $assert_eq)\n (start $main))\n",
-                expected_result.trim()
+                "\t{}\n\tcall $assert_eq_{})\n (start $main))\n",
+                expected_result.trim(),
+                assert_type
             ));
             let file_name = format!(
                 "../../zkasm_data/spectest/{name}/{}_{}.wat",

cranelift/zkasm_data/_should_fail_unreachable.wat

@@ -1,6 +1,6 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	unreachable
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/add.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 999999999
 	i32.const 1000000000
 	i32.add
 	i32.const 1999999999
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/add_func.wat

@@ -1,11 +1,11 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 2
 	i32.const 3
 	call $add
 	i32.const 5
-	call $assert_eq)
+	call $assert_eq_i32)
  (func $add (param $lhs i32) (param $rhs i32) (result i32)
  	(i32.add
 		(local.get $lhs)

cranelift/zkasm_data/and.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 1
 	i32.const 0
 	i32.and
 	i32.const 0
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/benchmarks/fibonacci/from_rust.wat

@@ -3,7 +3,7 @@
 (module
   (type (;0;) (func (param i64 i64)))
   (type (;1;) (func))
-  (import "env" "assert_eq" (func (;0;) (type 0)))
+  (import "env" "assert_eq_i64" (func (;0;) (type 0)))
   (func (;1;) (type 1)
     (local i64 i64 i32)
     i64.const 1

cranelift/zkasm_data/benchmarks/fibonacci/handwritten_wat.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
 	(local $counter i32)
 	(local $fp i64)
@@ -28,5 +28,5 @@
 	)
 	(local.get $fp)
 	(i64.const -2872092127636481573)
-	call $assert_eq)
+	call $assert_eq_i64)
 (start $main))

cranelift/zkasm_data/benchmarks/sha256/from_rust.wat

@@ -5,7 +5,7 @@
   (type (;1;) (func))
   (type (;2;) (func (param i32 i32 i32)))
   (type (;3;) (func (param i32 i32 i32) (result i32)))
-  (import "env" "assert_eq" (func (;0;) (type 0)))
+  (import "env" "assert_eq_i64" (func (;0;) (type 0)))
   (func (;1;) (type 1)
     (local i32 i32 i32 i32 i32 i32 i32 i32 i64 i64 i64 i32 i32)
     global.get 0

cranelift/zkasm_data/counter.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	(local $counter i32)
 	(local.set $counter (i32.const 0))
@@ -20,5 +20,5 @@
 	)
 	(local.get $counter)
 	(i32.const 10)
-	call $assert_eq)
+	call $assert_eq_i32)
 (start $main))

cranelift/zkasm_data/div.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 5
 	i32.const 2
 	i32.div_s
 	i32.const 2
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/eqz.wat

@@ -1,12 +1,12 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 5
     i32.eqz
     i32.const 0
-	call $assert_eq
+	call $assert_eq_i32
     i32.const 0
     i32.eqz
     i32.const 1
-    call $assert_eq)
+    call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/global.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (global $a i32 (i32.const -2))
  (global $b (mut i32) (i32.const 5))
  (func $main
@@ -8,5 +8,5 @@
 	(global.get $b)
 	i32.add
 	i32.const 1
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/i32_add_overflows.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 4294967295
 	i32.const 1
 	i32.add
 	i32.const 0
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/i32_const.wat

@@ -1,7 +1,7 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 4
 	i32.const 4
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/i32_mul_overflows.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 2147483648
 	i32.const 2
 	i32.mul
 	i32.const 0
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/i64_const.wat

@@ -1,7 +1,7 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
 	i64.const 9223372036854775807
 	i64.const 9223372036854775807
-	call $assert_eq)
+	call $assert_eq_i64)
  (start $main))

cranelift/zkasm_data/i64_div.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
 	i64.const 214748364
 	i64.const 107374183
@@ -9,5 +9,5 @@
     i64.const 214748364
     i64.div_s
     i64.const 214748366
-	call $assert_eq)
+	call $assert_eq_i64)
  (start $main))

cranelift/zkasm_data/i64_mul.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
 	i64.const 214748364
 	i64.const 107374183
@@ -11,5 +11,5 @@
     i64.const 2
 	i64.mul
     i64.mul
-	call $assert_eq)
+	call $assert_eq_i64)
  (start $main))

cranelift/zkasm_data/i64_mul_overflows.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
 	i64.const 2
 	i64.const 9223372036854775808
     i64.mul
     i64.const 0
-	call $assert_eq)
+	call $assert_eq_i64)
  (start $main))

cranelift/zkasm_data/i64_rem.wat

@@ -1,14 +1,14 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i64) (param i64)))
+ (import "env" "assert_eq_i64" (func $assert_eq_i64 (param i64) (param i64)))
  (func $main
     i64.const 5
     i64.const 2
     i64.rem_s
     i64.const 1
-    call $assert_eq
+    call $assert_eq_i64
     i64.const 8
     i64.const 3
     i64.rem_s
     i64.const 2
-    call $assert_eq)
+    call $assert_eq_i64)
  (start $main))

cranelift/zkasm_data/locals.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	(local $x i32)
 	(local $y i32)
@@ -11,5 +11,5 @@
 	(local.set $z (i32.add))
 	(local.get $z)
 	(i32.const 5)
-	call $assert_eq)
+	call $assert_eq_i32)
 (start $main))

cranelift/zkasm_data/locals_simple.wat

@@ -1,9 +1,9 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	(local $x i32)
 	(local.set $x (i32.const 2))
 	(local.get $x)
 	(i32.const 2)
-	call $assert_eq)
+	call $assert_eq_i32)
 (start $main))

cranelift/zkasm_data/lt_s.wat

@@ -1,16 +1,16 @@
 ;; 1 - true, 0 false
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 2
 	i32.const 3
 	i32.lt_s
 	i32.const 1
-	call $assert_eq
+	call $assert_eq_i32
 
 	i32.const 3
 	i32.const 2
 	i32.lt_s
 	i32.const 0
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/lt_u.wat

@@ -1,16 +1,16 @@
 ;; 1 - true, 0 false
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (func $main
 	i32.const 2
 	i32.const 3
 	i32.lt_u
 	i32.const 1
-	call $assert_eq
+	call $assert_eq_i32
 
 	i32.const 3
 	i32.const 2
 	i32.lt_u
 	i32.const 0
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))

cranelift/zkasm_data/memory.wat

@@ -1,5 +1,5 @@
 (module
- (import "env" "assert_eq" (func $assert_eq (param i32) (param i32)))
+ (import "env" "assert_eq_i32" (func $assert_eq_i32 (param i32) (param i32)))
  (memory (export "memory") 100)
  (func $main
 	(i32.store (i32.const 0) (i32.const 2))
@@ -8,5 +8,5 @@
 	(i32.load (i32.const 8))
 	i32.add
 	i32.const 5
-	call $assert_eq)
+	call $assert_eq_i32)
  (start $main))