diff --git a/cranelift/fuzzgen/src/function_generator.rs b/cranelift/fuzzgen/src/function_generator.rs
index 00c4a92127..744b923cae 100644
--- a/cranelift/fuzzgen/src/function_generator.rs
+++ b/cranelift/fuzzgen/src/function_generator.rs
@@ -189,7 +189,6 @@ fn insert_const(
 fn insert_bitcast(
     fgen: &mut FunctionGenerator,
     builder: &mut FunctionBuilder,
-    _opcode: Opcode,
     args: &'static [Type],
     rets: &'static [Type],
 ) -> Result<()> {
@@ -213,6 +212,10 @@ fn insert_load_store(
     args: &'static [Type],
     rets: &'static [Type],
 ) -> Result<()> {
+    if opcode == Opcode::Bitcast {
+        return insert_bitcast(fgen, builder, args, rets);
+    }
+
     let ctrl_type = *rets.first().or(args.first()).unwrap();
     let type_size = ctrl_type.bytes();
 
@@ -666,617 +669,616 @@ type OpcodeSignature = (
     Opcode,
     &'static [Type], // Args
     &'static [Type], // Rets
-    OpcodeInserter,
 );
 
 // TODO: Derive this from the `cranelift-meta` generator.
 #[rustfmt::skip]
 const OPCODE_SIGNATURES: &[OpcodeSignature] = &[
-    (Opcode::Nop, &[], &[], insert_opcode),
+    (Opcode::Nop, &[], &[]),
     // Iadd
-    (Opcode::Iadd, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Iadd, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Iadd, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Iadd, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Iadd, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Iadd, &[I8, I8], &[I8]),
+    (Opcode::Iadd, &[I16, I16], &[I16]),
+    (Opcode::Iadd, &[I32, I32], &[I32]),
+    (Opcode::Iadd, &[I64, I64], &[I64]),
+    (Opcode::Iadd, &[I128, I128], &[I128]),
     // IaddCout
-    (Opcode::IaddCout, &[I8, I8], &[I8, I8], insert_opcode),
-    (Opcode::IaddCout, &[I16, I16], &[I16, I8], insert_opcode),
-    (Opcode::IaddCout, &[I32, I32], &[I32, I8], insert_opcode),
-    (Opcode::IaddCout, &[I64, I64], &[I64, I8], insert_opcode),
-    (Opcode::IaddCout, &[I128, I128], &[I128, I8], insert_opcode),
+    (Opcode::IaddCout, &[I8, I8], &[I8, I8]),
+    (Opcode::IaddCout, &[I16, I16], &[I16, I8]),
+    (Opcode::IaddCout, &[I32, I32], &[I32, I8]),
+    (Opcode::IaddCout, &[I64, I64], &[I64, I8]),
+    (Opcode::IaddCout, &[I128, I128], &[I128, I8]),
     // Isub
-    (Opcode::Isub, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Isub, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Isub, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Isub, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Isub, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Isub, &[I8, I8], &[I8]),
+    (Opcode::Isub, &[I16, I16], &[I16]),
+    (Opcode::Isub, &[I32, I32], &[I32]),
+    (Opcode::Isub, &[I64, I64], &[I64]),
+    (Opcode::Isub, &[I128, I128], &[I128]),
     // Imul
-    (Opcode::Imul, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Imul, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Imul, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Imul, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Imul, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Imul, &[I8, I8], &[I8]),
+    (Opcode::Imul, &[I16, I16], &[I16]),
+    (Opcode::Imul, &[I32, I32], &[I32]),
+    (Opcode::Imul, &[I64, I64], &[I64]),
+    (Opcode::Imul, &[I128, I128], &[I128]),
     // Smulhi
-    (Opcode::Smulhi, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Smulhi, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Smulhi, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Smulhi, &[I64, I64], &[I64], insert_opcode),
+    (Opcode::Smulhi, &[I8, I8], &[I8]),
+    (Opcode::Smulhi, &[I16, I16], &[I16]),
+    (Opcode::Smulhi, &[I32, I32], &[I32]),
+    (Opcode::Smulhi, &[I64, I64], &[I64]),
     // Umulhi
-    (Opcode::Umulhi, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Umulhi, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Umulhi, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Umulhi, &[I64, I64], &[I64], insert_opcode),
+    (Opcode::Umulhi, &[I8, I8], &[I8]),
+    (Opcode::Umulhi, &[I16, I16], &[I16]),
+    (Opcode::Umulhi, &[I32, I32], &[I32]),
+    (Opcode::Umulhi, &[I64, I64], &[I64]),
     // Udiv
-    (Opcode::Udiv, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Udiv, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Udiv, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Udiv, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Udiv, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Udiv, &[I8, I8], &[I8]),
+    (Opcode::Udiv, &[I16, I16], &[I16]),
+    (Opcode::Udiv, &[I32, I32], &[I32]),
+    (Opcode::Udiv, &[I64, I64], &[I64]),
+    (Opcode::Udiv, &[I128, I128], &[I128]),
     // Sdiv
-    (Opcode::Sdiv, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Sdiv, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Sdiv, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Sdiv, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Sdiv, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Sdiv, &[I8, I8], &[I8]),
+    (Opcode::Sdiv, &[I16, I16], &[I16]),
+    (Opcode::Sdiv, &[I32, I32], &[I32]),
+    (Opcode::Sdiv, &[I64, I64], &[I64]),
+    (Opcode::Sdiv, &[I128, I128], &[I128]),
     // Urem
-    (Opcode::Urem, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Urem, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Urem, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Urem, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Urem, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Urem, &[I8, I8], &[I8]),
+    (Opcode::Urem, &[I16, I16], &[I16]),
+    (Opcode::Urem, &[I32, I32], &[I32]),
+    (Opcode::Urem, &[I64, I64], &[I64]),
+    (Opcode::Urem, &[I128, I128], &[I128]),
     // Srem
-    (Opcode::Srem, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Srem, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Srem, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Srem, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Srem, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Srem, &[I8, I8], &[I8]),
+    (Opcode::Srem, &[I16, I16], &[I16]),
+    (Opcode::Srem, &[I32, I32], &[I32]),
+    (Opcode::Srem, &[I64, I64], &[I64]),
+    (Opcode::Srem, &[I128, I128], &[I128]),
     // Ineg
-    (Opcode::Ineg, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Ineg, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Ineg, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Ineg, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Ineg, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Ineg, &[I8, I8], &[I8]),
+    (Opcode::Ineg, &[I16, I16], &[I16]),
+    (Opcode::Ineg, &[I32, I32], &[I32]),
+    (Opcode::Ineg, &[I64, I64], &[I64]),
+    (Opcode::Ineg, &[I128, I128], &[I128]),
     // Iabs
-    (Opcode::Iabs, &[I8], &[I8], insert_opcode),
-    (Opcode::Iabs, &[I16], &[I16], insert_opcode),
-    (Opcode::Iabs, &[I32], &[I32], insert_opcode),
-    (Opcode::Iabs, &[I64], &[I64], insert_opcode),
-    (Opcode::Iabs, &[I128], &[I128], insert_opcode),
-    (Opcode::Iabs, &[I8X16, I8X16], &[I8X16], insert_opcode),
-    (Opcode::Iabs, &[I16X8, I16X8], &[I16X8], insert_opcode),
-    (Opcode::Iabs, &[I32X4, I32X4], &[I32X4], insert_opcode),
-    (Opcode::Iabs, &[I64X2, I64X2], &[I64X2], insert_opcode),
+    (Opcode::Iabs, &[I8], &[I8]),
+    (Opcode::Iabs, &[I16], &[I16]),
+    (Opcode::Iabs, &[I32], &[I32]),
+    (Opcode::Iabs, &[I64], &[I64]),
+    (Opcode::Iabs, &[I128], &[I128]),
+    (Opcode::Iabs, &[I8X16, I8X16], &[I8X16]),
+    (Opcode::Iabs, &[I16X8, I16X8], &[I16X8]),
+    (Opcode::Iabs, &[I32X4, I32X4], &[I32X4]),
+    (Opcode::Iabs, &[I64X2, I64X2], &[I64X2]),
     // Smin
-    (Opcode::Smin, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Smin, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Smin, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Smin, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Smin, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Smin, &[I8, I8], &[I8]),
+    (Opcode::Smin, &[I16, I16], &[I16]),
+    (Opcode::Smin, &[I32, I32], &[I32]),
+    (Opcode::Smin, &[I64, I64], &[I64]),
+    (Opcode::Smin, &[I128, I128], &[I128]),
     // Umin
-    (Opcode::Umin, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Umin, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Umin, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Umin, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Umin, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Umin, &[I8, I8], &[I8]),
+    (Opcode::Umin, &[I16, I16], &[I16]),
+    (Opcode::Umin, &[I32, I32], &[I32]),
+    (Opcode::Umin, &[I64, I64], &[I64]),
+    (Opcode::Umin, &[I128, I128], &[I128]),
     // Smax
-    (Opcode::Smax, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Smax, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Smax, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Smax, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Smax, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Smax, &[I8, I8], &[I8]),
+    (Opcode::Smax, &[I16, I16], &[I16]),
+    (Opcode::Smax, &[I32, I32], &[I32]),
+    (Opcode::Smax, &[I64, I64], &[I64]),
+    (Opcode::Smax, &[I128, I128], &[I128]),
     // Umax
-    (Opcode::Umax, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Umax, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Umax, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Umax, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Umax, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Umax, &[I8, I8], &[I8]),
+    (Opcode::Umax, &[I16, I16], &[I16]),
+    (Opcode::Umax, &[I32, I32], &[I32]),
+    (Opcode::Umax, &[I64, I64], &[I64]),
+    (Opcode::Umax, &[I128, I128], &[I128]),
     // Rotr
-    (Opcode::Rotr, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Rotr, &[I8, I16], &[I8], insert_opcode),
-    (Opcode::Rotr, &[I8, I32], &[I8], insert_opcode),
-    (Opcode::Rotr, &[I8, I64], &[I8], insert_opcode),
-    (Opcode::Rotr, &[I8, I128], &[I8], insert_opcode),
-    (Opcode::Rotr, &[I16, I8], &[I16], insert_opcode),
-    (Opcode::Rotr, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Rotr, &[I16, I32], &[I16], insert_opcode),
-    (Opcode::Rotr, &[I16, I64], &[I16], insert_opcode),
-    (Opcode::Rotr, &[I16, I128], &[I16], insert_opcode),
-    (Opcode::Rotr, &[I32, I8], &[I32], insert_opcode),
-    (Opcode::Rotr, &[I32, I16], &[I32], insert_opcode),
-    (Opcode::Rotr, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Rotr, &[I32, I64], &[I32], insert_opcode),
-    (Opcode::Rotr, &[I32, I128], &[I32], insert_opcode),
-    (Opcode::Rotr, &[I64, I8], &[I64], insert_opcode),
-    (Opcode::Rotr, &[I64, I16], &[I64], insert_opcode),
-    (Opcode::Rotr, &[I64, I32], &[I64], insert_opcode),
-    (Opcode::Rotr, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Rotr, &[I64, I128], &[I64], insert_opcode),
-    (Opcode::Rotr, &[I128, I8], &[I128], insert_opcode),
-    (Opcode::Rotr, &[I128, I16], &[I128], insert_opcode),
-    (Opcode::Rotr, &[I128, I32], &[I128], insert_opcode),
-    (Opcode::Rotr, &[I128, I64], &[I128], insert_opcode),
-    (Opcode::Rotr, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Rotr, &[I8, I8], &[I8]),
+    (Opcode::Rotr, &[I8, I16], &[I8]),
+    (Opcode::Rotr, &[I8, I32], &[I8]),
+    (Opcode::Rotr, &[I8, I64], &[I8]),
+    (Opcode::Rotr, &[I8, I128], &[I8]),
+    (Opcode::Rotr, &[I16, I8], &[I16]),
+    (Opcode::Rotr, &[I16, I16], &[I16]),
+    (Opcode::Rotr, &[I16, I32], &[I16]),
+    (Opcode::Rotr, &[I16, I64], &[I16]),
+    (Opcode::Rotr, &[I16, I128], &[I16]),
+    (Opcode::Rotr, &[I32, I8], &[I32]),
+    (Opcode::Rotr, &[I32, I16], &[I32]),
+    (Opcode::Rotr, &[I32, I32], &[I32]),
+    (Opcode::Rotr, &[I32, I64], &[I32]),
+    (Opcode::Rotr, &[I32, I128], &[I32]),
+    (Opcode::Rotr, &[I64, I8], &[I64]),
+    (Opcode::Rotr, &[I64, I16], &[I64]),
+    (Opcode::Rotr, &[I64, I32], &[I64]),
+    (Opcode::Rotr, &[I64, I64], &[I64]),
+    (Opcode::Rotr, &[I64, I128], &[I64]),
+    (Opcode::Rotr, &[I128, I8], &[I128]),
+    (Opcode::Rotr, &[I128, I16], &[I128]),
+    (Opcode::Rotr, &[I128, I32], &[I128]),
+    (Opcode::Rotr, &[I128, I64], &[I128]),
+    (Opcode::Rotr, &[I128, I128], &[I128]),
     // Rotl
-    (Opcode::Rotl, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Rotl, &[I8, I16], &[I8], insert_opcode),
-    (Opcode::Rotl, &[I8, I32], &[I8], insert_opcode),
-    (Opcode::Rotl, &[I8, I64], &[I8], insert_opcode),
-    (Opcode::Rotl, &[I8, I128], &[I8], insert_opcode),
-    (Opcode::Rotl, &[I16, I8], &[I16], insert_opcode),
-    (Opcode::Rotl, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Rotl, &[I16, I32], &[I16], insert_opcode),
-    (Opcode::Rotl, &[I16, I64], &[I16], insert_opcode),
-    (Opcode::Rotl, &[I16, I128], &[I16], insert_opcode),
-    (Opcode::Rotl, &[I32, I8], &[I32], insert_opcode),
-    (Opcode::Rotl, &[I32, I16], &[I32], insert_opcode),
-    (Opcode::Rotl, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Rotl, &[I32, I64], &[I32], insert_opcode),
-    (Opcode::Rotl, &[I32, I128], &[I32], insert_opcode),
-    (Opcode::Rotl, &[I64, I8], &[I64], insert_opcode),
-    (Opcode::Rotl, &[I64, I16], &[I64], insert_opcode),
-    (Opcode::Rotl, &[I64, I32], &[I64], insert_opcode),
-    (Opcode::Rotl, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Rotl, &[I64, I128], &[I64], insert_opcode),
-    (Opcode::Rotl, &[I128, I8], &[I128], insert_opcode),
-    (Opcode::Rotl, &[I128, I16], &[I128], insert_opcode),
-    (Opcode::Rotl, &[I128, I32], &[I128], insert_opcode),
-    (Opcode::Rotl, &[I128, I64], &[I128], insert_opcode),
-    (Opcode::Rotl, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Rotl, &[I8, I8], &[I8]),
+    (Opcode::Rotl, &[I8, I16], &[I8]),
+    (Opcode::Rotl, &[I8, I32], &[I8]),
+    (Opcode::Rotl, &[I8, I64], &[I8]),
+    (Opcode::Rotl, &[I8, I128], &[I8]),
+    (Opcode::Rotl, &[I16, I8], &[I16]),
+    (Opcode::Rotl, &[I16, I16], &[I16]),
+    (Opcode::Rotl, &[I16, I32], &[I16]),
+    (Opcode::Rotl, &[I16, I64], &[I16]),
+    (Opcode::Rotl, &[I16, I128], &[I16]),
+    (Opcode::Rotl, &[I32, I8], &[I32]),
+    (Opcode::Rotl, &[I32, I16], &[I32]),
+    (Opcode::Rotl, &[I32, I32], &[I32]),
+    (Opcode::Rotl, &[I32, I64], &[I32]),
+    (Opcode::Rotl, &[I32, I128], &[I32]),
+    (Opcode::Rotl, &[I64, I8], &[I64]),
+    (Opcode::Rotl, &[I64, I16], &[I64]),
+    (Opcode::Rotl, &[I64, I32], &[I64]),
+    (Opcode::Rotl, &[I64, I64], &[I64]),
+    (Opcode::Rotl, &[I64, I128], &[I64]),
+    (Opcode::Rotl, &[I128, I8], &[I128]),
+    (Opcode::Rotl, &[I128, I16], &[I128]),
+    (Opcode::Rotl, &[I128, I32], &[I128]),
+    (Opcode::Rotl, &[I128, I64], &[I128]),
+    (Opcode::Rotl, &[I128, I128], &[I128]),
     // Ishl
-    (Opcode::Ishl, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Ishl, &[I8, I16], &[I8], insert_opcode),
-    (Opcode::Ishl, &[I8, I32], &[I8], insert_opcode),
-    (Opcode::Ishl, &[I8, I64], &[I8], insert_opcode),
-    (Opcode::Ishl, &[I8, I128], &[I8], insert_opcode),
-    (Opcode::Ishl, &[I16, I8], &[I16], insert_opcode),
-    (Opcode::Ishl, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Ishl, &[I16, I32], &[I16], insert_opcode),
-    (Opcode::Ishl, &[I16, I64], &[I16], insert_opcode),
-    (Opcode::Ishl, &[I16, I128], &[I16], insert_opcode),
-    (Opcode::Ishl, &[I32, I8], &[I32], insert_opcode),
-    (Opcode::Ishl, &[I32, I16], &[I32], insert_opcode),
-    (Opcode::Ishl, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Ishl, &[I32, I64], &[I32], insert_opcode),
-    (Opcode::Ishl, &[I32, I128], &[I32], insert_opcode),
-    (Opcode::Ishl, &[I64, I8], &[I64], insert_opcode),
-    (Opcode::Ishl, &[I64, I16], &[I64], insert_opcode),
-    (Opcode::Ishl, &[I64, I32], &[I64], insert_opcode),
-    (Opcode::Ishl, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Ishl, &[I64, I128], &[I64], insert_opcode),
-    (Opcode::Ishl, &[I128, I8], &[I128], insert_opcode),
-    (Opcode::Ishl, &[I128, I16], &[I128], insert_opcode),
-    (Opcode::Ishl, &[I128, I32], &[I128], insert_opcode),
-    (Opcode::Ishl, &[I128, I64], &[I128], insert_opcode),
-    (Opcode::Ishl, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Ishl, &[I8, I8], &[I8]),
+    (Opcode::Ishl, &[I8, I16], &[I8]),
+    (Opcode::Ishl, &[I8, I32], &[I8]),
+    (Opcode::Ishl, &[I8, I64], &[I8]),
+    (Opcode::Ishl, &[I8, I128], &[I8]),
+    (Opcode::Ishl, &[I16, I8], &[I16]),
+    (Opcode::Ishl, &[I16, I16], &[I16]),
+    (Opcode::Ishl, &[I16, I32], &[I16]),
+    (Opcode::Ishl, &[I16, I64], &[I16]),
+    (Opcode::Ishl, &[I16, I128], &[I16]),
+    (Opcode::Ishl, &[I32, I8], &[I32]),
+    (Opcode::Ishl, &[I32, I16], &[I32]),
+    (Opcode::Ishl, &[I32, I32], &[I32]),
+    (Opcode::Ishl, &[I32, I64], &[I32]),
+    (Opcode::Ishl, &[I32, I128], &[I32]),
+    (Opcode::Ishl, &[I64, I8], &[I64]),
+    (Opcode::Ishl, &[I64, I16], &[I64]),
+    (Opcode::Ishl, &[I64, I32], &[I64]),
+    (Opcode::Ishl, &[I64, I64], &[I64]),
+    (Opcode::Ishl, &[I64, I128], &[I64]),
+    (Opcode::Ishl, &[I128, I8], &[I128]),
+    (Opcode::Ishl, &[I128, I16], &[I128]),
+    (Opcode::Ishl, &[I128, I32], &[I128]),
+    (Opcode::Ishl, &[I128, I64], &[I128]),
+    (Opcode::Ishl, &[I128, I128], &[I128]),
     // Sshr
-    (Opcode::Sshr, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Sshr, &[I8, I16], &[I8], insert_opcode),
-    (Opcode::Sshr, &[I8, I32], &[I8], insert_opcode),
-    (Opcode::Sshr, &[I8, I64], &[I8], insert_opcode),
-    (Opcode::Sshr, &[I8, I128], &[I8], insert_opcode),
-    (Opcode::Sshr, &[I16, I8], &[I16], insert_opcode),
-    (Opcode::Sshr, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Sshr, &[I16, I32], &[I16], insert_opcode),
-    (Opcode::Sshr, &[I16, I64], &[I16], insert_opcode),
-    (Opcode::Sshr, &[I16, I128], &[I16], insert_opcode),
-    (Opcode::Sshr, &[I32, I8], &[I32], insert_opcode),
-    (Opcode::Sshr, &[I32, I16], &[I32], insert_opcode),
-    (Opcode::Sshr, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Sshr, &[I32, I64], &[I32], insert_opcode),
-    (Opcode::Sshr, &[I32, I128], &[I32], insert_opcode),
-    (Opcode::Sshr, &[I64, I8], &[I64], insert_opcode),
-    (Opcode::Sshr, &[I64, I16], &[I64], insert_opcode),
-    (Opcode::Sshr, &[I64, I32], &[I64], insert_opcode),
-    (Opcode::Sshr, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Sshr, &[I64, I128], &[I64], insert_opcode),
-    (Opcode::Sshr, &[I128, I8], &[I128], insert_opcode),
-    (Opcode::Sshr, &[I128, I16], &[I128], insert_opcode),
-    (Opcode::Sshr, &[I128, I32], &[I128], insert_opcode),
-    (Opcode::Sshr, &[I128, I64], &[I128], insert_opcode),
-    (Opcode::Sshr, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Sshr, &[I8, I8], &[I8]),
+    (Opcode::Sshr, &[I8, I16], &[I8]),
+    (Opcode::Sshr, &[I8, I32], &[I8]),
+    (Opcode::Sshr, &[I8, I64], &[I8]),
+    (Opcode::Sshr, &[I8, I128], &[I8]),
+    (Opcode::Sshr, &[I16, I8], &[I16]),
+    (Opcode::Sshr, &[I16, I16], &[I16]),
+    (Opcode::Sshr, &[I16, I32], &[I16]),
+    (Opcode::Sshr, &[I16, I64], &[I16]),
+    (Opcode::Sshr, &[I16, I128], &[I16]),
+    (Opcode::Sshr, &[I32, I8], &[I32]),
+    (Opcode::Sshr, &[I32, I16], &[I32]),
+    (Opcode::Sshr, &[I32, I32], &[I32]),
+    (Opcode::Sshr, &[I32, I64], &[I32]),
+    (Opcode::Sshr, &[I32, I128], &[I32]),
+    (Opcode::Sshr, &[I64, I8], &[I64]),
+    (Opcode::Sshr, &[I64, I16], &[I64]),
+    (Opcode::Sshr, &[I64, I32], &[I64]),
+    (Opcode::Sshr, &[I64, I64], &[I64]),
+    (Opcode::Sshr, &[I64, I128], &[I64]),
+    (Opcode::Sshr, &[I128, I8], &[I128]),
+    (Opcode::Sshr, &[I128, I16], &[I128]),
+    (Opcode::Sshr, &[I128, I32], &[I128]),
+    (Opcode::Sshr, &[I128, I64], &[I128]),
+    (Opcode::Sshr, &[I128, I128], &[I128]),
     // Ushr
-    (Opcode::Ushr, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Ushr, &[I8, I16], &[I8], insert_opcode),
-    (Opcode::Ushr, &[I8, I32], &[I8], insert_opcode),
-    (Opcode::Ushr, &[I8, I64], &[I8], insert_opcode),
-    (Opcode::Ushr, &[I8, I128], &[I8], insert_opcode),
-    (Opcode::Ushr, &[I16, I8], &[I16], insert_opcode),
-    (Opcode::Ushr, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Ushr, &[I16, I32], &[I16], insert_opcode),
-    (Opcode::Ushr, &[I16, I64], &[I16], insert_opcode),
-    (Opcode::Ushr, &[I16, I128], &[I16], insert_opcode),
-    (Opcode::Ushr, &[I32, I8], &[I32], insert_opcode),
-    (Opcode::Ushr, &[I32, I16], &[I32], insert_opcode),
-    (Opcode::Ushr, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Ushr, &[I32, I64], &[I32], insert_opcode),
-    (Opcode::Ushr, &[I32, I128], &[I32], insert_opcode),
-    (Opcode::Ushr, &[I64, I8], &[I64], insert_opcode),
-    (Opcode::Ushr, &[I64, I16], &[I64], insert_opcode),
-    (Opcode::Ushr, &[I64, I32], &[I64], insert_opcode),
-    (Opcode::Ushr, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Ushr, &[I64, I128], &[I64], insert_opcode),
-    (Opcode::Ushr, &[I128, I8], &[I128], insert_opcode),
-    (Opcode::Ushr, &[I128, I16], &[I128], insert_opcode),
-    (Opcode::Ushr, &[I128, I32], &[I128], insert_opcode),
-    (Opcode::Ushr, &[I128, I64], &[I128], insert_opcode),
-    (Opcode::Ushr, &[I128, I128], &[I128], insert_opcode),
+    (Opcode::Ushr, &[I8, I8], &[I8]),
+    (Opcode::Ushr, &[I8, I16], &[I8]),
+    (Opcode::Ushr, &[I8, I32], &[I8]),
+    (Opcode::Ushr, &[I8, I64], &[I8]),
+    (Opcode::Ushr, &[I8, I128], &[I8]),
+    (Opcode::Ushr, &[I16, I8], &[I16]),
+    (Opcode::Ushr, &[I16, I16], &[I16]),
+    (Opcode::Ushr, &[I16, I32], &[I16]),
+    (Opcode::Ushr, &[I16, I64], &[I16]),
+    (Opcode::Ushr, &[I16, I128], &[I16]),
+    (Opcode::Ushr, &[I32, I8], &[I32]),
+    (Opcode::Ushr, &[I32, I16], &[I32]),
+    (Opcode::Ushr, &[I32, I32], &[I32]),
+    (Opcode::Ushr, &[I32, I64], &[I32]),
+    (Opcode::Ushr, &[I32, I128], &[I32]),
+    (Opcode::Ushr, &[I64, I8], &[I64]),
+    (Opcode::Ushr, &[I64, I16], &[I64]),
+    (Opcode::Ushr, &[I64, I32], &[I64]),
+    (Opcode::Ushr, &[I64, I64], &[I64]),
+    (Opcode::Ushr, &[I64, I128], &[I64]),
+    (Opcode::Ushr, &[I128, I8], &[I128]),
+    (Opcode::Ushr, &[I128, I16], &[I128]),
+    (Opcode::Ushr, &[I128, I32], &[I128]),
+    (Opcode::Ushr, &[I128, I64], &[I128]),
+    (Opcode::Ushr, &[I128, I128], &[I128]),
     // Uextend
-    (Opcode::Uextend, &[I8], &[I16], insert_opcode),
-    (Opcode::Uextend, &[I8], &[I32], insert_opcode),
-    (Opcode::Uextend, &[I8], &[I64], insert_opcode),
-    (Opcode::Uextend, &[I8], &[I128], insert_opcode),
-    (Opcode::Uextend, &[I16], &[I32], insert_opcode),
-    (Opcode::Uextend, &[I16], &[I64], insert_opcode),
-    (Opcode::Uextend, &[I16], &[I128], insert_opcode),
-    (Opcode::Uextend, &[I32], &[I64], insert_opcode),
-    (Opcode::Uextend, &[I32], &[I128], insert_opcode),
-    (Opcode::Uextend, &[I64], &[I128], insert_opcode),
+    (Opcode::Uextend, &[I8], &[I16]),
+    (Opcode::Uextend, &[I8], &[I32]),
+    (Opcode::Uextend, &[I8], &[I64]),
+    (Opcode::Uextend, &[I8], &[I128]),
+    (Opcode::Uextend, &[I16], &[I32]),
+    (Opcode::Uextend, &[I16], &[I64]),
+    (Opcode::Uextend, &[I16], &[I128]),
+    (Opcode::Uextend, &[I32], &[I64]),
+    (Opcode::Uextend, &[I32], &[I128]),
+    (Opcode::Uextend, &[I64], &[I128]),
     // Sextend
-    (Opcode::Sextend, &[I8], &[I16], insert_opcode),
-    (Opcode::Sextend, &[I8], &[I32], insert_opcode),
-    (Opcode::Sextend, &[I8], &[I64], insert_opcode),
-    (Opcode::Sextend, &[I8], &[I128], insert_opcode),
-    (Opcode::Sextend, &[I16], &[I32], insert_opcode),
-    (Opcode::Sextend, &[I16], &[I64], insert_opcode),
-    (Opcode::Sextend, &[I16], &[I128], insert_opcode),
-    (Opcode::Sextend, &[I32], &[I64], insert_opcode),
-    (Opcode::Sextend, &[I32], &[I128], insert_opcode),
-    (Opcode::Sextend, &[I64], &[I128], insert_opcode),
+    (Opcode::Sextend, &[I8], &[I16]),
+    (Opcode::Sextend, &[I8], &[I32]),
+    (Opcode::Sextend, &[I8], &[I64]),
+    (Opcode::Sextend, &[I8], &[I128]),
+    (Opcode::Sextend, &[I16], &[I32]),
+    (Opcode::Sextend, &[I16], &[I64]),
+    (Opcode::Sextend, &[I16], &[I128]),
+    (Opcode::Sextend, &[I32], &[I64]),
+    (Opcode::Sextend, &[I32], &[I128]),
+    (Opcode::Sextend, &[I64], &[I128]),
     // Ireduce
-    (Opcode::Ireduce, &[I16], &[I8], insert_opcode),
-    (Opcode::Ireduce, &[I32], &[I8], insert_opcode),
-    (Opcode::Ireduce, &[I32], &[I16], insert_opcode),
-    (Opcode::Ireduce, &[I64], &[I8], insert_opcode),
-    (Opcode::Ireduce, &[I64], &[I16], insert_opcode),
-    (Opcode::Ireduce, &[I64], &[I32], insert_opcode),
-    (Opcode::Ireduce, &[I128], &[I8], insert_opcode),
-    (Opcode::Ireduce, &[I128], &[I16], insert_opcode),
-    (Opcode::Ireduce, &[I128], &[I32], insert_opcode),
-    (Opcode::Ireduce, &[I128], &[I64], insert_opcode),
+    (Opcode::Ireduce, &[I16], &[I8]),
+    (Opcode::Ireduce, &[I32], &[I8]),
+    (Opcode::Ireduce, &[I32], &[I16]),
+    (Opcode::Ireduce, &[I64], &[I8]),
+    (Opcode::Ireduce, &[I64], &[I16]),
+    (Opcode::Ireduce, &[I64], &[I32]),
+    (Opcode::Ireduce, &[I128], &[I8]),
+    (Opcode::Ireduce, &[I128], &[I16]),
+    (Opcode::Ireduce, &[I128], &[I32]),
+    (Opcode::Ireduce, &[I128], &[I64]),
     // Isplit
-    (Opcode::Isplit, &[I128], &[I64, I64], insert_opcode),
+    (Opcode::Isplit, &[I128], &[I64, I64]),
     // Iconcat
-    (Opcode::Iconcat, &[I64, I64], &[I128], insert_opcode),
+    (Opcode::Iconcat, &[I64, I64], &[I128]),
     // Band
-    (Opcode::Band, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Band, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Band, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Band, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Band, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::Band, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Band, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Band, &[I8, I8], &[I8]),
+    (Opcode::Band, &[I16, I16], &[I16]),
+    (Opcode::Band, &[I32, I32], &[I32]),
+    (Opcode::Band, &[I64, I64], &[I64]),
+    (Opcode::Band, &[I128, I128], &[I128]),
+    (Opcode::Band, &[F32, F32], &[F32]),
+    (Opcode::Band, &[F64, F64], &[F64]),
     // Bor
-    (Opcode::Bor, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Bor, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Bor, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Bor, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Bor, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::Bor, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Bor, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Bor, &[I8, I8], &[I8]),
+    (Opcode::Bor, &[I16, I16], &[I16]),
+    (Opcode::Bor, &[I32, I32], &[I32]),
+    (Opcode::Bor, &[I64, I64], &[I64]),
+    (Opcode::Bor, &[I128, I128], &[I128]),
+    (Opcode::Bor, &[F32, F32], &[F32]),
+    (Opcode::Bor, &[F64, F64], &[F64]),
     // Bxor
-    (Opcode::Bxor, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Bxor, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Bxor, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Bxor, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Bxor, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::Bxor, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Bxor, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Bxor, &[I8, I8], &[I8]),
+    (Opcode::Bxor, &[I16, I16], &[I16]),
+    (Opcode::Bxor, &[I32, I32], &[I32]),
+    (Opcode::Bxor, &[I64, I64], &[I64]),
+    (Opcode::Bxor, &[I128, I128], &[I128]),
+    (Opcode::Bxor, &[F32, F32], &[F32]),
+    (Opcode::Bxor, &[F64, F64], &[F64]),
     // Bnot
-    (Opcode::Bnot, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::Bnot, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::Bnot, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::Bnot, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::Bnot, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::Bnot, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Bnot, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Bnot, &[I8, I8], &[I8]),
+    (Opcode::Bnot, &[I16, I16], &[I16]),
+    (Opcode::Bnot, &[I32, I32], &[I32]),
+    (Opcode::Bnot, &[I64, I64], &[I64]),
+    (Opcode::Bnot, &[I128, I128], &[I128]),
+    (Opcode::Bnot, &[F32, F32], &[F32]),
+    (Opcode::Bnot, &[F64, F64], &[F64]),
     // BandNot
-    (Opcode::BandNot, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::BandNot, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::BandNot, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::BandNot, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::BandNot, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::BandNot, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::BandNot, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::BandNot, &[I8, I8], &[I8]),
+    (Opcode::BandNot, &[I16, I16], &[I16]),
+    (Opcode::BandNot, &[I32, I32], &[I32]),
+    (Opcode::BandNot, &[I64, I64], &[I64]),
+    (Opcode::BandNot, &[I128, I128], &[I128]),
+    (Opcode::BandNot, &[F32, F32], &[F32]),
+    (Opcode::BandNot, &[F64, F64], &[F64]),
     // BorNot
-    (Opcode::BorNot, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::BorNot, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::BorNot, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::BorNot, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::BorNot, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::BorNot, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::BorNot, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::BorNot, &[I8, I8], &[I8]),
+    (Opcode::BorNot, &[I16, I16], &[I16]),
+    (Opcode::BorNot, &[I32, I32], &[I32]),
+    (Opcode::BorNot, &[I64, I64], &[I64]),
+    (Opcode::BorNot, &[I128, I128], &[I128]),
+    (Opcode::BorNot, &[F32, F32], &[F32]),
+    (Opcode::BorNot, &[F64, F64], &[F64]),
     // BxorNot
-    (Opcode::BxorNot, &[I8, I8], &[I8], insert_opcode),
-    (Opcode::BxorNot, &[I16, I16], &[I16], insert_opcode),
-    (Opcode::BxorNot, &[I32, I32], &[I32], insert_opcode),
-    (Opcode::BxorNot, &[I64, I64], &[I64], insert_opcode),
-    (Opcode::BxorNot, &[I128, I128], &[I128], insert_opcode),
-    (Opcode::BxorNot, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::BxorNot, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::BxorNot, &[I8, I8], &[I8]),
+    (Opcode::BxorNot, &[I16, I16], &[I16]),
+    (Opcode::BxorNot, &[I32, I32], &[I32]),
+    (Opcode::BxorNot, &[I64, I64], &[I64]),
+    (Opcode::BxorNot, &[I128, I128], &[I128]),
+    (Opcode::BxorNot, &[F32, F32], &[F32]),
+    (Opcode::BxorNot, &[F64, F64], &[F64]),
     // Bitrev
-    (Opcode::Bitrev, &[I8], &[I8], insert_opcode),
-    (Opcode::Bitrev, &[I16], &[I16], insert_opcode),
-    (Opcode::Bitrev, &[I32], &[I32], insert_opcode),
-    (Opcode::Bitrev, &[I64], &[I64], insert_opcode),
-    (Opcode::Bitrev, &[I128], &[I128], insert_opcode),
+    (Opcode::Bitrev, &[I8], &[I8]),
+    (Opcode::Bitrev, &[I16], &[I16]),
+    (Opcode::Bitrev, &[I32], &[I32]),
+    (Opcode::Bitrev, &[I64], &[I64]),
+    (Opcode::Bitrev, &[I128], &[I128]),
     // Clz
-    (Opcode::Clz, &[I8], &[I8], insert_opcode),
-    (Opcode::Clz, &[I16], &[I16], insert_opcode),
-    (Opcode::Clz, &[I32], &[I32], insert_opcode),
-    (Opcode::Clz, &[I64], &[I64], insert_opcode),
-    (Opcode::Clz, &[I128], &[I128], insert_opcode),
+    (Opcode::Clz, &[I8], &[I8]),
+    (Opcode::Clz, &[I16], &[I16]),
+    (Opcode::Clz, &[I32], &[I32]),
+    (Opcode::Clz, &[I64], &[I64]),
+    (Opcode::Clz, &[I128], &[I128]),
     // Cls
-    (Opcode::Cls, &[I8], &[I8], insert_opcode),
-    (Opcode::Cls, &[I16], &[I16], insert_opcode),
-    (Opcode::Cls, &[I32], &[I32], insert_opcode),
-    (Opcode::Cls, &[I64], &[I64], insert_opcode),
-    (Opcode::Cls, &[I128], &[I128], insert_opcode),
+    (Opcode::Cls, &[I8], &[I8]),
+    (Opcode::Cls, &[I16], &[I16]),
+    (Opcode::Cls, &[I32], &[I32]),
+    (Opcode::Cls, &[I64], &[I64]),
+    (Opcode::Cls, &[I128], &[I128]),
     // Ctz
-    (Opcode::Ctz, &[I8], &[I8], insert_opcode),
-    (Opcode::Ctz, &[I16], &[I16], insert_opcode),
-    (Opcode::Ctz, &[I32], &[I32], insert_opcode),
-    (Opcode::Ctz, &[I64], &[I64], insert_opcode),
-    (Opcode::Ctz, &[I128], &[I128], insert_opcode),
+    (Opcode::Ctz, &[I8], &[I8]),
+    (Opcode::Ctz, &[I16], &[I16]),
+    (Opcode::Ctz, &[I32], &[I32]),
+    (Opcode::Ctz, &[I64], &[I64]),
+    (Opcode::Ctz, &[I128], &[I128]),
     // Popcnt
-    (Opcode::Popcnt, &[I8], &[I8], insert_opcode),
-    (Opcode::Popcnt, &[I16], &[I16], insert_opcode),
-    (Opcode::Popcnt, &[I32], &[I32], insert_opcode),
-    (Opcode::Popcnt, &[I64], &[I64], insert_opcode),
-    (Opcode::Popcnt, &[I128], &[I128], insert_opcode),
+    (Opcode::Popcnt, &[I8], &[I8]),
+    (Opcode::Popcnt, &[I16], &[I16]),
+    (Opcode::Popcnt, &[I32], &[I32]),
+    (Opcode::Popcnt, &[I64], &[I64]),
+    (Opcode::Popcnt, &[I128], &[I128]),
     // Bmask
-    (Opcode::Bmask, &[I8], &[I8], insert_opcode),
-    (Opcode::Bmask, &[I16], &[I8], insert_opcode),
-    (Opcode::Bmask, &[I32], &[I8], insert_opcode),
-    (Opcode::Bmask, &[I64], &[I8], insert_opcode),
-    (Opcode::Bmask, &[I128], &[I8], insert_opcode),
-    (Opcode::Bmask, &[I8], &[I16], insert_opcode),
-    (Opcode::Bmask, &[I16], &[I16], insert_opcode),
-    (Opcode::Bmask, &[I32], &[I16], insert_opcode),
-    (Opcode::Bmask, &[I64], &[I16], insert_opcode),
-    (Opcode::Bmask, &[I128], &[I16], insert_opcode),
-    (Opcode::Bmask, &[I8], &[I32], insert_opcode),
-    (Opcode::Bmask, &[I16], &[I32], insert_opcode),
-    (Opcode::Bmask, &[I32], &[I32], insert_opcode),
-    (Opcode::Bmask, &[I64], &[I32], insert_opcode),
-    (Opcode::Bmask, &[I128], &[I32], insert_opcode),
-    (Opcode::Bmask, &[I8], &[I64], insert_opcode),
-    (Opcode::Bmask, &[I16], &[I64], insert_opcode),
-    (Opcode::Bmask, &[I32], &[I64], insert_opcode),
-    (Opcode::Bmask, &[I64], &[I64], insert_opcode),
-    (Opcode::Bmask, &[I128], &[I64], insert_opcode),
-    (Opcode::Bmask, &[I8], &[I128], insert_opcode),
-    (Opcode::Bmask, &[I16], &[I128], insert_opcode),
-    (Opcode::Bmask, &[I32], &[I128], insert_opcode),
-    (Opcode::Bmask, &[I64], &[I128], insert_opcode),
-    (Opcode::Bmask, &[I128], &[I128], insert_opcode),
+    (Opcode::Bmask, &[I8], &[I8]),
+    (Opcode::Bmask, &[I16], &[I8]),
+    (Opcode::Bmask, &[I32], &[I8]),
+    (Opcode::Bmask, &[I64], &[I8]),
+    (Opcode::Bmask, &[I128], &[I8]),
+    (Opcode::Bmask, &[I8], &[I16]),
+    (Opcode::Bmask, &[I16], &[I16]),
+    (Opcode::Bmask, &[I32], &[I16]),
+    (Opcode::Bmask, &[I64], &[I16]),
+    (Opcode::Bmask, &[I128], &[I16]),
+    (Opcode::Bmask, &[I8], &[I32]),
+    (Opcode::Bmask, &[I16], &[I32]),
+    (Opcode::Bmask, &[I32], &[I32]),
+    (Opcode::Bmask, &[I64], &[I32]),
+    (Opcode::Bmask, &[I128], &[I32]),
+    (Opcode::Bmask, &[I8], &[I64]),
+    (Opcode::Bmask, &[I16], &[I64]),
+    (Opcode::Bmask, &[I32], &[I64]),
+    (Opcode::Bmask, &[I64], &[I64]),
+    (Opcode::Bmask, &[I128], &[I64]),
+    (Opcode::Bmask, &[I8], &[I128]),
+    (Opcode::Bmask, &[I16], &[I128]),
+    (Opcode::Bmask, &[I32], &[I128]),
+    (Opcode::Bmask, &[I64], &[I128]),
+    (Opcode::Bmask, &[I128], &[I128]),
     // Bswap
-    (Opcode::Bswap, &[I16], &[I16], insert_opcode),
-    (Opcode::Bswap, &[I32], &[I32], insert_opcode),
-    (Opcode::Bswap, &[I64], &[I64], insert_opcode),
-    (Opcode::Bswap, &[I128], &[I128], insert_opcode),
+    (Opcode::Bswap, &[I16], &[I16]),
+    (Opcode::Bswap, &[I32], &[I32]),
+    (Opcode::Bswap, &[I64], &[I64]),
+    (Opcode::Bswap, &[I128], &[I128]),
     // Bitselect
-    (Opcode::Bitselect, &[I8, I8, I8], &[I8], insert_opcode),
-    (Opcode::Bitselect, &[I16, I16, I16], &[I16], insert_opcode),
-    (Opcode::Bitselect, &[I32, I32, I32], &[I32], insert_opcode),
-    (Opcode::Bitselect, &[I64, I64, I64], &[I64], insert_opcode),
-    (Opcode::Bitselect, &[I128, I128, I128], &[I128], insert_opcode),
+    (Opcode::Bitselect, &[I8, I8, I8], &[I8]),
+    (Opcode::Bitselect, &[I16, I16, I16], &[I16]),
+    (Opcode::Bitselect, &[I32, I32, I32], &[I32]),
+    (Opcode::Bitselect, &[I64, I64, I64], &[I64]),
+    (Opcode::Bitselect, &[I128, I128, I128], &[I128]),
     // Select
-    (Opcode::Select, &[I8, I8, I8], &[I8], insert_opcode),
-    (Opcode::Select, &[I8, I16, I16], &[I16], insert_opcode),
-    (Opcode::Select, &[I8, I32, I32], &[I32], insert_opcode),
-    (Opcode::Select, &[I8, I64, I64], &[I64], insert_opcode),
-    (Opcode::Select, &[I8, I128, I128], &[I128], insert_opcode),
-    (Opcode::Select, &[I16, I8, I8], &[I8], insert_opcode),
-    (Opcode::Select, &[I16, I16, I16], &[I16], insert_opcode),
-    (Opcode::Select, &[I16, I32, I32], &[I32], insert_opcode),
-    (Opcode::Select, &[I16, I64, I64], &[I64], insert_opcode),
-    (Opcode::Select, &[I16, I128, I128], &[I128], insert_opcode),
-    (Opcode::Select, &[I32, I8, I8], &[I8], insert_opcode),
-    (Opcode::Select, &[I32, I16, I16], &[I16], insert_opcode),
-    (Opcode::Select, &[I32, I32, I32], &[I32], insert_opcode),
-    (Opcode::Select, &[I32, I64, I64], &[I64], insert_opcode),
-    (Opcode::Select, &[I32, I128, I128], &[I128], insert_opcode),
-    (Opcode::Select, &[I64, I8, I8], &[I8], insert_opcode),
-    (Opcode::Select, &[I64, I16, I16], &[I16], insert_opcode),
-    (Opcode::Select, &[I64, I32, I32], &[I32], insert_opcode),
-    (Opcode::Select, &[I64, I64, I64], &[I64], insert_opcode),
-    (Opcode::Select, &[I64, I128, I128], &[I128], insert_opcode),
-    (Opcode::Select, &[I128, I8, I8], &[I8], insert_opcode),
-    (Opcode::Select, &[I128, I16, I16], &[I16], insert_opcode),
-    (Opcode::Select, &[I128, I32, I32], &[I32], insert_opcode),
-    (Opcode::Select, &[I128, I64, I64], &[I64], insert_opcode),
-    (Opcode::Select, &[I128, I128, I128], &[I128], insert_opcode),
+    (Opcode::Select, &[I8, I8, I8], &[I8]),
+    (Opcode::Select, &[I8, I16, I16], &[I16]),
+    (Opcode::Select, &[I8, I32, I32], &[I32]),
+    (Opcode::Select, &[I8, I64, I64], &[I64]),
+    (Opcode::Select, &[I8, I128, I128], &[I128]),
+    (Opcode::Select, &[I16, I8, I8], &[I8]),
+    (Opcode::Select, &[I16, I16, I16], &[I16]),
+    (Opcode::Select, &[I16, I32, I32], &[I32]),
+    (Opcode::Select, &[I16, I64, I64], &[I64]),
+    (Opcode::Select, &[I16, I128, I128], &[I128]),
+    (Opcode::Select, &[I32, I8, I8], &[I8]),
+    (Opcode::Select, &[I32, I16, I16], &[I16]),
+    (Opcode::Select, &[I32, I32, I32], &[I32]),
+    (Opcode::Select, &[I32, I64, I64], &[I64]),
+    (Opcode::Select, &[I32, I128, I128], &[I128]),
+    (Opcode::Select, &[I64, I8, I8], &[I8]),
+    (Opcode::Select, &[I64, I16, I16], &[I16]),
+    (Opcode::Select, &[I64, I32, I32], &[I32]),
+    (Opcode::Select, &[I64, I64, I64], &[I64]),
+    (Opcode::Select, &[I64, I128, I128], &[I128]),
+    (Opcode::Select, &[I128, I8, I8], &[I8]),
+    (Opcode::Select, &[I128, I16, I16], &[I16]),
+    (Opcode::Select, &[I128, I32, I32], &[I32]),
+    (Opcode::Select, &[I128, I64, I64], &[I64]),
+    (Opcode::Select, &[I128, I128, I128], &[I128]),
     // SelectSpectreGuard
-    (Opcode::SelectSpectreGuard, &[I8, I8, I8], &[I8], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I8, I16, I16], &[I16], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I8, I32, I32], &[I32], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I8, I64, I64], &[I64], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I8, I128, I128], &[I128], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I16, I8, I8], &[I8], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I16, I16, I16], &[I16], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I16, I32, I32], &[I32], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I16, I64, I64], &[I64], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I16, I128, I128], &[I128], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I32, I8, I8], &[I8], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I32, I16, I16], &[I16], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I32, I32, I32], &[I32], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I32, I64, I64], &[I64], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I32, I128, I128], &[I128], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I64, I8, I8], &[I8], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I64, I16, I16], &[I16], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I64, I32, I32], &[I32], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I64, I64, I64], &[I64], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I64, I128, I128], &[I128], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I128, I8, I8], &[I8], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I128, I16, I16], &[I16], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I128, I32, I32], &[I32], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I128, I64, I64], &[I64], insert_opcode),
-    (Opcode::SelectSpectreGuard, &[I128, I128, I128], &[I128], insert_opcode),
+    (Opcode::SelectSpectreGuard, &[I8, I8, I8], &[I8]),
+    (Opcode::SelectSpectreGuard, &[I8, I16, I16], &[I16]),
+    (Opcode::SelectSpectreGuard, &[I8, I32, I32], &[I32]),
+    (Opcode::SelectSpectreGuard, &[I8, I64, I64], &[I64]),
+    (Opcode::SelectSpectreGuard, &[I8, I128, I128], &[I128]),
+    (Opcode::SelectSpectreGuard, &[I16, I8, I8], &[I8]),
+    (Opcode::SelectSpectreGuard, &[I16, I16, I16], &[I16]),
+    (Opcode::SelectSpectreGuard, &[I16, I32, I32], &[I32]),
+    (Opcode::SelectSpectreGuard, &[I16, I64, I64], &[I64]),
+    (Opcode::SelectSpectreGuard, &[I16, I128, I128], &[I128]),
+    (Opcode::SelectSpectreGuard, &[I32, I8, I8], &[I8]),
+    (Opcode::SelectSpectreGuard, &[I32, I16, I16], &[I16]),
+    (Opcode::SelectSpectreGuard, &[I32, I32, I32], &[I32]),
+    (Opcode::SelectSpectreGuard, &[I32, I64, I64], &[I64]),
+    (Opcode::SelectSpectreGuard, &[I32, I128, I128], &[I128]),
+    (Opcode::SelectSpectreGuard, &[I64, I8, I8], &[I8]),
+    (Opcode::SelectSpectreGuard, &[I64, I16, I16], &[I16]),
+    (Opcode::SelectSpectreGuard, &[I64, I32, I32], &[I32]),
+    (Opcode::SelectSpectreGuard, &[I64, I64, I64], &[I64]),
+    (Opcode::SelectSpectreGuard, &[I64, I128, I128], &[I128]),
+    (Opcode::SelectSpectreGuard, &[I128, I8, I8], &[I8]),
+    (Opcode::SelectSpectreGuard, &[I128, I16, I16], &[I16]),
+    (Opcode::SelectSpectreGuard, &[I128, I32, I32], &[I32]),
+    (Opcode::SelectSpectreGuard, &[I128, I64, I64], &[I64]),
+    (Opcode::SelectSpectreGuard, &[I128, I128, I128], &[I128]),
     // Fadd
