add wide-arithmetic execution handlers

Author: Robbepop

crates/wasmi/src/engine/executor/handler/dispatch.rs

@@ -457,6 +457,11 @@ pub fn op_code_to_handler(code: OpCode) -> Handler {
         OpCode::TableSet_Ii => exec::table_set_ii,
         OpCode::ElemDrop => exec::elem_drop,
         OpCode::RefFunc => exec::ref_func,
+        // wide-arithmetic
+        OpCode::I64Add128 => exec::i64_add128,
+        OpCode::I64Sub128 => exec::i64_sub128,
+        OpCode::I64MulWide => exec::i64_mul_wide,
+        OpCode::U64MulWide => exec::u64_mul_wide,
         // unconditional branch
         OpCode::Branch => exec::branch,
         OpCode::BranchTable => exec::branch_table,

crates/wasmi/src/engine/executor/handler/exec.rs

@@ -923,6 +923,68 @@ pub fn ref_func(
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
 
+macro_rules! impl_i64_binop128 {
+    (
+        $( fn $handler:ident($op:ident) = $eval:expr );* $(;)?
+    ) => {
+        $(
+            pub fn $handler(
+                state: &mut VmState,
+                ip: Ip,
+                sp: Sp,
+                mem0: Mem0Ptr,
+                mem0_len: Mem0Len,
+                instance: Inst,
+            ) -> Done {
+                let (ip, crate::ir::decode::$op { results, lhs_lo, lhs_hi, rhs_lo, rhs_hi }) = unsafe { decode_op(ip) };
+                let lhs_lo: i64 = get_value(lhs_lo, sp);
+                let lhs_hi: i64 = get_value(lhs_hi, sp);
+                let rhs_lo: i64 = get_value(rhs_lo, sp);
+                let rhs_hi: i64 = get_value(rhs_hi, sp);
+                let results = results.to_array();
+                let (result_lo, result_hi) = $eval(lhs_lo, lhs_hi, rhs_lo, rhs_hi);
+                set_value(sp, results[0], result_lo);
+                set_value(sp, results[1], result_hi);
+                dispatch!(state, ip, sp, mem0, mem0_len, instance)
+            }
+        )*
+    };
+}
+impl_i64_binop128! {
+    fn i64_add128(I64Add128) = wasm::i64_add128;
+    fn i64_sub128(I64Sub128) = wasm::i64_sub128;
+}
+
+macro_rules! impl_i64_mul_wide {
+    (
+        $( fn $handler:ident($op:ident) = $eval:expr );* $(;)?
+    ) => {
+        $(
+            pub fn $handler(
+                state: &mut VmState,
+                ip: Ip,
+                sp: Sp,
+                mem0: Mem0Ptr,
+                mem0_len: Mem0Len,
+                instance: Inst,
+            ) -> Done {
+                let (ip, crate::ir::decode::$op { results, lhs, rhs }) = unsafe { decode_op(ip) };
+                let lhs: i64 = get_value(lhs, sp);
+                let rhs: i64 = get_value(rhs, sp);
+                let (result_lo, result_hi) = $eval(lhs, rhs);
+                let results = results.to_array();
+                set_value(sp, results[0], result_lo);
+                set_value(sp, results[1], result_hi);
+                dispatch!(state, ip, sp, mem0, mem0_len, instance)
+            }
+        )*
+    };
+}
+impl_i64_mul_wide! {
+    fn i64_mul_wide(I64MulWide) = wasm::i64_mul_wide_s;
+    fn u64_mul_wide(U64MulWide) = wasm::i64_mul_wide_u;
+}
+
 /// Fetches the branch table index value and normalizes it to clamp between `0..len_targets`.
 fn fetch_branch_table_target(sp: Sp, index: Slot, len_targets: u32) -> usize {
     let index: u32 = get_value(index, sp);

crates/wast/tests/mod.rs

@@ -182,7 +182,7 @@ macro_rules! foreach_test {
             fn spec_utf8_import_field("spec/utf8-import-field");
             fn spec_utf8_import_module("spec/utf8-import-module");
             fn spec_utf8_invalid_encoding("spec/utf8-invalid-encoding");
-            // fn spec_wide_arithmetic("spec/proposals/wide-arithmetic/wide-arithmetic");
+            fn spec_wide_arithmetic("spec/proposals/wide-arithmetic/wide-arithmetic");
 
             // Wasmi specific test cases and regression tests.
             fn wasmi_fibonacci("wasmi/tests/fibonacci");