wasmtime 19.0.2 → 20.0.0

data/ext/cargo-vendor/cranelift-codegen-0.106.2/src/nan_canonicalization.rs

@@ -1,106 +0,0 @@
-//! A NaN-canonicalizing rewriting pass. Patch floating point arithmetic
-//! instructions that may return a NaN result with a sequence of operations
-//! that will replace nondeterministic NaN's with a single canonical NaN value.
-
-use crate::cursor::{Cursor, FuncCursor};
-use crate::ir::condcodes::FloatCC;
-use crate::ir::immediates::{Ieee32, Ieee64};
-use crate::ir::types;
-use crate::ir::{Function, Inst, InstBuilder, InstructionData, Opcode, Value};
-use crate::opts::MemFlags;
-use crate::timing;
-
-// Canonical 32-bit and 64-bit NaN values.
-static CANON_32BIT_NAN: u32 = 0b01111111110000000000000000000000;
-static CANON_64BIT_NAN: u64 = 0b0111111111111000000000000000000000000000000000000000000000000000;
-
-/// Perform the NaN canonicalization pass.
-pub fn do_nan_canonicalization(func: &mut Function) {
-    let _tt = timing::canonicalize_nans();
-    let mut pos = FuncCursor::new(func);
-    while let Some(_block) = pos.next_block() {
-        while let Some(inst) = pos.next_inst() {
-            if is_fp_arith(&mut pos, inst) {
-                add_nan_canon_seq(&mut pos, inst);
-            }
-        }
-    }
-}
-
-/// Returns true/false based on whether the instruction is a floating-point
-/// arithmetic operation. This ignores operations like `fneg`, `fabs`, or
-/// `fcopysign` that only operate on the sign bit of a floating point value.
-fn is_fp_arith(pos: &mut FuncCursor, inst: Inst) -> bool {
-    match pos.func.dfg.insts[inst] {
-        InstructionData::Unary { opcode, .. } => {
-            opcode == Opcode::Ceil
-                || opcode == Opcode::Floor
-                || opcode == Opcode::Nearest
-                || opcode == Opcode::Sqrt
-                || opcode == Opcode::Trunc
-        }
-        InstructionData::Binary { opcode, .. } => {
-            opcode == Opcode::Fadd
-                || opcode == Opcode::Fdiv
-                || opcode == Opcode::Fmax
-                || opcode == Opcode::Fmin
-                || opcode == Opcode::Fmul
-                || opcode == Opcode::Fsub
-        }
-        InstructionData::Ternary { opcode, .. } => opcode == Opcode::Fma,
-        _ => false,
-    }
-}
-
-/// Append a sequence of canonicalizing instructions after the given instruction.
-fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst) {
-    // Select the instruction result, result type. Replace the instruction
-    // result and step forward before inserting the canonicalization sequence.
-    let val = pos.func.dfg.first_result(inst);
-    let val_type = pos.func.dfg.value_type(val);
-    let new_res = pos.func.dfg.replace_result(val, val_type);
-    let _next_inst = pos.next_inst().expect("block missing terminator!");
-
-    // Insert a comparison instruction, to check if `inst_res` is NaN. Select
-    // the canonical NaN value if `val` is NaN, assign the result to `inst`.
-    let is_nan = pos.ins().fcmp(FloatCC::NotEqual, new_res, new_res);
-
-    let scalar_select = |pos: &mut FuncCursor, canon_nan: Value| {
-        pos.ins()
-            .with_result(val)
-            .select(is_nan, canon_nan, new_res);
-    };
-    let vector_select = |pos: &mut FuncCursor, canon_nan: Value| {
-        let is_nan = pos.ins().bitcast(val_type, MemFlags::new(), is_nan);
-        pos.ins()
-            .with_result(val)
-            .bitselect(is_nan, canon_nan, new_res);
-    };
-
-    match val_type {
-        types::F32 => {
-            let canon_nan = pos.ins().f32const(Ieee32::with_bits(CANON_32BIT_NAN));
-            scalar_select(pos, canon_nan);
-        }
-        types::F64 => {
-            let canon_nan = pos.ins().f64const(Ieee64::with_bits(CANON_64BIT_NAN));
-            scalar_select(pos, canon_nan);
-        }
-        types::F32X4 => {
-            let canon_nan = pos.ins().f32const(Ieee32::with_bits(CANON_32BIT_NAN));
-            let canon_nan = pos.ins().splat(types::F32X4, canon_nan);
-            vector_select(pos, canon_nan);
-        }
-        types::F64X2 => {
-            let canon_nan = pos.ins().f64const(Ieee64::with_bits(CANON_64BIT_NAN));
-            let canon_nan = pos.ins().splat(types::F64X2, canon_nan);
-            vector_select(pos, canon_nan);
-        }
-        _ => {
-            // Panic if the type given was not an IEEE floating point type.
-            panic!("Could not canonicalize NaN: Unexpected result type found.");
-        }
-    }
-
-    pos.prev_inst(); // Step backwards so the pass does not skip instructions.
-}