-    (Opcode::Fadd, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fadd, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fadd, &[F32, F32], &[F32]),
+    (Opcode::Fadd, &[F64, F64], &[F64]),
     // Fmul
-    (Opcode::Fmul, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fmul, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fmul, &[F32, F32], &[F32]),
+    (Opcode::Fmul, &[F64, F64], &[F64]),
     // Fsub
-    (Opcode::Fsub, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fsub, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fsub, &[F32, F32], &[F32]),
+    (Opcode::Fsub, &[F64, F64], &[F64]),
     // Fdiv
-    (Opcode::Fdiv, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fdiv, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fdiv, &[F32, F32], &[F32]),
+    (Opcode::Fdiv, &[F64, F64], &[F64]),
     // Fmin
-    (Opcode::Fmin, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fmin, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fmin, &[F32, F32], &[F32]),
+    (Opcode::Fmin, &[F64, F64], &[F64]),
     // Fmax
-    (Opcode::Fmax, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fmax, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fmax, &[F32, F32], &[F32]),
+    (Opcode::Fmax, &[F64, F64], &[F64]),
     // FminPseudo
-    (Opcode::FminPseudo, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::FminPseudo, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::FminPseudo, &[F32, F32], &[F32]),
+    (Opcode::FminPseudo, &[F64, F64], &[F64]),
     // FmaxPseudo
