Add cmp+select instruction fusion (#1497)

* add new cmp+select instructions

* implement cmp+select instructions in executor

* fix docs typo

* add TryIntoCmpSelectInstr trait and impl

* implement new select translation

* remove old select instruction handlers

* convert translation test

* remove outdated select tests

* fix local_set test with select

* move CmpOp enum to mod.rs

* add new cmp+select translation tests

* remove old select instructions

* fix broken doc link

Author: Robbepop

crates/ir/src/enum.rs

@@ -31,8 +31,8 @@ macro_rules! define_enum {
         /// This type represents all such words and for simplicity we call the type [`Instruction`], still.
         ///
         /// Most instructions are composed of a single instruction word. An example of
-        /// this is [`Instruction::I32Add`]. However, some instructions, like
-        /// [`Instruction::Select`], are composed of two or more instruction words.
+        /// this is [`Instruction::I32Add`]. However, some instructions, like the `select` instructions
+        /// are composed of two or more instruction words.
         ///
         /// The Wasmi bytecode translation makes sure that instructions always appear in valid sequences.
         /// The Wasmi executor relies on the guarantees that the Wasmi translator provides.

crates/ir/src/for_each_op.rs

@@ -448,24 +448,210 @@ impl<'engine> Executor<'engine> {
                 Instr::CallIndirectImm16 { results, func_type } => {
                     self.execute_call_indirect_imm16(store, results, func_type)?
                 }
-                Instr::Select { result, lhs } => self.execute_select(result, lhs),
-                Instr::SelectImm32Rhs { result, lhs } => self.execute_select_imm32_rhs(result, lhs),
-                Instr::SelectImm32Lhs { result, lhs } => self.execute_select_imm32_lhs(result, lhs),
-                Instr::SelectImm32 { result, lhs } => self.execute_select_imm32(result, lhs),
-                Instr::SelectI64Imm32Rhs { result, lhs } => {
-                    self.execute_select_i64imm32_rhs(result, lhs)
+                Instr::SelectI32Eq { result, lhs, rhs } => {
+                    self.execute_select_i32_eq(result, lhs, rhs)
                 }
-                Instr::SelectI64Imm32Lhs { result, lhs } => {
-                    self.execute_select_i64imm32_lhs(result, lhs)
+                Instr::SelectI32EqImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_eq_imm16(result, lhs, rhs)
                 }
-                Instr::SelectI64Imm32 { result, lhs } => self.execute_select_i64imm32(result, lhs),
-                Instr::SelectF64Imm32Rhs { result, lhs } => {
-                    self.execute_select_f64imm32_rhs(result, lhs)
+                Instr::SelectI32Ne { result, lhs, rhs } => {
+                    self.execute_select_i32_ne(result, lhs, rhs)
                 }
-                Instr::SelectF64Imm32Lhs { result, lhs } => {
-                    self.execute_select_f64imm32_lhs(result, lhs)
+                Instr::SelectI32NeImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_ne_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32LtS { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_s(result, lhs, rhs)
+                }
+                Instr::SelectI32LtSImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_s_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LtSImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_s_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LtU { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_u(result, lhs, rhs)
+                }
+                Instr::SelectI32LtUImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_u_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LtUImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i32_lt_u_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LeS { result, lhs, rhs } => {
+                    self.execute_select_i32_le_s(result, lhs, rhs)
+                }
+                Instr::SelectI32LeSImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i32_le_s_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LeSImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i32_le_s_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LeU { result, lhs, rhs } => {
+                    self.execute_select_i32_le_u(result, lhs, rhs)
+                }
+                Instr::SelectI32LeUImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i32_le_u_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI32LeUImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i32_le_u_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI32And { result, lhs, rhs } => {
+                    self.execute_select_i32_and(result, lhs, rhs)
+                }
+                Instr::SelectI32AndImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_and_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32Or { result, lhs, rhs } => {
+                    self.execute_select_i32_or(result, lhs, rhs)
+                }
+                Instr::SelectI32OrImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_or_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32Xor { result, lhs, rhs } => {
+                    self.execute_select_i32_xor(result, lhs, rhs)
+                }
+                Instr::SelectI32XorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_xor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32Nand { result, lhs, rhs } => {
+                    self.execute_select_i32_nand(result, lhs, rhs)
+                }
+                Instr::SelectI32NandImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_nand_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32Nor { result, lhs, rhs } => {
+                    self.execute_select_i32_nor(result, lhs, rhs)
+                }
+                Instr::SelectI32NorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_nor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI32Xnor { result, lhs, rhs } => {
+                    self.execute_select_i32_xnor(result, lhs, rhs)
+                }
+                Instr::SelectI32XnorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i32_xnor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Eq { result, lhs, rhs } => {
+                    self.execute_select_i64_eq(result, lhs, rhs)
+                }
+                Instr::SelectI64EqImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_eq_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Ne { result, lhs, rhs } => {
+                    self.execute_select_i64_ne(result, lhs, rhs)
+                }
+                Instr::SelectI64NeImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_ne_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64LtS { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_s(result, lhs, rhs)
+                }
+                Instr::SelectI64LtSImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_s_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LtSImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_s_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LtU { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_u(result, lhs, rhs)
+                }
+                Instr::SelectI64LtUImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_u_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LtUImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i64_lt_u_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LeS { result, lhs, rhs } => {
+                    self.execute_select_i64_le_s(result, lhs, rhs)
+                }
+                Instr::SelectI64LeSImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i64_le_s_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LeSImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i64_le_s_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LeU { result, lhs, rhs } => {
+                    self.execute_select_i64_le_u(result, lhs, rhs)
+                }
+                Instr::SelectI64LeUImm16Rhs { result, lhs, rhs } => {
+                    self.execute_select_i64_le_u_imm16_rhs(result, lhs, rhs)
+                }
+                Instr::SelectI64LeUImm16Lhs { result, lhs, rhs } => {
+                    self.execute_select_i64_le_u_imm16_lhs(result, lhs, rhs)
+                }
+                Instr::SelectI64And { result, lhs, rhs } => {
+                    self.execute_select_i64_and(result, lhs, rhs)
+                }
+                Instr::SelectI64AndImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_and_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Or { result, lhs, rhs } => {
+                    self.execute_select_i64_or(result, lhs, rhs)
+                }
+                Instr::SelectI64OrImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_or_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Xor { result, lhs, rhs } => {
+                    self.execute_select_i64_xor(result, lhs, rhs)
+                }
+                Instr::SelectI64XorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_xor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Nand { result, lhs, rhs } => {
+                    self.execute_select_i64_nand(result, lhs, rhs)
+                }
+                Instr::SelectI64NandImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_nand_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Nor { result, lhs, rhs } => {
+                    self.execute_select_i64_nor(result, lhs, rhs)
+                }
+                Instr::SelectI64NorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_nor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectI64Xnor { result, lhs, rhs } => {
+                    self.execute_select_i64_xnor(result, lhs, rhs)
+                }
+                Instr::SelectI64XnorImm16 { result, lhs, rhs } => {
+                    self.execute_select_i64_xnor_imm16(result, lhs, rhs)
+                }
+                Instr::SelectF32Eq { result, lhs, rhs } => {
+                    self.execute_select_f32_eq(result, lhs, rhs)
+                }
+                Instr::SelectF32Ne { result, lhs, rhs } => {
+                    self.execute_select_f32_ne(result, lhs, rhs)
+                }
+                Instr::SelectF32Lt { result, lhs, rhs } => {
+                    self.execute_select_f32_lt(result, lhs, rhs)
+                }
+                Instr::SelectF32Le { result, lhs, rhs } => {
+                    self.execute_select_f32_le(result, lhs, rhs)
+                }
+                Instr::SelectF32NotLt { result, lhs, rhs } => {
+                    self.execute_select_f32_not_lt(result, lhs, rhs)
+                }
+                Instr::SelectF32NotLe { result, lhs, rhs } => {
+                    self.execute_select_f32_not_le(result, lhs, rhs)
+                }
+                Instr::SelectF64Eq { result, lhs, rhs } => {
+                    self.execute_select_f64_eq(result, lhs, rhs)
+                }
+                Instr::SelectF64Ne { result, lhs, rhs } => {
+                    self.execute_select_f64_ne(result, lhs, rhs)
+                }
+                Instr::SelectF64Lt { result, lhs, rhs } => {
+                    self.execute_select_f64_lt(result, lhs, rhs)
+                }
+                Instr::SelectF64Le { result, lhs, rhs } => {
+                    self.execute_select_f64_le(result, lhs, rhs)
+                }
+                Instr::SelectF64NotLt { result, lhs, rhs } => {
+                    self.execute_select_f64_not_lt(result, lhs, rhs)
+                }
+                Instr::SelectF64NotLe { result, lhs, rhs } => {
+                    self.execute_select_f64_not_le(result, lhs, rhs)
                 }
-                Instr::SelectF64Imm32 { result, lhs } => self.execute_select_f64imm32(result, lhs),
                 Instr::RefFunc { result, func } => self.execute_ref_func(result, func),
                 Instr::GlobalGet { result, global } => {
                     self.execute_global_get(store.inner(), result, global)