T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
d72010b749f296bb3bd4e707cd3027c3b156417a
wasmtime/cranelift/fuzzgen/src/function_generator.rs
Trevor Elliott d72010b749 Validate the OPCODE_SIGNATURES table (#6047) 
* Add a program for checking the function_generator opcode signatures

* Rework as a test in function_generator instead

* Fix some invalid opcode signatures in the function generator

* Fix bnot exclusions
2023-03-18 18:27:35 +00:00

2531 lines
96 KiB
Rust
Raw Blame History

use crate::config::Config;
use crate::cranelift_arbitrary::CraneliftArbitrary;
use anyhow::Result;
use arbitrary::{Arbitrary, Unstructured};
use cranelift::codegen::data_value::DataValue;
use cranelift::codegen::ir::immediates::Offset32;
use cranelift::codegen::ir::instructions::InstructionFormat;
use cranelift::codegen::ir::stackslot::StackSize;
use cranelift::codegen::ir::{
types::*, AtomicRmwOp, Block, ConstantData, ExternalName, FuncRef, Function, LibCall, Opcode,
Signature, StackSlot, Type, UserExternalName, UserFuncName, Value,
};
use cranelift::codegen::isa::CallConv;
use cranelift::frontend::{FunctionBuilder, FunctionBuilderContext, Switch, Variable};
use cranelift::prelude::{
EntityRef, ExtFuncData, FloatCC, InstBuilder, IntCC, JumpTableData, MemFlags, StackSlotData,
StackSlotKind,
};
use std::collections::HashMap;
use std::ops::RangeInclusive;
use target_lexicon::{Architecture, Triple};
type BlockSignature = Vec<Type>;
fn insert_opcode(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let mut vals = Vec::with_capacity(args.len());
for &arg in args.into_iter() {
let var = fgen.get_variable_of_type(arg)?;
let val = builder.use_var(var);
vals.push(val);
}
// Some opcodes require us to look at their input arguments to determine the
// controlling type. This is not the general case, but we can neatly check this
// using `requires_typevar_operand`.
let ctrl_type = if opcode.constraints().requires_typevar_operand() {
args.first()
} else {
rets.first()
}
.copied()
.unwrap_or(INVALID);
// Choose the appropriate instruction format for this opcode
let (inst, dfg) = match opcode.format() {
InstructionFormat::NullAry => builder.ins().NullAry(opcode, ctrl_type),
InstructionFormat::Unary => builder.ins().Unary(opcode, ctrl_type, vals[0]),
InstructionFormat::Binary => builder.ins().Binary(opcode, ctrl_type, vals[0], vals[1]),
InstructionFormat::Ternary => builder
.ins()
.Ternary(opcode, ctrl_type, vals[0], vals[1], vals[2]),
_ => unimplemented!(),
};
let results = dfg.inst_results(inst).to_vec();
for (val, &ty) in results.into_iter().zip(rets) {
let var = fgen.get_variable_of_type(ty)?;
builder.def_var(var, val);
}
Ok(())
}
fn insert_call(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
_args: &'static [Type],
_rets: &'static [Type],
) -> Result<()> {
assert_eq!(opcode, Opcode::Call, "only call handled at the moment");
let (sig, func_ref) = fgen.u.choose(&fgen.resources.func_refs)?.clone();
let actuals = fgen.generate_values_for_signature(
builder,
sig.params.iter().map(|abi_param| abi_param.value_type),
)?;
builder.ins().call(func_ref, &actuals);
Ok(())
}
fn insert_stack_load(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
_opcode: Opcode,
_args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let typevar = rets[0];
let type_size = typevar.bytes();
let (slot, slot_size) = fgen.stack_slot_with_size(type_size)?;
let offset = fgen.u.int_in_range(0..=(slot_size - type_size))? as i32;
let val = builder.ins().stack_load(typevar, slot, offset);
let var = fgen.get_variable_of_type(typevar)?;
builder.def_var(var, val);
Ok(())
}
fn insert_stack_store(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
_opcode: Opcode,
args: &'static [Type],
_rets: &'static [Type],
) -> Result<()> {
let typevar = args[0];
let type_size = typevar.bytes();
let (slot, slot_size) = fgen.stack_slot_with_size(type_size)?;
let offset = fgen.u.int_in_range(0..=(slot_size - type_size))? as i32;
let arg0 = fgen.get_variable_of_type(typevar)?;
let arg0 = builder.use_var(arg0);
builder.ins().stack_store(arg0, slot, offset);
Ok(())
}
fn insert_cmp(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let lhs = fgen.get_variable_of_type(args[0])?;
let lhs = builder.use_var(lhs);
let rhs = fgen.get_variable_of_type(args[1])?;
let rhs = builder.use_var(rhs);
let res = if opcode == Opcode::Fcmp {
let cc = *fgen.u.choose(FloatCC::all())?;
// We filter out condition codes that aren't supported by the target at
// this point after randomly choosing one, instead of randomly choosing a
// supported one, to avoid invalidating the corpus when these get implemented.
let unimplemented_cc = match (fgen.target_triple.architecture, cc) {
// Some FloatCC's are not implemented on AArch64, see:
// https://github.com/bytecodealliance/wasmtime/issues/4850
(Architecture::Aarch64(_), FloatCC::OrderedNotEqual) => true,
(Architecture::Aarch64(_), FloatCC::UnorderedOrEqual) => true,
(Architecture::Aarch64(_), FloatCC::UnorderedOrLessThan) => true,
(Architecture::Aarch64(_), FloatCC::UnorderedOrLessThanOrEqual) => true,
(Architecture::Aarch64(_), FloatCC::UnorderedOrGreaterThan) => true,
(Architecture::Aarch64(_), FloatCC::UnorderedOrGreaterThanOrEqual) => true,
// These are not implemented on x86_64, for vectors.
(Architecture::X86_64, FloatCC::UnorderedOrEqual | FloatCC::OrderedNotEqual) => {
args[0].is_vector()
}
_ => false,
};
if unimplemented_cc {
return Err(arbitrary::Error::IncorrectFormat.into());
}
builder.ins().fcmp(cc, lhs, rhs)
} else {
let cc = *fgen.u.choose(IntCC::all())?;
builder.ins().icmp(cc, lhs, rhs)
};
let var = fgen.get_variable_of_type(rets[0])?;
builder.def_var(var, res);
Ok(())
}
fn insert_const(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
_opcode: Opcode,
_args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let typevar = rets[0];
let var = fgen.get_variable_of_type(typevar)?;
let val = fgen.generate_const(builder, typevar)?;
builder.def_var(var, val);
Ok(())
}
fn insert_bitcast(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let from_var = fgen.get_variable_of_type(args[0])?;
let from_val = builder.use_var(from_var);
let to_var = fgen.get_variable_of_type(rets[0])?;
// TODO: We can generate little/big endian flags here.
let memflags = MemFlags::new();
let res = builder.ins().bitcast(rets[0], memflags, from_val);
builder.def_var(to_var, res);
Ok(())
}
fn insert_load_store(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
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();
let is_atomic = [Opcode::AtomicLoad, Opcode::AtomicStore].contains(&opcode);
let (address, flags, offset) =
fgen.generate_address_and_memflags(builder, type_size, is_atomic)?;
// The variable being loaded or stored into
let var = fgen.get_variable_of_type(ctrl_type)?;
match opcode.format() {
InstructionFormat::LoadNoOffset => {
let (inst, dfg) = builder
.ins()
.LoadNoOffset(opcode, ctrl_type, flags, address);
let new_val = dfg.first_result(inst);
builder.def_var(var, new_val);
}
InstructionFormat::StoreNoOffset => {
let val = builder.use_var(var);
builder
.ins()
.StoreNoOffset(opcode, ctrl_type, flags, val, address);
}
InstructionFormat::Store => {
let val = builder.use_var(var);
builder
.ins()
.Store(opcode, ctrl_type, flags, offset, val, address);
}
InstructionFormat::Load => {
let (inst, dfg) = builder
.ins()
.Load(opcode, ctrl_type, flags, offset, address);
let new_val = dfg.first_result(inst);
builder.def_var(var, new_val);
}
_ => unimplemented!(),
}
Ok(())
}
fn insert_atomic_rmw(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
_: Opcode,
_: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let ctrl_type = *rets.first().unwrap();
let type_size = ctrl_type.bytes();
let rmw_op = *fgen.u.choose(AtomicRmwOp::all())?;
let (address, flags, offset) = fgen.generate_address_and_memflags(builder, type_size, true)?;
// AtomicRMW does not directly support offsets, so add the offset to the address separately.
let address = builder.ins().iadd_imm(address, i64::from(offset));
// Load and store target variables
let source_var = fgen.get_variable_of_type(ctrl_type)?;
let target_var = fgen.get_variable_of_type(ctrl_type)?;
let source_val = builder.use_var(source_var);
let new_val = builder
.ins()
.atomic_rmw(ctrl_type, flags, rmw_op, address, source_val);
builder.def_var(target_var, new_val);
Ok(())
}
fn insert_atomic_cas(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
_: Opcode,
_: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let ctrl_type = *rets.first().unwrap();
let type_size = ctrl_type.bytes();
let (address, flags, offset) = fgen.generate_address_and_memflags(builder, type_size, true)?;
// AtomicCas does not directly support offsets, so add the offset to the address separately.
let address = builder.ins().iadd_imm(address, i64::from(offset));
// Source and Target variables
let expected_var = fgen.get_variable_of_type(ctrl_type)?;
let store_var = fgen.get_variable_of_type(ctrl_type)?;
let loaded_var = fgen.get_variable_of_type(ctrl_type)?;
let expected_val = builder.use_var(expected_var);
let store_val = builder.use_var(store_var);
let new_val = builder
.ins()
.atomic_cas(flags, address, expected_val, store_val);
builder.def_var(loaded_var, new_val);
Ok(())
}
fn insert_shuffle(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
_: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let ctrl_type = *rets.first().unwrap();
let lhs = builder.use_var(fgen.get_variable_of_type(ctrl_type)?);
let rhs = builder.use_var(fgen.get_variable_of_type(ctrl_type)?);
let mask = {
let mut lanes = [0u8; 16];
for lane in lanes.iter_mut() {
*lane = fgen.u.int_in_range(0..=31)?;
}
let lanes = ConstantData::from(lanes.as_ref());
builder.func.dfg.immediates.push(lanes)
};
// This function is called for any `InstructionFormat::Shuffle`. Which today is just
// `shuffle`, but lets assert that, just to be sure we don't accidentally insert
// something else.
assert_eq!(opcode, Opcode::Shuffle);
let res = builder.ins().shuffle(lhs, rhs, mask);
let target_var = fgen.get_variable_of_type(ctrl_type)?;
builder.def_var(target_var, res);
Ok(())
}
fn insert_ins_ext_lane(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
opcode: Opcode,
args: &'static [Type],
rets: &'static [Type],
) -> Result<()> {
let vector_type = *args.first().unwrap();
let ret_type = *rets.first().unwrap();
let lhs = builder.use_var(fgen.get_variable_of_type(vector_type)?);
let max_lane = (vector_type.lane_count() as u8) - 1;
let lane = fgen.u.int_in_range(0..=max_lane)?;
let res = match opcode {
Opcode::Insertlane => {
let rhs = builder.use_var(fgen.get_variable_of_type(args[1])?);
builder.ins().insertlane(lhs, rhs, lane)
}
Opcode::Extractlane => builder.ins().extractlane(lhs, lane),
_ => todo!(),
};
let target_var = fgen.get_variable_of_type(ret_type)?;
builder.def_var(target_var, res);
Ok(())
}
type OpcodeInserter = fn(
fgen: &mut FunctionGenerator,
builder: &mut FunctionBuilder,
Opcode,
&'static [Type],
&'static [Type],
) -> Result<()>;
/// Returns true if we believe this `OpcodeSignature` should compile correctly
/// for the given target triple. We currently have a range of known issues
/// with specific lowerings on specific backends, and we don't want to get
/// fuzz bug reports for those. Over time our goal is to eliminate all of these
/// exceptions.
fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -> bool {
macro_rules! exceptions {
( $(($($cases:pat),*)),* $(,)?) => {
match (op, args, rets) {
$( ($($cases,)* ..) => false, )*
_ => true,
}
}
}
match triple.architecture {
Architecture::X86_64 => {
exceptions!(
(Opcode::IaddCout, &([I8, I8] | [I16, I16] | [I128, I128])),
(Opcode::Imul, &[I8X16, I8X16]),
// https://github.com/bytecodealliance/wasmtime/issues/5468
(Opcode::Smulhi | Opcode::Umulhi, &[I8, I8]),
// https://github.com/bytecodealliance/wasmtime/issues/4756
(Opcode::Udiv | Opcode::Sdiv, &[I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/5474
(Opcode::Urem | Opcode::Srem, &[I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/5466
(Opcode::Iabs, &[I128]),
// https://github.com/bytecodealliance/wasmtime/issues/3370
(
Opcode::Smin | Opcode::Umin | Opcode::Smax | Opcode::Umax,
&[I128, I128]
),
// https://github.com/bytecodealliance/wasmtime/issues/4870
(Opcode::Bnot, &[F32 | F64]),
(
Opcode::Band
| Opcode::Bor
| Opcode::Bxor
| Opcode::BandNot
| Opcode::BorNot
| Opcode::BxorNot,
&([F32, F32] | [F64, F64])
),
// https://github.com/bytecodealliance/wasmtime/issues/5041
(
Opcode::BandNot | Opcode::BorNot | Opcode::BxorNot,
&([I8, I8] | [I16, I16] | [I32, I32] | [I64, I64] | [I128, I128])
),
// https://github.com/bytecodealliance/wasmtime/issues/5107
(Opcode::Cls, &[I8], &[I8]),
(Opcode::Cls, &[I16], &[I16]),
(Opcode::Cls, &[I32], &[I32]),
(Opcode::Cls, &[I64], &[I64]),
(Opcode::Cls, &[I128], &[I128]),
// https://github.com/bytecodealliance/wasmtime/issues/5197
(
Opcode::Bitselect,
&([I8, I8, I8]
| [I16, I16, I16]
| [I32, I32, I32]
| [I64, I64, I64]
| [I128, I128, I128])
),
// https://github.com/bytecodealliance/wasmtime/issues/4897
// https://github.com/bytecodealliance/wasmtime/issues/4899
(
Opcode::FcvtToUint
| Opcode::FcvtToUintSat
| Opcode::FcvtToSint
| Opcode::FcvtToSintSat,
&[F32 | F64],
&[I8 | I16 | I128]
),
(Opcode::FcvtToUint | Opcode::FcvtToSint, &[F32X4], &[I32X4]),
(
Opcode::FcvtToUint
| Opcode::FcvtToUintSat
| Opcode::FcvtToSint
| Opcode::FcvtToSintSat,
&[F64X2],
&[I64X2]
),
// https://github.com/bytecodealliance/wasmtime/issues/4900
(Opcode::FcvtFromUint, &[I128], &[F32 | F64]),
// This has a lowering, but only when preceded by `uwiden_low`.
(Opcode::FcvtFromUint, &[I64X2], &[F64X2]),
// https://github.com/bytecodealliance/wasmtime/issues/4900
(Opcode::FcvtFromSint, &[I128], &[F32 | F64]),
(Opcode::FcvtFromSint, &[I64X2], &[F64X2]),
(
Opcode::Umulhi | Opcode::Smulhi,
&([I8X16, I8X16] | [I16X8, I16X8] | [I32X4, I32X4] | [I64X2, I64X2])
),
(
Opcode::UaddSat | Opcode::SaddSat | Opcode::UsubSat | Opcode::SsubSat,
&([I32X4, I32X4] | [I64X2, I64X2])
),
(Opcode::Fcopysign, &([F32X4, F32X4] | [F64X2, F64X2])),
(Opcode::Popcnt, &([I8X16] | [I16X8] | [I32X4] | [I64X2])),
(
Opcode::Umax | Opcode::Smax | Opcode::Umin | Opcode::Smin,
&[I64X2, I64X2]
),
(Opcode::Bitcast, &[I128], &[_]),
(Opcode::Bitcast, &[_], &[I128]),
(Opcode::Uunarrow),
(Opcode::Snarrow | Opcode::Unarrow, &[I64X2, I64X2]),
(Opcode::SqmulRoundSat, &[I32X4, I32X4]),
// This Icmp is not implemented: #5529
(Opcode::Icmp, &[I64X2, I64X2]),
// IaddPairwise is implemented, but only for some types, and with some preceding ops.
(Opcode::IaddPairwise),
// Nothing wrong with this select. But we have an isle rule that can optimize it
// into a `min`/`max` instructions, which we don't have implemented yet.
(Opcode::Select, &[_, I128, I128]),
// These stack accesses can cause segfaults if they are merged into an SSE instruction.
// See: #5922
(
Opcode::StackStore,
&[I8X16 | I16X8 | I32X4 | I64X2 | F32X4 | F64X2]
),
(
Opcode::StackLoad,
&[],
&[I8X16 | I16X8 | I32X4 | I64X2 | F32X4 | F64X2]
),
)
}
Architecture::Aarch64(_) => {
exceptions!(
(Opcode::IaddCout, &[I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/4864
(Opcode::Udiv | Opcode::Sdiv, &[I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/5472
(Opcode::Urem | Opcode::Srem, &[I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/5467
(Opcode::Iabs, &[I128]),
// https://github.com/bytecodealliance/wasmtime/issues/4313
(
Opcode::Smin | Opcode::Umin | Opcode::Smax | Opcode::Umax,
&[I128, I128]
),
// https://github.com/bytecodealliance/wasmtime/issues/4870
(Opcode::Bnot, &[F32 | F64]),
(
Opcode::Band
| Opcode::Bor
| Opcode::Bxor
| Opcode::BandNot
| Opcode::BorNot
| Opcode::BxorNot,
&([F32, F32] | [F64, F64])
),
// https://github.com/bytecodealliance/wasmtime/issues/5198
(Opcode::Bitselect, &[I128, I128, I128]),
// https://github.com/bytecodealliance/wasmtime/issues/4934
(
Opcode::FcvtToUint
| Opcode::FcvtToUintSat
| Opcode::FcvtToSint
| Opcode::FcvtToSintSat,
&[F32 | F64]
),
// https://github.com/bytecodealliance/wasmtime/issues/4933
(
Opcode::FcvtFromUint | Opcode::FcvtFromSint,
&[I128],
&[F32 | F64]
),
(
Opcode::Umulhi | Opcode::Smulhi,
&([I8X16, I8X16] | [I16X8, I16X8] | [I32X4, I32X4] | [I64X2, I64X2])
),
(Opcode::Popcnt, &[I16X8 | I32X4 | I64X2]),
// Nothing wrong with this select. But we have an isle rule that can optimize it
// into a `min`/`max` instructions, which we don't have implemented yet.
(Opcode::Select, &[I8, I128, I128]),
)
}
Architecture::S390x => {
exceptions!(
(Opcode::IaddCout),
(
Opcode::Udiv | Opcode::Sdiv | Opcode::Urem | Opcode::Srem,
&[I128, I128]
),
(Opcode::Bnot, &[F32 | F64]),
(
Opcode::Band
| Opcode::Bor
| Opcode::Bxor
| Opcode::BandNot
| Opcode::BorNot
| Opcode::BxorNot,
&([F32, F32] | [F64, F64])
),
(
Opcode::FcvtToUint
| Opcode::FcvtToUintSat
| Opcode::FcvtToSint
| Opcode::FcvtToSintSat,
&[F32 | F64],
&[I128]
),
(
Opcode::FcvtFromUint | Opcode::FcvtFromSint,
&[I128],
&[F32 | F64]
),
(Opcode::SsubSat | Opcode::SaddSat, &[I64X2, I64X2]),
)
}
Architecture::Riscv64(_) => {
// RISC-V Does not support SIMD at all
let is_simd = args.iter().chain(rets).any(|t| t.is_vector());
if is_simd {
return false;
}
exceptions!(
// TODO
(Opcode::IaddCout),
// TODO
(
Opcode::Udiv | Opcode::Sdiv | Opcode::Urem | Opcode::Srem,
&[I128, I128]
),
// TODO
(Opcode::Iabs, &[I128]),
// TODO
(Opcode::Bitselect, &[I128, I128, I128]),
// TODO
(Opcode::Bswap),
// https://github.com/bytecodealliance/wasmtime/issues/5528
(
Opcode::FcvtToUint
| Opcode::FcvtToUintSat
| Opcode::FcvtToSint
| Opcode::FcvtToSintSat,
&[F32 | F64],
&[I8 | I16 | I128]
),
// https://github.com/bytecodealliance/wasmtime/issues/5528
(
Opcode::FcvtFromUint | Opcode::FcvtFromSint,
&[I8 | I16 | I128],
&[F32 | F64]
),
// TODO
(
Opcode::BandNot | Opcode::BorNot | Opcode::BxorNot,
&([F32, F32] | [F64, F64])
),
// https://github.com/bytecodealliance/wasmtime/issues/5884
(Opcode::AtomicRmw),
)
}
_ => true,
}
}
type OpcodeSignature = (
Opcode,
&'static [Type], // Args
&'static [Type], // Rets
);
// TODO: Derive this from the `cranelift-meta` generator.
#[rustfmt::skip]
pub const OPCODE_SIGNATURES: &[OpcodeSignature] = &[
(Opcode::Nop, &[], &[]),
// Iadd
(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]),
(Opcode::Iadd, &[I8X16, I8X16], &[I8X16]),
(Opcode::Iadd, &[I16X8, I16X8], &[I16X8]),
(Opcode::Iadd, &[I32X4, I32X4], &[I32X4]),
(Opcode::Iadd, &[I64X2, I64X2], &[I64X2]),
// IaddCout
(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]),
// UaddSat
(Opcode::UaddSat, &[I8X16, I8X16], &[I8X16]),
(Opcode::UaddSat, &[I16X8, I16X8], &[I16X8]),
(Opcode::UaddSat, &[I32X4, I32X4], &[I32X4]),
(Opcode::UaddSat, &[I64X2, I64X2], &[I64X2]),
// SaddSat
(Opcode::SaddSat, &[I8X16, I8X16], &[I8X16]),
(Opcode::SaddSat, &[I16X8, I16X8], &[I16X8]),
(Opcode::SaddSat, &[I32X4, I32X4], &[I32X4]),
(Opcode::SaddSat, &[I64X2, I64X2], &[I64X2]),
// Isub
(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]),
(Opcode::Isub, &[I8X16, I8X16], &[I8X16]),
(Opcode::Isub, &[I16X8, I16X8], &[I16X8]),
(Opcode::Isub, &[I32X4, I32X4], &[I32X4]),
(Opcode::Isub, &[I64X2, I64X2], &[I64X2]),
// UsubSat
(Opcode::UsubSat, &[I8X16, I8X16], &[I8X16]),
(Opcode::UsubSat, &[I16X8, I16X8], &[I16X8]),
(Opcode::UsubSat, &[I32X4, I32X4], &[I32X4]),
(Opcode::UsubSat, &[I64X2, I64X2], &[I64X2]),
// SsubSat
(Opcode::SsubSat, &[I8X16, I8X16], &[I8X16]),
(Opcode::SsubSat, &[I16X8, I16X8], &[I16X8]),
(Opcode::SsubSat, &[I32X4, I32X4], &[I32X4]),
(Opcode::SsubSat, &[I64X2, I64X2], &[I64X2]),
// Imul
(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]),
(Opcode::Imul, &[I8X16, I8X16], &[I8X16]),
(Opcode::Imul, &[I16X8, I16X8], &[I16X8]),
(Opcode::Imul, &[I32X4, I32X4], &[I32X4]),
(Opcode::Imul, &[I64X2, I64X2], &[I64X2]),
// Smulhi
(Opcode::Smulhi, &[I8, I8], &[I8]),
(Opcode::Smulhi, &[I16, I16], &[I16]),
(Opcode::Smulhi, &[I32, I32], &[I32]),
(Opcode::Smulhi, &[I64, I64], &[I64]),
(Opcode::Smulhi, &[I8X16, I8X16], &[I8X16]),
(Opcode::Smulhi, &[I16X8, I16X8], &[I16X8]),
(Opcode::Smulhi, &[I32X4, I32X4], &[I32X4]),
(Opcode::Smulhi, &[I64X2, I64X2], &[I64X2]),
// Umulhi
(Opcode::Umulhi, &[I8, I8], &[I8]),
(Opcode::Umulhi, &[I16, I16], &[I16]),
(Opcode::Umulhi, &[I32, I32], &[I32]),
(Opcode::Umulhi, &[I64, I64], &[I64]),
(Opcode::Umulhi, &[I8X16, I8X16], &[I8X16]),
(Opcode::Umulhi, &[I16X8, I16X8], &[I16X8]),
(Opcode::Umulhi, &[I32X4, I32X4], &[I32X4]),
(Opcode::Umulhi, &[I64X2, I64X2], &[I64X2]),
// Udiv
(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]),
(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]),
(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]),
(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]),
(Opcode::Ineg, &[I16], &[I16]),
(Opcode::Ineg, &[I32], &[I32]),
(Opcode::Ineg, &[I64], &[I64]),
(Opcode::Ineg, &[I128], &[I128]),
// Iabs
(Opcode::Iabs, &[I8], &[I8]),
(Opcode::Iabs, &[I16], &[I16]),
(Opcode::Iabs, &[I32], &[I32]),
(Opcode::Iabs, &[I64], &[I64]),
(Opcode::Iabs, &[I128], &[I128]),
(Opcode::Iabs, &[I8X16], &[I8X16]),
(Opcode::Iabs, &[I16X8], &[I16X8]),
(Opcode::Iabs, &[I32X4], &[I32X4]),
(Opcode::Iabs, &[I64X2], &[I64X2]),
// Smin
(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]),
(Opcode::Smin, &[I8X16, I8X16], &[I8X16]),
(Opcode::Smin, &[I16X8, I16X8], &[I16X8]),
(Opcode::Smin, &[I32X4, I32X4], &[I32X4]),
(Opcode::Smin, &[I64X2, I64X2], &[I64X2]),
// Umin
(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]),
(Opcode::Umin, &[I8X16, I8X16], &[I8X16]),
(Opcode::Umin, &[I16X8, I16X8], &[I16X8]),
(Opcode::Umin, &[I32X4, I32X4], &[I32X4]),
(Opcode::Umin, &[I64X2, I64X2], &[I64X2]),
// Smax
(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]),
(Opcode::Smax, &[I8X16, I8X16], &[I8X16]),
(Opcode::Smax, &[I16X8, I16X8], &[I16X8]),
(Opcode::Smax, &[I32X4, I32X4], &[I32X4]),
(Opcode::Smax, &[I64X2, I64X2], &[I64X2]),
// Umax
(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]),
(Opcode::Umax, &[I8X16, I8X16], &[I8X16]),
(Opcode::Umax, &[I16X8, I16X8], &[I16X8]),
(Opcode::Umax, &[I32X4, I32X4], &[I32X4]),
(Opcode::Umax, &[I64X2, I64X2], &[I64X2]),
// Rotr
(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]),
(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]),
(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]),
(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]),
(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]),
(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]),
(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]),
(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]),
// Iconcat
(Opcode::Iconcat, &[I64, I64], &[I128]),
// Band
(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]),
(Opcode::Band, &[I8X16, I8X16], &[I8X16]),
(Opcode::Band, &[I16X8, I16X8], &[I16X8]),
(Opcode::Band, &[I32X4, I32X4], &[I32X4]),
(Opcode::Band, &[I64X2, I64X2], &[I64X2]),
(Opcode::Band, &[F32X4, F32X4], &[F32X4]),
(Opcode::Band, &[F64X2, F64X2], &[F64X2]),
// Bor
(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]),
(Opcode::Bor, &[I8X16, I8X16], &[I8X16]),
(Opcode::Bor, &[I16X8, I16X8], &[I16X8]),
(Opcode::Bor, &[I32X4, I32X4], &[I32X4]),
(Opcode::Bor, &[I64X2, I64X2], &[I64X2]),
(Opcode::Bor, &[F32X4, F32X4], &[F32X4]),
(Opcode::Bor, &[F64X2, F64X2], &[F64X2]),
// Bxor
(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]),
(Opcode::Bxor, &[I8X16, I8X16], &[I8X16]),
(Opcode::Bxor, &[I16X8, I16X8], &[I16X8]),
(Opcode::Bxor, &[I32X4, I32X4], &[I32X4]),
(Opcode::Bxor, &[I64X2, I64X2], &[I64X2]),
(Opcode::Bxor, &[F32X4, F32X4], &[F32X4]),
(Opcode::Bxor, &[F64X2, F64X2], &[F64X2]),
// Bnot
(Opcode::Bnot, &[I8], &[I8]),
(Opcode::Bnot, &[I16], &[I16]),
(Opcode::Bnot, &[I32], &[I32]),
(Opcode::Bnot, &[I64], &[I64]),
(Opcode::Bnot, &[I128], &[I128]),
(Opcode::Bnot, &[F32], &[F32]),
(Opcode::Bnot, &[F64], &[F64]),
(Opcode::Bnot, &[I8X16], &[I8X16]),
(Opcode::Bnot, &[I16X8], &[I16X8]),
(Opcode::Bnot, &[I32X4], &[I32X4]),
(Opcode::Bnot, &[I64X2], &[I64X2]),
(Opcode::Bnot, &[F32X4], &[F32X4]),
(Opcode::Bnot, &[F64X2], &[F64X2]),
// BandNot
(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]),
(Opcode::BandNot, &[I8X16, I8X16], &[I8X16]),
(Opcode::BandNot, &[I16X8, I16X8], &[I16X8]),
(Opcode::BandNot, &[I32X4, I32X4], &[I32X4]),
(Opcode::BandNot, &[I64X2, I64X2], &[I64X2]),
(Opcode::BandNot, &[F32X4, F32X4], &[F32X4]),
(Opcode::BandNot, &[F64X2, F64X2], &[F64X2]),
// BorNot
(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]),
(Opcode::BorNot, &[I8X16, I8X16], &[I8X16]),
(Opcode::BorNot, &[I16X8, I16X8], &[I16X8]),
(Opcode::BorNot, &[I32X4, I32X4], &[I32X4]),
(Opcode::BorNot, &[I64X2, I64X2], &[I64X2]),
(Opcode::BorNot, &[F32X4, F32X4], &[F32X4]),
(Opcode::BorNot, &[F64X2, F64X2], &[F64X2]),
// BxorNot
(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]),
(Opcode::BxorNot, &[I8X16, I8X16], &[I8X16]),
(Opcode::BxorNot, &[I16X8, I16X8], &[I16X8]),
(Opcode::BxorNot, &[I32X4, I32X4], &[I32X4]),
(Opcode::BxorNot, &[I64X2, I64X2], &[I64X2]),
(Opcode::BxorNot, &[F32X4, F32X4], &[F32X4]),
(Opcode::BxorNot, &[F64X2, F64X2], &[F64X2]),
// Bitrev
(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]),
(Opcode::Clz, &[I16], &[I16]),
(Opcode::Clz, &[I32], &[I32]),
(Opcode::Clz, &[I64], &[I64]),
(Opcode::Clz, &[I128], &[I128]),
// Cls
(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]),
(Opcode::Ctz, &[I16], &[I16]),
(Opcode::Ctz, &[I32], &[I32]),
(Opcode::Ctz, &[I64], &[I64]),
(Opcode::Ctz, &[I128], &[I128]),
// Popcnt
(Opcode::Popcnt, &[I8], &[I8]),
(Opcode::Popcnt, &[I16], &[I16]),
(Opcode::Popcnt, &[I32], &[I32]),
(Opcode::Popcnt, &[I64], &[I64]),
(Opcode::Popcnt, &[I128], &[I128]),
(Opcode::Popcnt, &[I8X16], &[I8X16]),
(Opcode::Popcnt, &[I16X8], &[I16X8]),
(Opcode::Popcnt, &[I32X4], &[I32X4]),
(Opcode::Popcnt, &[I64X2], &[I64X2]),
// Bmask
(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]),
(Opcode::Bswap, &[I32], &[I32]),
(Opcode::Bswap, &[I64], &[I64]),
(Opcode::Bswap, &[I128], &[I128]),
// Bitselect
(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]),
(Opcode::Bitselect, &[I8X16, I8X16, I8X16], &[I8X16]),
(Opcode::Bitselect, &[I16X8, I16X8, I16X8], &[I16X8]),
(Opcode::Bitselect, &[I32X4, I32X4, I32X4], &[I32X4]),
(Opcode::Bitselect, &[I64X2, I64X2, I64X2], &[I64X2]),
// Select
(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]),
(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]),
(Opcode::Fadd, &[F64, F64], &[F64]),
(Opcode::Fadd, &[F32X4, F32X4], &[F32X4]),
(Opcode::Fadd, &[F64X2, F64X2], &[F64X2]),
// Fmul
(Opcode::Fmul, &[F32, F32], &[F32]),
(Opcode::Fmul, &[F64, F64], &[F64]),
(Opcode::Fmul, &[F32X4, F32X4], &[F32X4]),
(Opcode::Fmul, &[F64X2, F64X2], &[F64X2]),
// Fsub
(Opcode::Fsub, &[F32, F32], &[F32]),
(Opcode::Fsub, &[F64, F64], &[F64]),
(Opcode::Fsub, &[F32X4, F32X4], &[F32X4]),
(Opcode::Fsub, &[F64X2, F64X2], &[F64X2]),
// Fdiv
(Opcode::Fdiv, &[F32, F32], &[F32]),
(Opcode::Fdiv, &[F64, F64], &[F64]),
(Opcode::Fdiv, &[F32X4, F32X4], &[F32X4]),
(Opcode::Fdiv, &[F64X2, F64X2], &[F64X2]),
// Fmin
(Opcode::Fmin, &[F32, F32], &[F32]),
(Opcode::Fmin, &[F64, F64], &[F64]),
// Fmax
(Opcode::Fmax, &[F32, F32], &[F32]),
(Opcode::Fmax, &[F64, F64], &[F64]),
// FminPseudo
(Opcode::FminPseudo, &[F32, F32], &[F32]),
(Opcode::FminPseudo, &[F64, F64], &[F64]),
// FmaxPseudo
(Opcode::FmaxPseudo, &[F32, F32], &[F32]),
(Opcode::FmaxPseudo, &[F64, F64], &[F64]),
// Fcopysign
(Opcode::Fcopysign, &[F32, F32], &[F32]),
(Opcode::Fcopysign, &[F64, F64], &[F64]),
(Opcode::Fcopysign, &[F32X4, F32X4], &[F32X4]),
(Opcode::Fcopysign, &[F64X2, F64X2], &[F64X2]),
// Fma
(Opcode::Fma, &[F32, F32, F32], &[F32]),
(Opcode::Fma, &[F64, F64, F64], &[F64]),
(Opcode::Fma, &[F32X4, F32X4, F32X4], &[F32X4]),
(Opcode::Fma, &[F64X2, F64X2, F64X2], &[F64X2]),
// Fabs
(Opcode::Fabs, &[F32], &[F32]),
(Opcode::Fabs, &[F64], &[F64]),
(Opcode::Fabs, &[F32X4], &[F32X4]),
(Opcode::Fabs, &[F64X2], &[F64X2]),
// Fneg
(Opcode::Fneg, &[F32], &[F32]),
(Opcode::Fneg, &[F64], &[F64]),
(Opcode::Fneg, &[F32X4], &[F32X4]),
(Opcode::Fneg, &[F64X2], &[F64X2]),
// Sqrt
(Opcode::Sqrt, &[F32], &[F32]),
(Opcode::Sqrt, &[F64], &[F64]),
(Opcode::Sqrt, &[F32X4], &[F32X4]),
(Opcode::Sqrt, &[F64X2], &[F64X2]),
// Ceil
(Opcode::Ceil, &[F32], &[F32]),
(Opcode::Ceil, &[F64], &[F64]),
(Opcode::Ceil, &[F32X4], &[F32X4]),
(Opcode::Ceil, &[F64X2], &[F64X2]),
// Floor
(Opcode::Floor, &[F32], &[F32]),
(Opcode::Floor, &[F64], &[F64]),
(Opcode::Floor, &[F32X4], &[F32X4]),
(Opcode::Floor, &[F64X2], &[F64X2]),
// Trunc
(Opcode::Trunc, &[F32], &[F32]),
(Opcode::Trunc, &[F64], &[F64]),
(Opcode::Trunc, &[F32X4], &[F32X4]),
(Opcode::Trunc, &[F64X2], &[F64X2]),
// Nearest
(Opcode::Nearest, &[F32], &[F32]),
(Opcode::Nearest, &[F64], &[F64]),
(Opcode::Nearest, &[F32X4], &[F32X4]),
(Opcode::Nearest, &[F64X2], &[F64X2]),
// Fpromote
(Opcode::Fpromote, &[F32], &[F64]),
// Fdemote
(Opcode::Fdemote, &[F64], &[F32]),
// FcvtToUint
(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]),
(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]),
(Opcode::FcvtToUintSat, &[F32X4], &[I32X4]),
(Opcode::FcvtToUintSat, &[F64X2], &[I64X2]),
// FcvtToSint
(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]),
(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]),
(Opcode::FcvtToSintSat, &[F32X4], &[I32X4]),
(Opcode::FcvtToSintSat, &[F64X2], &[I64X2]),
// FcvtFromUint
(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]),
(Opcode::FcvtFromUint, &[I32X4], &[F32X4]),
(Opcode::FcvtFromUint, &[I64X2], &[F64X2]),
// FcvtFromSint
(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]),
(Opcode::FcvtFromSint, &[I32X4], &[F32X4]),
(Opcode::FcvtFromSint, &[I64X2], &[F64X2]),
// FcvtLowFromSint
(Opcode::FcvtLowFromSint, &[I32X4], &[F64X2]),
// FvpromoteLow
(Opcode::FvpromoteLow, &[F32X4], &[F64X2]),
// Fvdemote
(Opcode::Fvdemote, &[F64X2], &[F32X4]),
// Fcmp
(Opcode::Fcmp, &[F32, F32], &[I8]),
(Opcode::Fcmp, &[F64, F64], &[I8]),
(Opcode::Fcmp, &[F32X4, F32X4], &[I32X4]),
(Opcode::Fcmp, &[F64X2, F64X2], &[I64X2]),
// Icmp
(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]),
(Opcode::Icmp, &[I8X16, I8X16], &[I8X16]),
(Opcode::Icmp, &[I16X8, I16X8], &[I16X8]),
(Opcode::Icmp, &[I32X4, I32X4], &[I32X4]),
(Opcode::Icmp, &[I64X2, I64X2], &[I64X2]),
// Fence
(Opcode::Fence, &[], &[]),
// Stack Access
(Opcode::StackStore, &[I8], &[]),
(Opcode::StackStore, &[I16], &[]),
(Opcode::StackStore, &[I32], &[]),
(Opcode::StackStore, &[I64], &[]),
(Opcode::StackStore, &[I128], &[]),
(Opcode::StackStore, &[F32], &[]),
(Opcode::StackStore, &[F64], &[]),
(Opcode::StackStore, &[I8X16], &[]),
(Opcode::StackStore, &[I16X8], &[]),
(Opcode::StackStore, &[I32X4], &[]),
(Opcode::StackStore, &[I64X2], &[]),
(Opcode::StackStore, &[F32X4], &[]),
(Opcode::StackStore, &[F64X2], &[]),
(Opcode::StackLoad, &[], &[I8]),
(Opcode::StackLoad, &[], &[I16]),
(Opcode::StackLoad, &[], &[I32]),
(Opcode::StackLoad, &[], &[I64]),
(Opcode::StackLoad, &[], &[I128]),
(Opcode::StackLoad, &[], &[F32]),
(Opcode::StackLoad, &[], &[F64]),
(Opcode::StackLoad, &[], &[I8X16]),
(Opcode::StackLoad, &[], &[I16X8]),
(Opcode::StackLoad, &[], &[I32X4]),
(Opcode::StackLoad, &[], &[I64X2]),
(Opcode::StackLoad, &[], &[F32X4]),
(Opcode::StackLoad, &[], &[F64X2]),
// Loads
(Opcode::Load, &[], &[I8]),
(Opcode::Load, &[], &[I16]),
(Opcode::Load, &[], &[I32]),
(Opcode::Load, &[], &[I64]),
(Opcode::Load, &[], &[I128]),
(Opcode::Load, &[], &[F32]),
(Opcode::Load, &[], &[F64]),
(Opcode::Load, &[], &[I8X16]),
(Opcode::Load, &[], &[I16X8]),
(Opcode::Load, &[], &[I32X4]),
(Opcode::Load, &[], &[I64X2]),
(Opcode::Load, &[], &[F32X4]),
(Opcode::Load, &[], &[F64X2]),
// Special Loads
(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
// Opcode::Uload16x4
// Opcode::Sload16x4
// Opcode::Uload32x2
// Opcode::Sload32x2
// AtomicLoad
(Opcode::AtomicLoad, &[], &[I8]),
(Opcode::AtomicLoad, &[], &[I16]),
(Opcode::AtomicLoad, &[], &[I32]),
(Opcode::AtomicLoad, &[], &[I64]),
// Stores
(Opcode::Store, &[I8], &[]),
(Opcode::Store, &[I16], &[]),
(Opcode::Store, &[I32], &[]),
(Opcode::Store, &[I64], &[]),
(Opcode::Store, &[I128], &[]),
(Opcode::Store, &[F32], &[]),
(Opcode::Store, &[F64], &[]),
(Opcode::Store, &[I8X16], &[]),
(Opcode::Store, &[I16X8], &[]),
(Opcode::Store, &[I32X4], &[]),
(Opcode::Store, &[I64X2], &[]),
(Opcode::Store, &[F32X4], &[]),
(Opcode::Store, &[F64X2], &[]),
// Special Stores
(Opcode::Istore8, &[I16], &[]),
(Opcode::Istore8, &[I32], &[]),
(Opcode::Istore8, &[I64], &[]),
(Opcode::Istore16, &[I32], &[]),
(Opcode::Istore16, &[I64], &[]),
(Opcode::Istore32, &[I64], &[]),
// AtomicStore
(Opcode::AtomicStore, &[I8], &[]),
(Opcode::AtomicStore, &[I16], &[]),
(Opcode::AtomicStore, &[I32], &[]),
(Opcode::AtomicStore, &[I64], &[]),
// AtomicRMW
(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]),
(Opcode::AtomicCas, &[I16, I16], &[I16]),
(Opcode::AtomicCas, &[I32, I32], &[I32]),
(Opcode::AtomicCas, &[I64, I64], &[I64]),
// Bitcast
(Opcode::Bitcast, &[F32], &[I32]),
(Opcode::Bitcast, &[I32], &[F32]),
(Opcode::Bitcast, &[F64], &[I64]),
(Opcode::Bitcast, &[I64], &[F64]),
// Shuffle
(Opcode::Shuffle, &[I8X16, I8X16], &[I8X16]),
// Swizzle
(Opcode::Swizzle, &[I8X16, I8X16], &[I8X16]),
// Splat
(Opcode::Splat, &[I8], &[I8X16]),
(Opcode::Splat, &[I16], &[I16X8]),
(Opcode::Splat, &[I32], &[I32X4]),
(Opcode::Splat, &[I64], &[I64X2]),
(Opcode::Splat, &[F32], &[F32X4]),
(Opcode::Splat, &[F64], &[F64X2]),
// Insert Lane
(Opcode::Insertlane, &[I8X16, I8], &[I8X16]),
(Opcode::Insertlane, &[I16X8, I16], &[I16X8]),
(Opcode::Insertlane, &[I32X4, I32], &[I32X4]),
(Opcode::Insertlane, &[I64X2, I64], &[I64X2]),
(Opcode::Insertlane, &[F32X4, F32], &[F32X4]),
(Opcode::Insertlane, &[F64X2, F64], &[F64X2]),
// Extract Lane
(Opcode::Extractlane, &[I8X16], &[I8]),
(Opcode::Extractlane, &[I16X8], &[I16]),
(Opcode::Extractlane, &[I32X4], &[I32]),
(Opcode::Extractlane, &[I64X2], &[I64]),
(Opcode::Extractlane, &[F32X4], &[F32]),
(Opcode::Extractlane, &[F64X2], &[F64]),
// Snarrow
(Opcode::Snarrow, &[I64X2, I64X2], &[I32X4]),
(Opcode::Snarrow, &[I32X4, I32X4], &[I16X8]),
(Opcode::Snarrow, &[I16X8, I16X8], &[I8X16]),
// Unarrow
(Opcode::Unarrow, &[I64X2, I64X2], &[I32X4]),
(Opcode::Unarrow, &[I32X4, I32X4], &[I16X8]),
(Opcode::Unarrow, &[I16X8, I16X8], &[I8X16]),
// Uunarrow
(Opcode::Uunarrow, &[I64X2, I64X2], &[I32X4]),
(Opcode::Uunarrow, &[I32X4, I32X4], &[I16X8]),
(Opcode::Uunarrow, &[I16X8, I16X8], &[I8X16]),
// VhighBits
(Opcode::VhighBits, &[I8X16], &[I8]),
(Opcode::VhighBits, &[I16X8], &[I8]),
(Opcode::VhighBits, &[I32X4], &[I8]),
(Opcode::VhighBits, &[I64X2], &[I8]),
// VanyTrue
(Opcode::VanyTrue, &[I8X16], &[I8]),
(Opcode::VanyTrue, &[I16X8], &[I8]),
(Opcode::VanyTrue, &[I32X4], &[I8]),
(Opcode::VanyTrue, &[I64X2], &[I8]),
// SwidenLow
(Opcode::SwidenLow, &[I8X16], &[I16X8]),
(Opcode::SwidenLow, &[I16X8], &[I32X4]),
(Opcode::SwidenLow, &[I32X4], &[I64X2]),
// SwidenHigh
(Opcode::SwidenHigh, &[I8X16], &[I16X8]),
(Opcode::SwidenHigh, &[I16X8], &[I32X4]),
(Opcode::SwidenHigh, &[I32X4], &[I64X2]),
// UwidenLow
(Opcode::UwidenLow, &[I8X16], &[I16X8]),
(Opcode::UwidenLow, &[I16X8], &[I32X4]),
(Opcode::UwidenLow, &[I32X4], &[I64X2]),
// UwidenHigh
(Opcode::UwidenHigh, &[I8X16], &[I16X8]),
(Opcode::UwidenHigh, &[I16X8], &[I32X4]),
(Opcode::UwidenHigh, &[I32X4], &[I64X2]),
// SqmulRoundSat
(Opcode::SqmulRoundSat, &[I16X8, I16X8], &[I16X8]),
(Opcode::SqmulRoundSat, &[I32X4, I32X4], &[I32X4]),
// IaddPairwise
(Opcode::IaddPairwise, &[I8X16, I8X16], &[I8X16]),
(Opcode::IaddPairwise, &[I16X8, I16X8], &[I16X8]),
(Opcode::IaddPairwise, &[I32X4, I32X4], &[I32X4]),
// Integer Consts
(Opcode::Iconst, &[], &[I8]),
(Opcode::Iconst, &[], &[I16]),
(Opcode::Iconst, &[], &[I32]),
(Opcode::Iconst, &[], &[I64]),
// Float Consts
(Opcode::F32const, &[], &[F32]),
(Opcode::F64const, &[], &[F64]),
// Vector Consts
(Opcode::Vconst, &[], &[I8X16]),
(Opcode::Vconst, &[], &[I16X8]),
(Opcode::Vconst, &[], &[I32X4]),
(Opcode::Vconst, &[], &[I64X2]),
(Opcode::Vconst, &[], &[F32X4]),
(Opcode::Vconst, &[], &[F64X2]),
// 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 => insert_ins_ext_lane,
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 => insert_shuffle,
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 => insert_ins_ext_lane,
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,
{
u: &'r mut Unstructured<'data>,
config: &'r Config,
resources: Resources,
target_triple: Triple,
name: UserFuncName,
signature: Signature,
}
#[derive(Debug, Clone)]
enum BlockTerminator {
Return,
Jump(Block),
Br(Block, Block),
BrTable(Block, Vec<Block>),
Switch(Type, Block, HashMap<u128, Block>),
}
#[derive(Debug, Clone)]
enum BlockTerminatorKind {
Return,
Jump,
Br,
BrTable,
Switch,
}
#[derive(Default)]
struct Resources {
vars: HashMap<Type, Vec<Variable>>,
blocks: Vec<(Block, BlockSignature)>,
blocks_without_params: Vec<Block>,
block_terminators: Vec<BlockTerminator>,
func_refs: Vec<(Signature, FuncRef)>,
stack_slots: Vec<(StackSlot, StackSize)>,
usercalls: Vec<(UserExternalName, Signature)>,
libcalls: Vec<LibCall>,
}
impl Resources {
/// Partitions blocks at `block`. Only blocks that can be targeted by branches are considered.
///
/// The first slice includes all blocks up to and including `block`.
/// The second slice includes all remaining blocks.
fn partition_target_blocks(
&self,
block: Block,
) -> (&[(Block, BlockSignature)], &[(Block, BlockSignature)]) {
// Blocks are stored in-order and have no gaps, this means that we can simply index them by
// their number. We also need to exclude the entry block since it isn't a valid target.
let target_blocks = &self.blocks[1..];
target_blocks.split_at(block.as_u32() as usize)
}
/// Returns blocks forward of `block`. Only blocks that can be targeted by branches are considered.
fn forward_blocks(&self, block: Block) -> &[(Block, BlockSignature)] {
let (_, forward_blocks) = self.partition_target_blocks(block);
forward_blocks
}
/// Generates a slice of `blocks_without_params` ahead of `block`
fn forward_blocks_without_params(&self, block: Block) -> &[Block] {
let partition_point = self.blocks_without_params.partition_point(|b| *b <= block);
&self.blocks_without_params[partition_point..]
}
}
impl<'r, 'data> FunctionGenerator<'r, 'data>
where
'data: 'r,
{
pub fn new(
u: &'r mut Unstructured<'data>,
config: &'r Config,
target_triple: Triple,
name: UserFuncName,
signature: Signature,
usercalls: Vec<(UserExternalName, Signature)>,
libcalls: Vec<LibCall>,
) -> Self {
Self {
u,
config,
resources: Resources {
usercalls,
libcalls,
..Resources::default()
},
target_triple,
name,
signature,
}
}
/// Generates a random value for config `param`
fn param(&mut self, param: &RangeInclusive<usize>) -> Result<usize> {
Ok(self.u.int_in_range(param.clone())?)
}
fn system_callconv(&mut self) -> CallConv {
// TODO: This currently only runs on linux, so this is the only choice
// We should improve this once we generate flags and targets
CallConv::SystemV
}
/// Finds a stack slot with size of at least n bytes
fn stack_slot_with_size(&mut self, n: u32) -> Result<(StackSlot, StackSize)> {
let first = self
.resources
.stack_slots
.partition_point(|&(_slot, size)| size < n);
Ok(*self.u.choose(&self.resources.stack_slots[first..])?)
}
/// Generates an address that should allow for a store or a load.
///
/// Addresses aren't generated like other values. They are never stored in variables so that
/// we don't run the risk of returning them from a function, which would make the fuzzer
/// complain since they are different from the interpreter to the backend.
///
/// `min_size`: Controls the amount of space that the address should have.
///
/// `aligned`: When passed as true, the resulting address is guaranteed to be aligned
/// on an 8 byte boundary.
///
/// Returns a valid address and the maximum possible offset that still respects `min_size`.
fn generate_load_store_address(
&mut self,
builder: &mut FunctionBuilder,
min_size: u32,
aligned: bool,
) -> Result<(Value, u32)> {
// TODO: Currently our only source of addresses is stack_addr, but we
// should add global_value, symbol_value eventually
let (addr, available_size) = {
let (ss, slot_size) = self.stack_slot_with_size(min_size)?;
// stack_slot_with_size guarantees that slot_size >= min_size
let max_offset = slot_size - min_size;
let offset = if aligned {
self.u.int_in_range(0..=max_offset / min_size)? * min_size
} else {
self.u.int_in_range(0..=max_offset)?
};
let base_addr = builder.ins().stack_addr(I64, ss, offset as i32);
let available_size = slot_size.saturating_sub(offset);
(base_addr, available_size)
};
// TODO: Insert a bunch of amode opcodes here to modify the address!
// Now that we have an address and a size, we just choose a random offset to return to the
// caller. Preserving min_size bytes.
let max_offset = available_size.saturating_sub(min_size);
Ok((addr, max_offset))
}
// Generates an address and memflags for a load or store.
fn generate_address_and_memflags(
&mut self,
builder: &mut FunctionBuilder,
min_size: u32,
is_atomic: bool,
) -> Result<(Value, MemFlags, Offset32)> {
// Should we generate an aligned address
// Some backends have issues with unaligned atomics.
// AArch64: https://github.com/bytecodealliance/wasmtime/issues/5483
// RISCV: https://github.com/bytecodealliance/wasmtime/issues/5882
let requires_aligned_atomics = matches!(
self.target_triple.architecture,
Architecture::Aarch64(_) | Architecture::Riscv64(_)
);
let aligned = if is_atomic && requires_aligned_atomics {
true
} else if min_size > 8 {
// TODO: We currently can't guarantee that a stack_slot will be aligned on a 16 byte
// boundary. We don't have a way to specify alignment when creating stack slots, and
// cranelift only guarantees 8 byte alignment between stack slots.
// See: https://github.com/bytecodealliance/wasmtime/issues/5922#issuecomment-1457926624
false
} else {
bool::arbitrary(self.u)?
};
let mut flags = MemFlags::new();
// Even if we picked an aligned address, we can always generate unaligned memflags
if aligned && bool::arbitrary(self.u)? {
flags.set_aligned();
}
// If the address is aligned, then we know it won't trap
if aligned && bool::arbitrary(self.u)? {
flags.set_notrap();
}
let (address, max_offset) = self.generate_load_store_address(builder, min_size, aligned)?;
// Pick an offset to pass into the load/store.
let offset = if aligned {
0
} else {
self.u.int_in_range(0..=max_offset)? as i32
}
.into();
Ok((address, flags, offset))
}
/// Get a variable of type `ty` from the current function
fn get_variable_of_type(&mut self, ty: Type) -> Result<Variable> {
let opts = self.resources.vars.get(&ty).map_or(&[][..], Vec::as_slice);
let var = self.u.choose(opts)?;
Ok(*var)
}
/// Generates an instruction(`iconst`/`fconst`/etc...) to introduce a constant value
fn generate_const(&mut self, builder: &mut FunctionBuilder, ty: Type) -> Result<Value> {
Ok(match self.u.datavalue(ty)? {
DataValue::I8(i) => builder.ins().iconst(ty, i as i64),
DataValue::I16(i) => builder.ins().iconst(ty, i as i64),
DataValue::I32(i) => builder.ins().iconst(ty, i as i64),
DataValue::I64(i) => builder.ins().iconst(ty, i as i64),
DataValue::I128(i) => {
let hi = builder.ins().iconst(I64, (i >> 64) as i64);
let lo = builder.ins().iconst(I64, i as i64);
builder.ins().iconcat(lo, hi)
}
DataValue::F32(f) => builder.ins().f32const(f),
DataValue::F64(f) => builder.ins().f64const(f),
DataValue::V128(bytes) => {
let data = bytes.to_vec().into();
let handle = builder.func.dfg.constants.insert(data);
builder.ins().vconst(ty, handle)
}
_ => unimplemented!(),
})
}
/// Chooses a random block which can be targeted by a jump / branch.
/// This means any block that is not the first block.
fn generate_target_block(&mut self, source_block: Block) -> Result<Block> {
// We try to mostly generate forward branches to avoid generating an excessive amount of
// infinite loops. But they are still important, so give them a small chance of existing.
let (backwards_blocks, forward_blocks) =
self.resources.partition_target_blocks(source_block);
let ratio = self.config.backwards_branch_ratio;
let block_targets = if !backwards_blocks.is_empty() && self.u.ratio(ratio.0, ratio.1)? {
backwards_blocks
} else {
forward_blocks
};
assert!(!block_targets.is_empty());
let (block, _) = self.u.choose(block_targets)?.clone();
Ok(block)
}
fn generate_values_for_block(
&mut self,
builder: &mut FunctionBuilder,
block: Block,
) -> Result<Vec<Value>> {
let (_, sig) = self.resources.blocks[block.as_u32() as usize].clone();
self.generate_values_for_signature(builder, sig.iter().copied())
}
fn generate_values_for_signature<I: Iterator<Item = Type>>(
&mut self,
builder: &mut FunctionBuilder,
signature: I,
) -> Result<Vec<Value>> {
signature
.map(|ty| {
let var = self.get_variable_of_type(ty)?;
let val = builder.use_var(var);
Ok(val)
})
.collect()
}
/// The terminator that we need to insert has already been picked ahead of time
/// we just need to build the instructions for it
fn insert_terminator(
&mut self,
builder: &mut FunctionBuilder,
source_block: Block,
) -> Result<()> {
let terminator = self.resources.block_terminators[source_block.as_u32() as usize].clone();
match terminator {
BlockTerminator::Return => {
let types: Vec<Type> = {
let rets = &builder.func.signature.returns;
rets.iter().map(|p| p.value_type).collect()
};
let vals = self.generate_values_for_signature(builder, types.into_iter())?;
builder.ins().return_(&vals[..]);
}
BlockTerminator::Jump(target) => {
let args = self.generate_values_for_block(builder, target)?;
builder.ins().jump(target, &args[..]);
}
BlockTerminator::Br(left, right) => {
let left_args = self.generate_values_for_block(builder, left)?;
let right_args = self.generate_values_for_block(builder, right)?;
let condbr_types = [I8, I16, I32, I64, I128];
let _type = *self.u.choose(&condbr_types[..])?;
let val = builder.use_var(self.get_variable_of_type(_type)?);
builder
.ins()
.brif(val, left, &left_args[..], right, &right_args[..]);
}
BlockTerminator::BrTable(default, targets) => {
// Create jump tables on demand
let mut jt = Vec::with_capacity(targets.len());
for block in targets {
let args = self.generate_values_for_block(builder, block)?;
jt.push(builder.func.dfg.block_call(block, &args))
}
let args = self.generate_values_for_block(builder, default)?;
let jt_data = JumpTableData::new(builder.func.dfg.block_call(default, &args), &jt);
let jt = builder.create_jump_table(jt_data);
// br_table only supports I32
let val = builder.use_var(self.get_variable_of_type(I32)?);
builder.ins().br_table(val, jt);
}
BlockTerminator::Switch(_type, default, entries) => {
let mut switch = Switch::new();
for (&entry, &block) in entries.iter() {
switch.set_entry(entry, block);
}
let switch_val = builder.use_var(self.get_variable_of_type(_type)?);
switch.emit(builder, switch_val, default);
}
}
Ok(())
}
/// 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) = *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
// generation, to avoid invalidating the corpus when instructions are enabled/disabled.
if !valid_for_target(&self.target_triple, op, args, rets) {
return Err(arbitrary::Error::IncorrectFormat.into());
}
let inserter = inserter_for_format(op.format());
inserter(self, builder, op, args, rets)?;
}
Ok(())
}
fn generate_funcrefs(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
let usercalls: Vec<(ExternalName, Signature)> = self
.resources
.usercalls
.iter()
.map(|(name, signature)| {
let user_func_ref = builder.func.declare_imported_user_function(name.clone());
let name = ExternalName::User(user_func_ref);
(name, signature.clone())
})
.collect();
let lib_callconv = self.system_callconv();
let libcalls: Vec<(ExternalName, Signature)> = self
.resources
.libcalls
.iter()
.map(|libcall| {
let signature = libcall.signature(lib_callconv);
let name = ExternalName::LibCall(*libcall);
(name, signature)
})
.collect();
for (name, signature) in usercalls.into_iter().chain(libcalls) {
let sig_ref = builder.import_signature(signature.clone());
let func_ref = builder.import_function(ExtFuncData {
name,
signature: sig_ref,
colocated: self.u.arbitrary()?,
});
self.resources.func_refs.push((signature, func_ref));
}
Ok(())
}
fn generate_stack_slots(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
for _ in 0..self.param(&self.config.static_stack_slots_per_function)? {
let bytes = self.param(&self.config.static_stack_slot_size)? as u32;
let ss_data = StackSlotData::new(StackSlotKind::ExplicitSlot, bytes);
let slot = builder.create_sized_stack_slot(ss_data);
self.resources.stack_slots.push((slot, bytes));
}
self.resources
.stack_slots
.sort_unstable_by_key(|&(_slot, bytes)| bytes);
Ok(())
}
/// Zero initializes the stack slot by inserting `stack_store`'s.
fn initialize_stack_slots(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
let i8_zero = builder.ins().iconst(I8, 0);
let i16_zero = builder.ins().iconst(I16, 0);
let i32_zero = builder.ins().iconst(I32, 0);
let i64_zero = builder.ins().iconst(I64, 0);
let i128_zero = builder.ins().uextend(I128, i64_zero);
for &(slot, init_size) in self.resources.stack_slots.iter() {
let mut size = init_size;
// Insert the largest available store for the remaining size.
while size != 0 {
let offset = (init_size - size) as i32;
let (val, filled) = match size {
sz if sz / 16 > 0 => (i128_zero, 16),
sz if sz / 8 > 0 => (i64_zero, 8),
sz if sz / 4 > 0 => (i32_zero, 4),
sz if sz / 2 > 0 => (i16_zero, 2),
_ => (i8_zero, 1),
};
builder.ins().stack_store(val, slot, offset);
size -= filled;
}
}
Ok(())
}
/// Creates a random amount of blocks in this function
fn generate_blocks(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
let extra_block_count = self.param(&self.config.blocks_per_function)?;
// We must always have at least one block, so we generate the "extra" blocks and add 1 for
// the entry block.
let block_count = 1 + extra_block_count;
// Blocks need to be sorted in ascending order
self.resources.blocks = (0..block_count)
.map(|i| {
let is_entry = i == 0;
let block = builder.create_block();
// Optionally mark blocks that are not the entry block as cold
if !is_entry {
if bool::arbitrary(self.u)? {
builder.set_cold_block(block);
}
}
// The first block has to have the function signature, but for the rest of them we generate
// a random signature;
if is_entry {
builder.append_block_params_for_function_params(block);
Ok((
block,
self.signature.params.iter().map(|a| a.value_type).collect(),
))
} else {
let sig = self.generate_block_signature()?;
sig.iter().for_each(|ty| {
builder.append_block_param(block, *ty);
});
Ok((block, sig))
}
})
.collect::<Result<Vec<_>>>()?;
// Valid blocks for jump tables have to have no parameters in the signature, and must also
// not be the first block.
self.resources.blocks_without_params = self.resources.blocks[1..]
.iter()
.filter(|(_, sig)| sig.len() == 0)
.map(|(b, _)| *b)
.collect();
// Compute the block CFG
//
// cranelift-frontend requires us to never generate unreachable blocks
// To ensure this property we start by constructing a main "spine" of blocks. So block1 can
// always jump to block2, and block2 can always jump to block3, etc...
//
// That is not a very interesting CFG, so we introduce variations on that, but always
// ensuring that the property of pointing to the next block is maintained whatever the
// branching mechanism we use.
let blocks = self.resources.blocks.clone();
self.resources.block_terminators = blocks
.iter()
.map(|&(block, _)| {
let next_block = Block::with_number(block.as_u32() + 1).unwrap();
let forward_blocks = self.resources.forward_blocks(block);
let paramless_targets = self.resources.forward_blocks_without_params(block);
let has_paramless_targets = !paramless_targets.is_empty();
let next_block_is_paramless = paramless_targets.contains(&next_block);
let mut valid_terminators = vec![];
if forward_blocks.is_empty() {
// Return is only valid on the last block.
valid_terminators.push(BlockTerminatorKind::Return);
} else {
// If we have more than one block we can allow terminators that target blocks.
// TODO: We could add some kind of BrReturn here, to explore edges where we
// exit in the middle of the function
valid_terminators.extend_from_slice(&[
BlockTerminatorKind::Jump,
BlockTerminatorKind::Br,
BlockTerminatorKind::BrTable,
]);
}
// As the Switch interface only allows targeting blocks without params we need
// to ensure that the next block has no params, since that one is guaranteed to be
// picked in either case.
if has_paramless_targets && next_block_is_paramless {
valid_terminators.push(BlockTerminatorKind::Switch);
}
let terminator = self.u.choose(&valid_terminators)?;
// Choose block targets for the terminators that we picked above
Ok(match terminator {
BlockTerminatorKind::Return => BlockTerminator::Return,
BlockTerminatorKind::Jump => BlockTerminator::Jump(next_block),
BlockTerminatorKind::Br => {
BlockTerminator::Br(next_block, self.generate_target_block(block)?)
}
// TODO: Allow generating backwards branches here
BlockTerminatorKind::BrTable => {
// Make the default the next block, and then we don't have to worry
// that we can reach it via the targets
let default = next_block;
let target_count = self.param(&self.config.jump_table_entries)?;
let targets = Result::from_iter(
(0..target_count).map(|_| self.generate_target_block(block)),
)?;
BlockTerminator::BrTable(default, targets)
}
BlockTerminatorKind::Switch => {
// Make the default the next block, and then we don't have to worry
// that we can reach it via the entries below
let default_block = next_block;
let _type = *self.u.choose(&[I8, I16, I32, I64, I128][..])?;
// Build this into a HashMap since we cannot have duplicate entries.
let mut entries = HashMap::new();
for _ in 0..self.param(&self.config.switch_cases)? {
// The Switch API only allows for entries that are addressable by the index type
// so we need to limit the range of values that we generate.
let (ty_min, ty_max) = _type.bounds(false);
let range_start = self.u.int_in_range(ty_min..=ty_max)?;
// We can either insert a contiguous range of blocks or a individual block
// This is done because the Switch API specializes contiguous ranges.
let range_size = if bool::arbitrary(self.u)? {
1
} else {
self.param(&self.config.switch_max_range_size)?
} as u128;
// Build the switch entries
for i in 0..range_size {
let index = range_start.wrapping_add(i) % ty_max;
let block = *self
.u
.choose(self.resources.forward_blocks_without_params(block))?;
entries.insert(index, block);
}
}
BlockTerminator::Switch(_type, default_block, entries)
}
})
})
.collect::<Result<_>>()?;
Ok(())
}
fn generate_block_signature(&mut self) -> Result<BlockSignature> {
let param_count = self.param(&self.config.block_signature_params)?;
let mut params = Vec::with_capacity(param_count);
for _ in 0..param_count {
params.push(self.u._type(self.target_triple.architecture)?);
}
Ok(params)
}
fn build_variable_pool(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
let block = builder.current_block().unwrap();
// Define variables for the function signature
let mut vars: Vec<_> = builder
.func
.signature
.params
.iter()
.map(|param| param.value_type)
.zip(builder.block_params(block).iter().copied())
.collect();
// Create a pool of vars that are going to be used in this function
for _ in 0..self.param(&self.config.vars_per_function)? {
let ty = self.u._type(self.target_triple.architecture)?;
let value = self.generate_const(builder, ty)?;
vars.push((ty, value));
}
for (id, (ty, value)) in vars.into_iter().enumerate() {
let var = Variable::new(id);
builder.declare_var(var, ty);
builder.def_var(var, value);
self.resources
.vars
.entry(ty)
.or_insert_with(Vec::new)
.push(var);
}
Ok(())
}
/// We generate a function in multiple stages:
///
/// * First we generate a random number of empty blocks
/// * Then we generate a random pool of variables to be used throughout the function
/// * We then visit each block and generate random instructions
///
/// Because we generate all blocks and variables up front we already know everything that
/// we need when generating instructions (i.e. jump targets / variables)
pub fn generate(mut self) -> Result<Function> {
let mut fn_builder_ctx = FunctionBuilderContext::new();
let mut func = Function::with_name_signature(self.name.clone(), self.signature.clone());
let mut builder = FunctionBuilder::new(&mut func, &mut fn_builder_ctx);
self.generate_blocks(&mut builder)?;
// Function preamble
self.generate_funcrefs(&mut builder)?;
self.generate_stack_slots(&mut builder)?;
// Main instruction generation loop
for (block, block_sig) in self.resources.blocks.clone().into_iter() {
let is_block0 = block.as_u32() == 0;
builder.switch_to_block(block);
if is_block0 {
// The first block is special because we must create variables both for the
// block signature and for the variable pool. Additionally, we must also define
// initial values for all variables that are not the function signature.
self.build_variable_pool(&mut builder)?;
// Stack slots have random bytes at the beginning of the function
// initialize them to a constant value so that execution stays predictable.
self.initialize_stack_slots(&mut builder)?;
} else {
// Define variables for the block params
for (i, ty) in block_sig.iter().enumerate() {
let var = self.get_variable_of_type(*ty)?;
let block_param = builder.block_params(block)[i];
builder.def_var(var, block_param);
}
}
// Generate block instructions
self.generate_instructions(&mut builder)?;
// Insert a terminator to safely exit the block
self.insert_terminator(&mut builder, block)?;
}
builder.seal_all_blocks();
builder.finalize();
Ok(func)
}
}
#[cfg(test)]
mod tests {
use super::OPCODE_SIGNATURES;
use cranelift::codegen::ir::{instructions::ResolvedConstraint, types::*, Opcode, Type};
use std::collections::HashMap;
/// The list of opcodes that we exclude from the analysis. This should only be instructions
/// that affect control flow, as everything else should be handled by the general machinery in
/// function_generator.
///
/// NOTE: This list should not grow, and ultimately should just be the set of instructions that
/// need special handling outside of `generate_instructions`.
const SKIPPED_OPCODES: &[Opcode] = &[
// These opcodes have special handling in cranelift-fuzzgen
Opcode::Call,
Opcode::Return,
Opcode::Jump,
Opcode::Brif,
Opcode::BrTable,
// TODO: ExtractVector produces dynamic vectors, and those cause a panic in
// `constraint.result_type`.
Opcode::ExtractVector,
// These opcodes are known to have invalid signatures, but the specific types chosen are
// not used by the insertion strategy for that format. They can be removed when their
// entries in OPCODE_SIGNATURES have been fixed
Opcode::Load,
Opcode::Store,
Opcode::AtomicLoad,
Opcode::AtomicStore,
Opcode::AtomicCas,
Opcode::AtomicRmw,
Opcode::Sload8,
Opcode::Sload16,
Opcode::Sload32,
Opcode::Uload8,
Opcode::Uload16,
Opcode::Uload32,
Opcode::Istore8,
Opcode::Istore16,
Opcode::Istore32,
];
/// This is the set of types that we know how to fuzz in cranelift. It's not specialized by
/// targets, as we expect any target-specific support for things like SIMD to be expressed in
/// the `function_generator::valid_for_target` predicate instead.
const TYPES: &[Type] = &[
I8, I16, I32, I64, I128, // Scalar Integers
F32, F64, // Scalar Floats
I8X16, I16X8, I32X4, I64X2, // SIMD Integers
F32X4, F64X2, // SIMD Floats
];
/// Generate all instantiations of all opcodes in cranelift, minus those named in
/// [SKIPPED_OPCODES].
fn instruction_instantiations<'a>() -> Vec<(Opcode, Vec<Type>, Vec<Type>)> {
let mut insts = vec![];
for op in Opcode::all() {
if SKIPPED_OPCODES.contains(op) {
continue;
}
let constraints = op.constraints();
let ctrl_types = if let Some(ctrls) = constraints.ctrl_typeset() {
Vec::from_iter(TYPES.iter().copied().filter(|ty| ctrls.contains(*ty)))
} else {
vec![INVALID]
};
for ctrl_type in ctrl_types {
let rets = Vec::from_iter(
(0..constraints.num_fixed_results())
.map(|i| constraints.result_type(i, ctrl_type)),
);
// Cols is a vector whose length will match `num_fixed_value_arguments`, and whose
// elements will be vectors of types that are valid for that fixed argument
// position.
let mut cols = vec![];
for i in 0..constraints.num_fixed_value_arguments() {
match constraints.value_argument_constraint(i, ctrl_type) {
ResolvedConstraint::Bound(ty) => cols.push(Vec::from([ty])),
ResolvedConstraint::Free(tys) => cols.push(Vec::from_iter(
TYPES.iter().copied().filter(|ty| tys.contains(*ty)),
)),
}
}
// Generate the cartesian product of cols to produce a vector of argument lists,
// argss. The argss vector is seeded with the empty argument list, so there's an
// initial value to be extended in the loop below.
let mut argss = vec![vec![]];
let mut cols = cols.as_slice();
while let Some((col, rest)) = cols.split_last() {
cols = rest;
let mut next = vec![];
for current in argss.iter() {
// Extend the front of each argument candidate with every type in `col`.
for ty in col {
let mut args = vec![*ty];
args.extend_from_slice(&current);
next.push(args);
}
}
let _ = std::mem::replace(&mut argss, next);
}
for args in argss {
insts.push((*op, args, rets.clone()));
}
}
}
insts
}
#[derive(Eq, PartialEq, Debug)]
struct Inst<'a> {
args: &'a [Type],
rets: &'a [Type],
}
fn build_sig_map<'a, T>(sigs: &'a [(Opcode, T, T)]) -> HashMap<Opcode, Vec<Inst<'a>>>
where
T: AsRef<[Type]>,
{
let mut insts = HashMap::<Opcode, Vec<Inst<'a>>>::default();
for (op, args, rets) in sigs {
insts.entry(*op).or_default().push(Inst {
args: args.as_ref(),
rets: rets.as_ref(),
});
}
insts
}
#[test]
fn validate_opcode_signatures() {
// We could instead use the instruction constraints to validate the entries in
// OPCODE_SIGNATURES directly, but generating all instantiations gives us the ability to
// also generate the complement of signatures that we don't currently handle in the future.
let all_ops = instruction_instantiations();
let everything = build_sig_map(&all_ops);
let fuzzed = build_sig_map(OPCODE_SIGNATURES);
let mut found_errs = false;
let mut unknown = vec![];
for (op, insts) in fuzzed.iter() {
if let Some(known_insts) = everything.get(op) {
let invalid =
Vec::from_iter(insts.iter().filter(|inst| !known_insts.contains(inst)));
if !invalid.is_empty() {
found_errs = true;
println!("# Invalid instantiations for Opcode::{:?}", op);
for inst in invalid {
println!("- args: `{:?}`, rets: `{:?}`", inst.args, inst.rets);
}
}
} else {
if !SKIPPED_OPCODES.contains(op) {
unknown.push(*op);
}
}
}
if !unknown.is_empty() {
found_errs = true;
println!();
println!("# Instructions without known instantiations");
for op in unknown {
println!("- Opcode::{:?}", op);
}
}
assert!(
!found_errs,
"Discovered inconsistent entries in OPCODE_SIGNATURES"
);
}
}
Reference in New Issue View Git Blame Copy Permalink