-    (Opcode::FmaxPseudo, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::FmaxPseudo, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::FmaxPseudo, &[F32, F32], &[F32]),
+    (Opcode::FmaxPseudo, &[F64, F64], &[F64]),
     // Fcopysign
-    (Opcode::Fcopysign, &[F32, F32], &[F32], insert_opcode),
-    (Opcode::Fcopysign, &[F64, F64], &[F64], insert_opcode),
+    (Opcode::Fcopysign, &[F32, F32], &[F32]),
+    (Opcode::Fcopysign, &[F64, F64], &[F64]),
     // Fma
-    (Opcode::Fma, &[F32, F32, F32], &[F32], insert_opcode),
-    (Opcode::Fma, &[F64, F64, F64], &[F64], insert_opcode),
+    (Opcode::Fma, &[F32, F32, F32], &[F32]),
+    (Opcode::Fma, &[F64, F64, F64], &[F64]),
     // Fabs
-    (Opcode::Fabs, &[F32], &[F32], insert_opcode),
-    (Opcode::Fabs, &[F64], &[F64], insert_opcode),
+    (Opcode::Fabs, &[F32], &[F32]),
+    (Opcode::Fabs, &[F64], &[F64]),
     // Fneg
-    (Opcode::Fneg, &[F32], &[F32], insert_opcode),
-    (Opcode::Fneg, &[F64], &[F64], insert_opcode),
+    (Opcode::Fneg, &[F32], &[F32]),
+    (Opcode::Fneg, &[F64], &[F64]),
     // Sqrt