data/ext/cargo-vendor/cranelift-codegen-0.106.2/src/opts/cprop.isle

@@ -1,266 +0,0 @@
-;; Constant propagation.
-
-(rule (simplify
-       (iadd (fits_in_64 ty)
-             (iconst ty (u64_from_imm64 k1))
-             (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_add k1 k2)))))
-
-(rule (simplify
-       (isub (fits_in_64 ty)
-             (iconst ty (u64_from_imm64 k1))
-             (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_sub k1 k2)))))
-
-(rule (simplify
-       (imul (fits_in_64 ty)
-             (iconst ty (u64_from_imm64 k1))
-             (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_mul k1 k2)))))
-
-(rule (simplify
-       (sdiv (fits_in_64 ty)
-             (iconst ty (u64_from_imm64 k1))
-             (iconst ty (u64_from_imm64 k2))))
-      (if-let d (u64_sdiv k1 k2))
-      (subsume (iconst ty (imm64_masked ty d))))
-
-(rule (simplify
-       (udiv (fits_in_64 ty)
-             (iconst ty (u64_from_imm64 k1))
-             (iconst ty (u64_from_imm64 k2))))
-      (if-let d (u64_udiv k1 k2))
-      (subsume (iconst ty (imm64_masked ty d))))
-
-(rule (simplify
-       (bor (fits_in_64 ty)
-            (iconst ty (u64_from_imm64 k1))
-            (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_or k1 k2)))))
-
-(rule (simplify
-       (band (fits_in_64 ty)
-            (iconst ty (u64_from_imm64 k1))
-            (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_and k1 k2)))))
-
-(rule (simplify
-       (bxor (fits_in_64 ty)
-            (iconst ty (u64_from_imm64 k1))
-            (iconst ty (u64_from_imm64 k2))))
-      (subsume (iconst ty (imm64_masked ty (u64_xor k1 k2)))))
-
-(rule (simplify
-       (bnot (fits_in_64 ty)
-            (iconst ty (u64_from_imm64 k))))
-      (subsume (iconst ty (imm64_masked ty (u64_not k)))))
-
-(rule (simplify (ishl (fits_in_64 ty)
-                      (iconst ty k1)
-                      (iconst _ k2)))
-      (subsume (iconst ty (imm64_shl ty k1 k2))))
-
-(rule (simplify (ushr (fits_in_64 ty)
-                      (iconst ty k1)
-                      (iconst _ k2)))
-      (subsume (iconst ty (imm64_ushr ty k1 k2))))
-
-(rule (simplify (sshr (fits_in_64 ty)
-                      (iconst ty k1)
-                      (iconst _ k2)))
-      (subsume (iconst ty (imm64_sshr ty k1 k2))))
-
-(rule (simplify (ireduce narrow (iconst (fits_in_64 _) (u64_from_imm64 imm))))
-      (subsume (iconst narrow (imm64_masked narrow imm))))
-
-;; iconst_[su] support $I128, but do so by extending, so restricting to
-;; 64-bit or smaller keeps it from just remaking essentially the same thing.
-(rule (simplify (uextend (fits_in_64 wide) (iconst_u narrow k)))
-      (subsume (iconst_u wide k)))
-(rule (simplify (sextend (fits_in_64 wide) (iconst_s narrow k)))
-      (subsume (iconst_s wide k)))
-
-(rule (simplify
-       (icmp result_ty
-            cc
-            (iconst ty k1)
-            (iconst ty k2)))
-      (subsume (iconst result_ty (imm64_icmp ty cc k1 k2))))
-
-
-;; Canonicalize via commutativity: push immediates to the right.
-;;
-;;   (op k x) --> (op x k)
-
-(rule (simplify
-       (iadd ty k @ (iconst ty _) x))
-      (iadd ty x k))
-;; sub is not commutative, but we can flip the args and negate the
-;; whole thing.
-(rule (simplify
-       (isub ty k @ (iconst ty _) x))
-      (ineg ty (isub ty x k)))
-(rule (simplify
-       (imul ty k @ (iconst ty _) x))
-      (imul ty x k))
-
-(rule (simplify
-       (bor ty k @ (iconst ty _) x))
-      (bor ty x k))
-(rule (simplify
-       (band ty k @ (iconst ty _) x))
-      (band ty x k))
-(rule (simplify
-       (bxor ty k @ (iconst ty _) x))
-      (bxor ty x k))
-
-(rule (simplify
-       (icmp ty cc k @ (iconst _ _) x))
-      (icmp ty (intcc_swap_args cc) x k))
-
-;; Canonicalize via associativity: reassociate to a right-heavy tree
-;; for constants.
-;;
-;;   (op (op x k) k) --> (op x (op k k))
-
-(rule (simplify
-       (iadd ty (iadd ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
-      (iadd ty x (iadd ty k1 k2)))
-;; sub is not directly associative, but we can flip a sub to an add to
-;; make it work:
-;; - (sub (sub x k1) k2) -> (sub x (add k1 k2))
-;; - (sub (sub k1 x) k2) -> (sub (sub k1 k2) x)
-;; - (sub (add x k1) k2) -> (sub x (sub k2 k1))
-;; - (add (sub x k1) k2) -> (add x (sub k2 k1))
-;; - (add (sub k1 x) k2) -> (sub (add k1 k2) x)
-(rule (simplify (isub ty
-                      (isub ty x (iconst ty (u64_from_imm64 k1)))
-                      (iconst ty (u64_from_imm64 k2))))
-      (isub ty x (iconst ty (imm64_masked ty (u64_add k1 k2)))))
-(rule (simplify (isub ty
-                      (isub ty (iconst ty (u64_from_imm64 k1)) x)
-                      (iconst ty (u64_from_imm64 k2))))
-      (isub ty (iconst ty (imm64_masked ty (u64_sub k1 k2))) x))
-(rule (simplify (isub ty
-                      (iadd ty x (iconst ty (u64_from_imm64 k1)))
-                      (iconst ty (u64_from_imm64 k2))))
-      (isub ty x (iconst ty (imm64_masked ty (u64_sub k2 k1)))))
-(rule (simplify (iadd ty
-                      (isub ty x (iconst ty (u64_from_imm64 k1)))
-                      (iconst ty (u64_from_imm64 k2))))
-      (iadd ty x (iconst ty (imm64_masked ty (u64_sub k2 k1)))))
-(rule (simplify (iadd ty
-                      (isub ty (iconst ty (u64_from_imm64 k1)) x)
-                      (iconst ty (u64_from_imm64 k2))))
-      (isub ty (iconst ty (imm64_masked ty (u64_add k1 k2))) x))
-
-(rule (simplify
-       (imul ty (imul ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
-      (imul ty x (imul ty k1 k2)))
-(rule (simplify
-       (bor ty (bor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
-      (bor ty x (bor ty k1 k2)))
-(rule (simplify
-       (band ty (band ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
-      (band ty x (band ty k1 k2)))
-(rule (simplify
-       (bxor ty (bxor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
-      (bxor ty x (bxor ty k1 k2)))
-
-(rule (simplify (select ty (iconst_u _ (u64_nonzero _)) x _))
-      (subsume x))
-(rule (simplify (select ty (iconst_u _ 0) _ y))
-      (subsume y))
-
-;; Replace subtraction by a "negative" constant with addition.
-;; Notably, this gives `x - (-1) == x + 1`, so other patterns don't have to
-;; match the subtract-negative-one version too.
-;; TODO: it would be nice to do this for `x + (-1) == x - 1` as well, but
-;; that needs work in lowering first to avoid regressing addressing modes.
-
-(rule (simplify (isub ty x (iconst_s ty k)))
-      (if-let $true (u64_lt (i64_as_u64 (i64_neg k)) (i64_as_u64 k)))
-      (iadd ty x (iconst ty (imm64_masked ty (i64_as_u64 (i64_neg k))))))
-
-;; TODO: fadd, fsub, fmul, fdiv, fneg, fabs
-
-;; A splat of a constant can become a direct `vconst` with the appropriate bit
-;; pattern.
-(rule (simplify (splat dst (iconst $I8 n)))
-      (vconst dst (splat8 (u64_uextend_imm64 $I8 n))))
-(rule (simplify (splat dst (iconst $I16 n)))
-      (vconst dst (splat16 (u64_uextend_imm64 $I16 n))))
-(rule (simplify (splat dst (iconst $I32 n)))
-      (vconst dst (splat32 (u64_uextend_imm64 $I32 n))))
-(rule (simplify (splat dst (iconst $I64 n)))
-      (vconst dst (splat64 (u64_uextend_imm64 $I64 n))))
-(rule (simplify (splat dst (f32const _ (u32_from_ieee32 n))))
-      (vconst dst (splat32 n)))
-(rule (simplify (splat dst (f64const _ (u64_from_ieee64 n))))
-      (vconst dst (splat64 n)))
-
-(decl splat8 (u64) Constant)
-(rule (splat8 n) (splat16 (u64_or n (u64_shl n 8))))
-(decl splat16 (u64) Constant)
-(rule (splat16 n) (splat32 (u64_or n (u64_shl n 16))))
-(decl splat32 (u64) Constant)
-(rule (splat32 n) (splat64 (u64_or n (u64_shl n 32))))
-(decl splat64 (u64) Constant)
-(extern constructor splat64 splat64)
-
-;; Reassociate nested shifts of constants to put constants together for cprop.
-;;
-;; ((A shift b) shift C) ==> ((A shift C) shift b)
-(rule (simplify (ishl ty (ishl ty a@(iconst _ _) b) c@(iconst _ _)))
-      (ishl ty (ishl ty a c) b))
-(rule (simplify (ushr ty (ushr ty a@(iconst _ _) b) c@(iconst _ _)))
-      (ushr ty (ushr ty a c) b))
-(rule (simplify (sshr ty (sshr ty a@(iconst _ _) b) c@(iconst _ _)))
-      (sshr ty (sshr ty a c) b))
-
-;; When we operations that are both commutative and associative, reassociate
-;; constants together for cprop:
-;;
-;; ((a op B) op (c op D)) ==> ((a op c) op (B op D))
-;;
-;; Where `op` is one of: `iadd`, `imul`, `band`, `bor`, or `bxor`.
-(rule (simplify (iadd ty
-                      (iadd ty a b@(iconst _ _))
-                      (iadd ty c d@(iconst _ _))))
-      (iadd ty (iadd ty a c) (iadd ty b d)))
-(rule (simplify (imul ty
-                      (imul ty a b@(iconst _ _))
-                      (imul ty c d@(iconst _ _))))
-      (imul ty (imul ty a c) (imul ty b d)))
-(rule (simplify (band ty
-                      (band ty a b@(iconst _ _))
-                      (band ty c d@(iconst _ _))))
-      (band ty (band ty a c) (band ty b d)))
-(rule (simplify (bor ty
-                      (bor ty a b@(iconst _ _))
-                      (bor ty c d@(iconst _ _))))
-      (bor ty (bor ty a c) (bor ty b d)))
-(rule (simplify (bxor ty
-                      (bxor ty a b@(iconst _ _))
-                      (bxor ty c d@(iconst _ _))))
-      (bxor ty (bxor ty a c) (bxor ty b d)))
-
-
-;; Constant fold int-to-float conversions.
-(rule (simplify (fcvt_from_uint $F32 (iconst_u _ n)))
-      (f32const $F32 (f32_from_uint n)))
-(rule (simplify (fcvt_from_uint $F64 (iconst_u _ n)))
-      (f64const $F64 (f64_from_uint n)))
-(rule (simplify (fcvt_from_sint $F32 (iconst_s _ n)))
-      (f32const $F32 (f32_from_sint n)))
-(rule (simplify (fcvt_from_sint $F64 (iconst_s _ n)))
-      (f64const $F64 (f64_from_sint n)))
-
-(decl f32_from_uint (u64) Ieee32)
-(extern constructor f32_from_uint f32_from_uint)
-(decl f64_from_uint (u64) Ieee64)
-(extern constructor f64_from_uint f64_from_uint)
-(decl f32_from_sint (i64) Ieee32)
-(extern constructor f32_from_sint f32_from_sint)
-(decl f64_from_sint (i64) Ieee64)
-(extern constructor f64_from_sint f64_from_sint)

data/ext/cargo-vendor/cranelift-codegen-0.106.2/src/opts.rs

@@ -1,284 +0,0 @@
-//! Optimization driver using ISLE rewrite rules on an egraph.
-
-use crate::egraph::{NewOrExistingInst, OptimizeCtx};
-pub use crate::ir::condcodes::{FloatCC, IntCC};
-use crate::ir::dfg::ValueDef;
-pub use crate::ir::immediates::{Ieee32, Ieee64, Imm64, Offset32, Uimm8, V128Imm};
-use crate::ir::instructions::InstructionFormat;
-pub use crate::ir::types::*;
-pub use crate::ir::{
-    AtomicRmwOp, BlockCall, Constant, DynamicStackSlot, FuncRef, GlobalValue, Immediate,
-    InstructionData, MemFlags, Opcode, StackSlot, Table, TrapCode, Type, Value,
-};
-use crate::isle_common_prelude_methods;
-use crate::machinst::isle::*;
-use crate::trace;
-use cranelift_entity::packed_option::ReservedValue;
-use smallvec::{smallvec, SmallVec};
-use std::marker::PhantomData;
-
-#[allow(dead_code)]
-pub type Unit = ();
-pub type Range = (usize, usize);
-pub type ValueArray2 = [Value; 2];
-pub type ValueArray3 = [Value; 3];
-
-const MAX_ISLE_RETURNS: usize = 8;
-
-pub type ConstructorVec<T> = SmallVec<[T; MAX_ISLE_RETURNS]>;
-
-type TypeAndInstructionData = (Type, InstructionData);
-
-impl<T: smallvec::Array> generated_code::Length for SmallVec<T> {
-    #[inline]
-    fn len(&self) -> usize {
-        SmallVec::len(self)
-    }
-}
-
-pub(crate) mod generated_code;
-use generated_code::{ContextIter, IntoContextIter};
-
-pub(crate) struct IsleContext<'a, 'b, 'c> {
-    pub(crate) ctx: &'a mut OptimizeCtx<'b, 'c>,
-}
-
-pub(crate) struct InstDataEtorIter<'a, 'b, 'c> {
-    stack: SmallVec<[Value; 8]>,
-    _phantom1: PhantomData<&'a ()>,
-    _phantom2: PhantomData<&'b ()>,
-    _phantom3: PhantomData<&'c ()>,
-}
-
-impl Default for InstDataEtorIter<'_, '_, '_> {
-    fn default() -> Self {
-        InstDataEtorIter {
-            stack: SmallVec::default(),
-            _phantom1: PhantomData,
-            _phantom2: PhantomData,
-            _phantom3: PhantomData,
-        }
-    }
-}
-
-impl<'a, 'b, 'c> InstDataEtorIter<'a, 'b, 'c> {
-    fn new(root: Value) -> Self {
-        debug_assert_ne!(root, Value::reserved_value());
-        Self {
-            stack: smallvec![root],
-            _phantom1: PhantomData,
-            _phantom2: PhantomData,
-            _phantom3: PhantomData,
-        }
-    }
-}
-
-impl<'a, 'b, 'c> ContextIter for InstDataEtorIter<'a, 'b, 'c>
-where
-    'b: 'a,
-    'c: 'b,
-{
-    type Context = IsleContext<'a, 'b, 'c>;
-    type Output = (Type, InstructionData);
-
-    fn next(&mut self, ctx: &mut IsleContext<'a, 'b, 'c>) -> Option<Self::Output> {
-        while let Some(value) = self.stack.pop() {
-            debug_assert_ne!(value, Value::reserved_value());
-            let value = ctx.ctx.func.dfg.resolve_aliases(value);
-            trace!("iter: value {:?}", value);
-            match ctx.ctx.func.dfg.value_def(value) {
-                ValueDef::Union(x, y) => {
-                    debug_assert_ne!(x, Value::reserved_value());
-                    debug_assert_ne!(y, Value::reserved_value());
-                    trace!(" -> {}, {}", x, y);
-                    self.stack.push(x);
-                    self.stack.push(y);
-                    continue;
-                }
-                ValueDef::Result(inst, _) if ctx.ctx.func.dfg.inst_results(inst).len() == 1 => {
-                    let ty = ctx.ctx.func.dfg.value_type(value);
-                    trace!(" -> value of type {}", ty);
-                    return Some((ty, ctx.ctx.func.dfg.insts[inst].clone()));
-                }
-                _ => {}
-            }
-        }
-        None
-    }
-}
-
-impl<'a, 'b, 'c> IntoContextIter for InstDataEtorIter<'a, 'b, 'c>
-where
-    'b: 'a,
-    'c: 'b,
-{
-    type Context = IsleContext<'a, 'b, 'c>;
-    type Output = (Type, InstructionData);
-    type IntoIter = Self;
-
-    fn into_context_iter(self) -> Self {
-        self
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct MaybeUnaryEtorIter<'a, 'b, 'c> {
-    opcode: Option<Opcode>,
-    inner: InstDataEtorIter<'a, 'b, 'c>,
-    fallback: Option<Value>,
-}
-
-impl MaybeUnaryEtorIter<'_, '_, '_> {
-    fn new(opcode: Opcode, value: Value) -> Self {
-        debug_assert_eq!(opcode.format(), InstructionFormat::Unary);
-        Self {
-            opcode: Some(opcode),
-            inner: InstDataEtorIter::new(value),
-            fallback: Some(value),
-        }
-    }
-}
-
-impl<'a, 'b, 'c> ContextIter for MaybeUnaryEtorIter<'a, 'b, 'c>
-where
-    'b: 'a,
-    'c: 'b,
-{
-    type Context = IsleContext<'a, 'b, 'c>;
-    type Output = (Type, Value);
-
-    fn next(&mut self, ctx: &mut IsleContext<'a, 'b, 'c>) -> Option<Self::Output> {
-        debug_assert_ne!(self.opcode, None);
-        while let Some((ty, inst_def)) = self.inner.next(ctx) {
-            let InstructionData::Unary { opcode, arg } = inst_def else {
-                continue;
-            };
-            if Some(opcode) == self.opcode {
-                self.fallback = None;
-                return Some((ty, arg));
-            }
-        }
-
-        self.fallback.take().map(|value| {
-            let ty = generated_code::Context::value_type(ctx, value);
-            (ty, value)
-        })
-    }
-}
-
-impl<'a, 'b, 'c> IntoContextIter for MaybeUnaryEtorIter<'a, 'b, 'c>
-where
-    'b: 'a,
-    'c: 'b,
-{
-    type Context = IsleContext<'a, 'b, 'c>;
-    type Output = (Type, Value);
-    type IntoIter = Self;
-
-    fn into_context_iter(self) -> Self {
-        self
-    }
-}
-
-impl<'a, 'b, 'c> generated_code::Context for IsleContext<'a, 'b, 'c> {
-    isle_common_prelude_methods!();
-
-    type inst_data_etor_returns = InstDataEtorIter<'a, 'b, 'c>;
-
-    fn inst_data_etor(&mut self, eclass: Value, returns: &mut InstDataEtorIter<'a, 'b, 'c>) {
-        *returns = InstDataEtorIter::new(eclass);
-    }
-
-    type inst_data_tupled_etor_returns = InstDataEtorIter<'a, 'b, 'c>;
-
-    fn inst_data_tupled_etor(&mut self, eclass: Value, returns: &mut InstDataEtorIter<'a, 'b, 'c>) {
-        // Literally identical to `inst_data_etor`, just a different nominal type in ISLE
-        self.inst_data_etor(eclass, returns);
-    }
-
-    fn make_inst_ctor(&mut self, ty: Type, op: &InstructionData) -> Value {
-        let value = self
-            .ctx
-            .insert_pure_enode(NewOrExistingInst::New(op.clone(), ty));
-        trace!("make_inst_ctor: {:?} -> {}", op, value);
-        value
-    }
-
-    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2 {
-        [arg0, arg1]
-    }
-
-    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3 {
-        [arg0, arg1, arg2]
-    }
-
-    #[inline]
-    fn value_type(&mut self, val: Value) -> Type {
-        self.ctx.func.dfg.value_type(val)
-    }
-
-    fn iconst_sextend_etor(
-        &mut self,
-        (ty, inst_data): (Type, InstructionData),
-    ) -> Option<(Type, i64)> {
-        if let InstructionData::UnaryImm {
-            opcode: Opcode::Iconst,
-            imm,
-        } = inst_data
-        {
-            Some((ty, self.i64_sextend_imm64(ty, imm)))
-        } else {
-            None
-        }
-    }
-
-    fn remat(&mut self, value: Value) -> Value {
-        trace!("remat: {}", value);
-        self.ctx.remat_values.insert(value);
-        self.ctx.stats.remat += 1;
-        value
-    }
-
-    fn subsume(&mut self, value: Value) -> Value {
-        trace!("subsume: {}", value);
-        self.ctx.subsume_values.insert(value);
-        self.ctx.stats.subsume += 1;
-        value
-    }
-
-    fn splat64(&mut self, val: u64) -> Constant {
-        let val = u128::from(val);
-        let val = val | (val << 64);
-        let imm = V128Imm(val.to_le_bytes());
-        self.ctx.func.dfg.constants.insert(imm.into())
-    }
-
-    type sextend_maybe_etor_returns = MaybeUnaryEtorIter<'a, 'b, 'c>;
-    fn sextend_maybe_etor(&mut self, value: Value, returns: &mut Self::sextend_maybe_etor_returns) {
-        *returns = MaybeUnaryEtorIter::new(Opcode::Sextend, value);
-    }
-
-    type uextend_maybe_etor_returns = MaybeUnaryEtorIter<'a, 'b, 'c>;
-    fn uextend_maybe_etor(&mut self, value: Value, returns: &mut Self::uextend_maybe_etor_returns) {
-        *returns = MaybeUnaryEtorIter::new(Opcode::Uextend, value);
-    }
-
-    // NB: Cranelift's defined semantics for `fcvt_from_{s,u}int` match Rust's
-    // own semantics for converting an integer to a float, so these are all
-    // implemented with `as` conversions in Rust.
-    fn f32_from_uint(&mut self, n: u64) -> Ieee32 {
-        Ieee32::with_float(n as f32)
-    }
-
-    fn f64_from_uint(&mut self, n: u64) -> Ieee64 {
-        Ieee64::with_float(n as f64)
-    }
-
-    fn f32_from_sint(&mut self, n: i64) -> Ieee32 {
-        Ieee32::with_float(n as f32)
-    }
-
-    fn f64_from_sint(&mut self, n: i64) -> Ieee64 {
-        Ieee64::with_float(n as f64)
-    }
-}