-    (Opcode::Sqrt, &[F32], &[F32], insert_opcode),
-    (Opcode::Sqrt, &[F64], &[F64], insert_opcode),
+    (Opcode::Sqrt, &[F32], &[F32]),
+    (Opcode::Sqrt, &[F64], &[F64]),
     // Ceil
-    (Opcode::Ceil, &[F32], &[F32], insert_opcode),
-    (Opcode::Ceil, &[F64], &[F64], insert_opcode),
+    (Opcode::Ceil, &[F32], &[F32]),
+    (Opcode::Ceil, &[F64], &[F64]),
     // Floor
-    (Opcode::Floor, &[F32], &[F32], insert_opcode),
-    (Opcode::Floor, &[F64], &[F64], insert_opcode),
+    (Opcode::Floor, &[F32], &[F32]),
+    (Opcode::Floor, &[F64], &[F64]),
     // Trunc
-    (Opcode::Trunc, &[F32], &[F32], insert_opcode),
-    (Opcode::Trunc, &[F64], &[F64], insert_opcode),
+    (Opcode::Trunc, &[F32], &[F32]),
+    (Opcode::Trunc, &[F64], &[F64]),
     // Nearest
-    (Opcode::Nearest, &[F32], &[F32], insert_opcode),
-    (Opcode::Nearest, &[F64], &[F64], insert_opcode),
+    (Opcode::Nearest, &[F32], &[F32]),
+    (Opcode::Nearest, &[F64], &[F64]),
     // Fpromote
-    (Opcode::Fpromote, &[F32], &[F64], insert_opcode),
+    (Opcode::Fpromote, &[F32], &[F64]),
     // Fdemote
-    (Opcode::Fdemote, &[F64], &[F32], insert_opcode),
+    (Opcode::Fdemote, &[F64], &[F32]),
     // FcvtToUint
-    (Opcode::FcvtToUint, &[F32], &[I8], insert_opcode),
-    (Opcode::FcvtToUint, &[F32], &[I16], insert_opcode),
-    (Opcode::FcvtToUint, &[F32], &[I32], insert_opcode),
-    (Opcode::FcvtToUint, &[F32], &[I64], insert_opcode),
-    (Opcode::FcvtToUint, &[F32], &[I128], insert_opcode),
-    (Opcode::FcvtToUint, &[F64], &[I8], insert_opcode),
-    (Opcode::FcvtToUint, &[F64], &[I16], insert_opcode),
-    (Opcode::FcvtToUint, &[F64], &[I32], insert_opcode),
-    (Opcode::FcvtToUint, &[F64], &[I64], insert_opcode),
-    (Opcode::FcvtToUint, &[F64], &[I128], insert_opcode),
+    (Opcode::FcvtToUint, &[F32], &[I8]),
+    (Opcode::FcvtToUint, &[F32], &[I16]),
+    (Opcode::FcvtToUint, &[F32], &[I32]),
+    (Opcode::FcvtToUint, &[F32], &[I64]),
+    (Opcode::FcvtToUint, &[F32], &[I128]),
+    (Opcode::FcvtToUint, &[F64], &[I8]),
+    (Opcode::FcvtToUint, &[F64], &[I16]),
+    (Opcode::FcvtToUint, &[F64], &[I32]),
+    (Opcode::FcvtToUint, &[F64], &[I64]),
+    (Opcode::FcvtToUint, &[F64], &[I128]),
     // FcvtToUintSat
-    (Opcode::FcvtToUintSat, &[F32], &[I8], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F32], &[I16], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F32], &[I32], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F32], &[I64], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F32], &[I128], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F64], &[I8], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F64], &[I16], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F64], &[I32], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F64], &[I64], insert_opcode),
-    (Opcode::FcvtToUintSat, &[F64], &[I128], insert_opcode),
+    (Opcode::FcvtToUintSat, &[F32], &[I8]),
+    (Opcode::FcvtToUintSat, &[F32], &[I16]),
+    (Opcode::FcvtToUintSat, &[F32], &[I32]),
+    (Opcode::FcvtToUintSat, &[F32], &[I64]),
+    (Opcode::FcvtToUintSat, &[F32], &[I128]),
+    (Opcode::FcvtToUintSat, &[F64], &[I8]),
+    (Opcode::FcvtToUintSat, &[F64], &[I16]),
+    (Opcode::FcvtToUintSat, &[F64], &[I32]),
+    (Opcode::FcvtToUintSat, &[F64], &[I64]),
+    (Opcode::FcvtToUintSat, &[F64], &[I128]),
     // FcvtToSint
-    (Opcode::FcvtToSint, &[F32], &[I8], insert_opcode),
-    (Opcode::FcvtToSint, &[F32], &[I16], insert_opcode),
-    (Opcode::FcvtToSint, &[F32], &[I32], insert_opcode),
-    (Opcode::FcvtToSint, &[F32], &[I64], insert_opcode),
-    (Opcode::FcvtToSint, &[F32], &[I128], insert_opcode),
-    (Opcode::FcvtToSint, &[F64], &[I8], insert_opcode),
-    (Opcode::FcvtToSint, &[F64], &[I16], insert_opcode),
-    (Opcode::FcvtToSint, &[F64], &[I32], insert_opcode),
-    (Opcode::FcvtToSint, &[F64], &[I64], insert_opcode),
-    (Opcode::FcvtToSint, &[F64], &[I128], insert_opcode),
+    (Opcode::FcvtToSint, &[F32], &[I8]),
+    (Opcode::FcvtToSint, &[F32], &[I16]),
+    (Opcode::FcvtToSint, &[F32], &[I32]),
+    (Opcode::FcvtToSint, &[F32], &[I64]),
+    (Opcode::FcvtToSint, &[F32], &[I128]),
+    (Opcode::FcvtToSint, &[F64], &[I8]),
+    (Opcode::FcvtToSint, &[F64], &[I16]),
+    (Opcode::FcvtToSint, &[F64], &[I32]),
+    (Opcode::FcvtToSint, &[F64], &[I64]),
+    (Opcode::FcvtToSint, &[F64], &[I128]),
     // FcvtToSintSat
-    (Opcode::FcvtToSintSat, &[F32], &[I8], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F32], &[I16], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F32], &[I32], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F32], &[I64], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F32], &[I128], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F64], &[I8], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F64], &[I16], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F64], &[I32], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F64], &[I64], insert_opcode),
-    (Opcode::FcvtToSintSat, &[F64], &[I128], insert_opcode),
+    (Opcode::FcvtToSintSat, &[F32], &[I8]),
+    (Opcode::FcvtToSintSat, &[F32], &[I16]),
+    (Opcode::FcvtToSintSat, &[F32], &[I32]),
+    (Opcode::FcvtToSintSat, &[F32], &[I64]),
+    (Opcode::FcvtToSintSat, &[F32], &[I128]),
+    (Opcode::FcvtToSintSat, &[F64], &[I8]),
+    (Opcode::FcvtToSintSat, &[F64], &[I16]),
+    (Opcode::FcvtToSintSat, &[F64], &[I32]),
+    (Opcode::FcvtToSintSat, &[F64], &[I64]),
+    (Opcode::FcvtToSintSat, &[F64], &[I128]),
     // FcvtFromUint
-    (Opcode::FcvtFromUint, &[I8], &[F32], insert_opcode),
-    (Opcode::FcvtFromUint, &[I16], &[F32], insert_opcode),
-    (Opcode::FcvtFromUint, &[I32], &[F32], insert_opcode),
-    (Opcode::FcvtFromUint, &[I64], &[F32], insert_opcode),
-    (Opcode::FcvtFromUint, &[I128], &[F32], insert_opcode),
-    (Opcode::FcvtFromUint, &[I8], &[F64], insert_opcode),
-    (Opcode::FcvtFromUint, &[I16], &[F64], insert_opcode),
-    (Opcode::FcvtFromUint, &[I32], &[F64], insert_opcode),
-    (Opcode::FcvtFromUint, &[I64], &[F64], insert_opcode),
-    (Opcode::FcvtFromUint, &[I128], &[F64], insert_opcode),
+    (Opcode::FcvtFromUint, &[I8], &[F32]),
+    (Opcode::FcvtFromUint, &[I16], &[F32]),
+    (Opcode::FcvtFromUint, &[I32], &[F32]),
+    (Opcode::FcvtFromUint, &[I64], &[F32]),
+    (Opcode::FcvtFromUint, &[I128], &[F32]),
+    (Opcode::FcvtFromUint, &[I8], &[F64]),
+    (Opcode::FcvtFromUint, &[I16], &[F64]),
+    (Opcode::FcvtFromUint, &[I32], &[F64]),
+    (Opcode::FcvtFromUint, &[I64], &[F64]),
+    (Opcode::FcvtFromUint, &[I128], &[F64]),
     // FcvtFromSint
-    (Opcode::FcvtFromSint, &[I8], &[F32], insert_opcode),
-    (Opcode::FcvtFromSint, &[I16], &[F32], insert_opcode),
-    (Opcode::FcvtFromSint, &[I32], &[F32], insert_opcode),
-    (Opcode::FcvtFromSint, &[I64], &[F32], insert_opcode),
-    (Opcode::FcvtFromSint, &[I128], &[F32], insert_opcode),
-    (Opcode::FcvtFromSint, &[I8], &[F64], insert_opcode),
-    (Opcode::FcvtFromSint, &[I16], &[F64], insert_opcode),
-    (Opcode::FcvtFromSint, &[I32], &[F64], insert_opcode),
-    (Opcode::FcvtFromSint, &[I64], &[F64], insert_opcode),
-    (Opcode::FcvtFromSint, &[I128], &[F64], insert_opcode),
+    (Opcode::FcvtFromSint, &[I8], &[F32]),
+    (Opcode::FcvtFromSint, &[I16], &[F32]),
+    (Opcode::FcvtFromSint, &[I32], &[F32]),
+    (Opcode::FcvtFromSint, &[I64], &[F32]),
+    (Opcode::FcvtFromSint, &[I128], &[F32]),
+    (Opcode::FcvtFromSint, &[I8], &[F64]),
+    (Opcode::FcvtFromSint, &[I16], &[F64]),
+    (Opcode::FcvtFromSint, &[I32], &[F64]),
+    (Opcode::FcvtFromSint, &[I64], &[F64]),
+    (Opcode::FcvtFromSint, &[I128], &[F64]),
     // Fcmp
-    (Opcode::Fcmp, &[F32, F32], &[I8], insert_cmp),
-    (Opcode::Fcmp, &[F64, F64], &[I8], insert_cmp),
+    (Opcode::Fcmp, &[F32, F32], &[I8]),
+    (Opcode::Fcmp, &[F64, F64], &[I8]),
     // Icmp
-    (Opcode::Icmp, &[I8, I8], &[I8], insert_cmp),
-    (Opcode::Icmp, &[I16, I16], &[I8], insert_cmp),
-    (Opcode::Icmp, &[I32, I32], &[I8], insert_cmp),
-    (Opcode::Icmp, &[I64, I64], &[I8], insert_cmp),
-    (Opcode::Icmp, &[I128, I128], &[I8], insert_cmp),
+    (Opcode::Icmp, &[I8, I8], &[I8]),
+    (Opcode::Icmp, &[I16, I16], &[I8]),
+    (Opcode::Icmp, &[I32, I32], &[I8]),
+    (Opcode::Icmp, &[I64, I64], &[I8]),
+    (Opcode::Icmp, &[I128, I128], &[I8]),
     // Fence
-    (Opcode::Fence, &[], &[], insert_opcode),
+    (Opcode::Fence, &[], &[]),
     // Stack Access
-    (Opcode::StackStore, &[I8], &[], insert_stack_store),
-    (Opcode::StackStore, &[I16], &[], insert_stack_store),
-    (Opcode::StackStore, &[I32], &[], insert_stack_store),
-    (Opcode::StackStore, &[I64], &[], insert_stack_store),
-    (Opcode::StackStore, &[I128], &[], insert_stack_store),
-    (Opcode::StackLoad, &[], &[I8], insert_stack_load),
-    (Opcode::StackLoad, &[], &[I16], insert_stack_load),
-    (Opcode::StackLoad, &[], &[I32], insert_stack_load),
-    (Opcode::StackLoad, &[], &[I64], insert_stack_load),
-    (Opcode::StackLoad, &[], &[I128], insert_stack_load),
+    (Opcode::StackStore, &[I8], &[]),
+    (Opcode::StackStore, &[I16], &[]),
+    (Opcode::StackStore, &[I32], &[]),
+    (Opcode::StackStore, &[I64], &[]),
+    (Opcode::StackStore, &[I128], &[]),
+    (Opcode::StackLoad, &[], &[I8]),
+    (Opcode::StackLoad, &[], &[I16]),
+    (Opcode::StackLoad, &[], &[I32]),
+    (Opcode::StackLoad, &[], &[I64]),
+    (Opcode::StackLoad, &[], &[I128]),
     // Loads
-    (Opcode::Load, &[], &[I8], insert_load_store),
-    (Opcode::Load, &[], &[I16], insert_load_store),
-    (Opcode::Load, &[], &[I32], insert_load_store),
-    (Opcode::Load, &[], &[I64], insert_load_store),
-    (Opcode::Load, &[], &[I128], insert_load_store),
-    (Opcode::Load, &[], &[F32], insert_load_store),
-    (Opcode::Load, &[], &[F64], insert_load_store),
+    (Opcode::Load, &[], &[I8]),
+    (Opcode::Load, &[], &[I16]),
+    (Opcode::Load, &[], &[I32]),
+    (Opcode::Load, &[], &[I64]),
+    (Opcode::Load, &[], &[I128]),
+    (Opcode::Load, &[], &[F32]),
+    (Opcode::Load, &[], &[F64]),
     // Special Loads
-    (Opcode::Uload8, &[], &[I16], insert_load_store),
-    (Opcode::Uload8, &[], &[I32], insert_load_store),
-    (Opcode::Uload8, &[], &[I64], insert_load_store),
-    (Opcode::Uload16, &[], &[I32], insert_load_store),
-    (Opcode::Uload16, &[], &[I64], insert_load_store),
-    (Opcode::Uload32, &[], &[I64], insert_load_store),
-    (Opcode::Sload8, &[], &[I16], insert_load_store),
-    (Opcode::Sload8, &[], &[I32], insert_load_store),
-    (Opcode::Sload8, &[], &[I64], insert_load_store),
-    (Opcode::Sload16, &[], &[I32], insert_load_store),
-    (Opcode::Sload16, &[], &[I64], insert_load_store),
-    (Opcode::Sload32, &[], &[I64], insert_load_store),
+    (Opcode::Uload8, &[], &[I16]),
+    (Opcode::Uload8, &[], &[I32]),
+    (Opcode::Uload8, &[], &[I64]),
+    (Opcode::Uload16, &[], &[I32]),
+    (Opcode::Uload16, &[], &[I64]),
+    (Opcode::Uload32, &[], &[I64]),
+    (Opcode::Sload8, &[], &[I16]),
+    (Opcode::Sload8, &[], &[I32]),
+    (Opcode::Sload8, &[], &[I64]),
+    (Opcode::Sload16, &[], &[I32]),
+    (Opcode::Sload16, &[], &[I64]),
+    (Opcode::Sload32, &[], &[I64]),
     // TODO: Unimplemented in the interpreter
     // Opcode::Uload8x8
     // Opcode::Sload8x8
@@ -1285,57 +1287,102 @@ const OPCODE_SIGNATURES: &[OpcodeSignature] = &[
     // Opcode::Uload32x2
     // Opcode::Sload32x2
     // AtomicLoad
-    (Opcode::AtomicLoad, &[], &[I8], insert_load_store),
-    (Opcode::AtomicLoad, &[], &[I16], insert_load_store),
-    (Opcode::AtomicLoad, &[], &[I32], insert_load_store),
-    (Opcode::AtomicLoad, &[], &[I64], insert_load_store),
+    (Opcode::AtomicLoad, &[], &[I8]),
+    (Opcode::AtomicLoad, &[], &[I16]),
+    (Opcode::AtomicLoad, &[], &[I32]),
+    (Opcode::AtomicLoad, &[], &[I64]),
     // Stores
-    (Opcode::Store, &[I8], &[], insert_load_store),
-    (Opcode::Store, &[I16], &[], insert_load_store),
-    (Opcode::Store, &[I32], &[], insert_load_store),
-    (Opcode::Store, &[I64], &[], insert_load_store),
-    (Opcode::Store, &[I128], &[], insert_load_store),
-    (Opcode::Store, &[F32], &[], insert_load_store),
-    (Opcode::Store, &[F64], &[], insert_load_store),
+    (Opcode::Store, &[I8], &[]),
+    (Opcode::Store, &[I16], &[]),
+    (Opcode::Store, &[I32], &[]),
+    (Opcode::Store, &[I64], &[]),
+    (Opcode::Store, &[I128], &[]),
+    (Opcode::Store, &[F32], &[]),
+    (Opcode::Store, &[F64], &[]),
     // Special Stores
-    (Opcode::Istore8, &[I16], &[], insert_load_store),
-    (Opcode::Istore8, &[I32], &[], insert_load_store),
-    (Opcode::Istore8, &[I64], &[], insert_load_store),
-    (Opcode::Istore16, &[I32], &[], insert_load_store),
-    (Opcode::Istore16, &[I64], &[], insert_load_store),
-    (Opcode::Istore32, &[I64], &[], insert_load_store),
+    (Opcode::Istore8, &[I16], &[]),
+    (Opcode::Istore8, &[I32], &[]),
+    (Opcode::Istore8, &[I64], &[]),
+    (Opcode::Istore16, &[I32], &[]),
+    (Opcode::Istore16, &[I64], &[]),
+    (Opcode::Istore32, &[I64], &[]),
     // AtomicStore
-    (Opcode::AtomicStore, &[I8], &[], insert_load_store),
-    (Opcode::AtomicStore, &[I16], &[], insert_load_store),
-    (Opcode::AtomicStore, &[I32], &[], insert_load_store),
-    (Opcode::AtomicStore, &[I64], &[], insert_load_store),
+    (Opcode::AtomicStore, &[I8], &[]),
+    (Opcode::AtomicStore, &[I16], &[]),
+    (Opcode::AtomicStore, &[I32], &[]),
+    (Opcode::AtomicStore, &[I64], &[]),
     // AtomicRMW
-    (Opcode::AtomicRmw, &[I8, I8], &[I8], insert_atomic_rmw),
-    (Opcode::AtomicRmw, &[I16, I16], &[I16], insert_atomic_rmw),
-    (Opcode::AtomicRmw, &[I32, I32], &[I32], insert_atomic_rmw),
-    (Opcode::AtomicRmw, &[I64, I64], &[I64], insert_atomic_rmw),
+    (Opcode::AtomicRmw, &[I8, I8], &[I8]),
+    (Opcode::AtomicRmw, &[I16, I16], &[I16]),
+    (Opcode::AtomicRmw, &[I32, I32], &[I32]),
+    (Opcode::AtomicRmw, &[I64, I64], &[I64]),
     // AtomicCas
-    (Opcode::AtomicCas, &[I8, I8], &[I8], insert_atomic_cas),
-    (Opcode::AtomicCas, &[I16, I16], &[I16], insert_atomic_cas),
-    (Opcode::AtomicCas, &[I32, I32], &[I32], insert_atomic_cas),
-    (Opcode::AtomicCas, &[I64, I64], &[I64], insert_atomic_cas),
+    (Opcode::AtomicCas, &[I8, I8], &[I8]),
+    (Opcode::AtomicCas, &[I16, I16], &[I16]),
+    (Opcode::AtomicCas, &[I32, I32], &[I32]),
+    (Opcode::AtomicCas, &[I64, I64], &[I64]),
     // Bitcast
-    (Opcode::Bitcast, &[F32], &[I32], insert_bitcast),
-    (Opcode::Bitcast, &[I32], &[F32], insert_bitcast),
-    (Opcode::Bitcast, &[F64], &[I64], insert_bitcast),
-    (Opcode::Bitcast, &[I64], &[F64], insert_bitcast),
+    (Opcode::Bitcast, &[F32], &[I32]),
+    (Opcode::Bitcast, &[I32], &[F32]),
+    (Opcode::Bitcast, &[F64], &[I64]),
+    (Opcode::Bitcast, &[I64], &[F64]),
     // Integer Consts
-    (Opcode::Iconst, &[], &[I8], insert_const),
-    (Opcode::Iconst, &[], &[I16], insert_const),
-    (Opcode::Iconst, &[], &[I32], insert_const),
-    (Opcode::Iconst, &[], &[I64], insert_const),
+    (Opcode::Iconst, &[], &[I8]),
+    (Opcode::Iconst, &[], &[I16]),
+    (Opcode::Iconst, &[], &[I32]),
+    (Opcode::Iconst, &[], &[I64]),
     // Float Consts
-    (Opcode::F32const, &[], &[F32], insert_const),
-    (Opcode::F64const, &[], &[F64], insert_const),
+    (Opcode::F32const, &[], &[F32]),
+    (Opcode::F64const, &[], &[F64]),
     // Call
-    (Opcode::Call, &[], &[], insert_call),
+    (Opcode::Call, &[], &[]),
 ];
 
+fn inserter_for_format(fmt: InstructionFormat) -> OpcodeInserter {
+    match fmt {
+        InstructionFormat::AtomicCas => insert_atomic_cas,
+        InstructionFormat::AtomicRmw => insert_atomic_rmw,
+        InstructionFormat::Binary => insert_opcode,
+        InstructionFormat::BinaryImm64 => todo!(),
+        InstructionFormat::BinaryImm8 => todo!(),
+        InstructionFormat::Call => insert_call,
+        InstructionFormat::CallIndirect => insert_call,
+        InstructionFormat::CondTrap => todo!(),
+        InstructionFormat::DynamicStackLoad => todo!(),
+        InstructionFormat::DynamicStackStore => todo!(),
+        InstructionFormat::FloatCompare => insert_cmp,
+        InstructionFormat::FuncAddr => todo!(),
+        InstructionFormat::IntAddTrap => todo!(),
+        InstructionFormat::IntCompare => insert_cmp,
+        InstructionFormat::IntCompareImm => todo!(),
+        InstructionFormat::Load => insert_load_store,
+        InstructionFormat::LoadNoOffset => insert_load_store,
+        InstructionFormat::NullAry => insert_opcode,
+        InstructionFormat::Shuffle => todo!(),
+        InstructionFormat::StackLoad => insert_stack_load,
+        InstructionFormat::StackStore => insert_stack_store,
+        InstructionFormat::Store => insert_load_store,
+        InstructionFormat::StoreNoOffset => insert_load_store,
+        InstructionFormat::TableAddr => todo!(),
+        InstructionFormat::Ternary => insert_opcode,
+        InstructionFormat::TernaryImm8 => todo!(),
+        InstructionFormat::Trap => todo!(),
+        InstructionFormat::Unary => insert_opcode,
+        InstructionFormat::UnaryConst => insert_const,
+        InstructionFormat::UnaryGlobalValue => todo!(),
+        InstructionFormat::UnaryIeee32 => insert_const,
+        InstructionFormat::UnaryIeee64 => insert_const,
+        InstructionFormat::UnaryImm => insert_const,
+
+        InstructionFormat::BranchTable
+        | InstructionFormat::Brif
+        | InstructionFormat::Jump
+        | InstructionFormat::MultiAry => {
+            panic!("Control-flow instructions should be handled by 'insert_terminator'")
+        }
+    }
+}
+
 pub struct FunctionGenerator<'r, 'data>
 where
     'data: 'r,
@@ -1682,7 +1729,7 @@ where
     /// Fills the current block with random instructions
     fn generate_instructions(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
         for _ in 0..self.param(&self.config.instructions_per_block)? {
-            let (op, args, rets, inserter) = *self.u.choose(OPCODE_SIGNATURES)?;
+            let (op, args, rets) = *self.u.choose(OPCODE_SIGNATURES)?;
 
             // We filter out instructions that aren't supported by the target at this point instead
             // of building a single vector of valid instructions at the beginning of function
@@ -1691,6 +1738,7 @@ where
                 return Err(arbitrary::Error::IncorrectFormat.into());
             }
 
+            let inserter = inserter_for_format(op.format());
             inserter(self, builder, op, args, rets)?;
         }