use std::error::Error;
use std::fmt;
use std::result;
#[derive(Debug, Clone)]
pub struct BinaryReaderError {
pub(crate) inner: Box<BinaryReaderErrorInner>,
}
#[derive(Debug, Clone)]
pub(crate) struct BinaryReaderErrorInner {
pub(crate) message: String,
pub(crate) offset: usize,
pub(crate) needed_hint: Option<usize>,
}
pub type Result<T, E = BinaryReaderError> = result::Result<T, E>;
impl Error for BinaryReaderError {}
impl fmt::Display for BinaryReaderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"{} (at offset {})",
self.inner.message, self.inner.offset
)
}
}
impl BinaryReaderError {
pub(crate) fn new(message: impl Into<String>, offset: usize) -> Self {
let message = message.into();
BinaryReaderError {
inner: Box::new(BinaryReaderErrorInner {
message,
offset,
needed_hint: None,
}),
}
}
pub(crate) fn eof(offset: usize, needed_hint: usize) -> Self {
BinaryReaderError {
inner: Box::new(BinaryReaderErrorInner {
message: "Unexpected EOF".to_string(),
offset,
needed_hint: Some(needed_hint),
}),
}
}
pub fn message(&self) -> &str {
&self.inner.message
}
pub fn offset(&self) -> usize {
self.inner.offset
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum CustomSectionKind {
Unknown,
Name,
Producers,
SourceMappingURL,
Reloc,
Linking,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum SectionCode<'a> {
Custom {
name: &'a str,
kind: CustomSectionKind,
},
Type,
Alias,
Import,
Module,
Instance,
Function,
Table,
Memory,
Global,
Export,
Start,
Element,
ModuleCode,
Code,
Data,
DataCount,
Event,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Type {
I32,
I64,
F32,
F64,
V128,
FuncRef,
ExternRef,
ExnRef,
Func,
EmptyBlockType,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TypeOrFuncType {
Type(Type),
FuncType(u32),
}
#[derive(Debug, Copy, Clone)]
pub enum ExternalKind {
Function,
Table,
Memory,
Event,
Global,
Type,
Module,
Instance,
}
#[derive(Debug, Clone)]
pub enum TypeDef<'a> {
Func(FuncType),
Instance(InstanceType<'a>),
Module(ModuleType<'a>),
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct FuncType {
pub params: Box<[Type]>,
pub returns: Box<[Type]>,
}
#[derive(Debug, Clone)]
pub struct InstanceType<'a> {
pub exports: Box<[ExportType<'a>]>,
}
#[derive(Debug, Clone)]
pub struct ModuleType<'a> {
pub imports: Box<[crate::Import<'a>]>,
pub exports: Box<[ExportType<'a>]>,
}
#[derive(Debug, Clone)]
pub struct ExportType<'a> {
pub name: &'a str,
pub ty: ImportSectionEntryType,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct ResizableLimits {
pub initial: u32,
pub maximum: Option<u32>,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct ResizableLimits64 {
pub initial: u64,
pub maximum: Option<u64>,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct TableType {
pub element_type: Type,
pub limits: ResizableLimits,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum MemoryType {
M32 {
limits: ResizableLimits,
shared: bool,
},
M64 {
limits: ResizableLimits64,
shared: bool,
},
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct EventType {
pub type_index: u32,
}
impl MemoryType {
pub fn index_type(&self) -> Type {
match self {
MemoryType::M32 { .. } => Type::I32,
MemoryType::M64 { .. } => Type::I64,
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct GlobalType {
pub content_type: Type,
pub mutable: bool,
}
#[derive(Debug, Copy, Clone)]
pub enum ImportSectionEntryType {
Function(u32),
Table(TableType),
Memory(MemoryType),
Event(EventType),
Global(GlobalType),
Module(u32),
Instance(u32),
}
#[derive(Debug, Copy, Clone)]
pub struct MemoryImmediate {
pub align: u8,
pub offset: u32,
pub memory: u32,
}
#[derive(Debug, Copy, Clone)]
pub struct Naming<'a> {
pub index: u32,
pub name: &'a str,
}
#[derive(Debug, Copy, Clone)]
pub enum NameType {
Module,
Function,
Local,
}
#[derive(Debug, Copy, Clone)]
pub enum LinkingType {
StackPointer(u32),
}
#[derive(Debug, Copy, Clone)]
pub enum RelocType {
FunctionIndexLEB,
TableIndexSLEB,
TableIndexI32,
GlobalAddrLEB,
GlobalAddrSLEB,
GlobalAddrI32,
TypeIndexLEB,
GlobalIndexLEB,
}
#[derive(Clone)]
pub struct BrTable<'a> {
pub(crate) reader: crate::BinaryReader<'a>,
pub(crate) cnt: usize,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct Ieee32(pub(crate) u32);
impl Ieee32 {
pub fn bits(self) -> u32 {
self.0
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct Ieee64(pub(crate) u64);
impl Ieee64 {
pub fn bits(self) -> u64 {
self.0
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct V128(pub(crate) [u8; 16]);
impl V128 {
pub fn bytes(&self) -> &[u8; 16] {
&self.0
}
}
pub type SIMDLaneIndex = u8;
#[derive(Debug, Clone)]
pub enum Operator<'a> {
Unreachable,
Nop,
Block {
ty: TypeOrFuncType,
},
Loop {
ty: TypeOrFuncType,
},
If {
ty: TypeOrFuncType,
},
Else,
Try {
ty: TypeOrFuncType,
},
Catch {
index: u32,
},
Throw {
index: u32,
},
Rethrow {
relative_depth: u32,
},
Unwind,
End,
Br {
relative_depth: u32,
},
BrIf {
relative_depth: u32,
},
BrTable {
table: BrTable<'a>,
},
Return,
Call {
function_index: u32,
},
CallIndirect {
index: u32,
table_index: u32,
},
ReturnCall {
function_index: u32,
},
ReturnCallIndirect {
index: u32,
table_index: u32,
},
Delegate {
relative_depth: u32,
},
CatchAll,
Drop,
Select,
TypedSelect {
ty: Type,
},
LocalGet {
local_index: u32,
},
LocalSet {
local_index: u32,
},
LocalTee {
local_index: u32,
},
GlobalGet {
global_index: u32,
},
GlobalSet {
global_index: u32,
},
I32Load {
memarg: MemoryImmediate,
},
I64Load {
memarg: MemoryImmediate,
},
F32Load {
memarg: MemoryImmediate,
},
F64Load {
memarg: MemoryImmediate,
},
I32Load8S {
memarg: MemoryImmediate,
},
I32Load8U {
memarg: MemoryImmediate,
},
I32Load16S {
memarg: MemoryImmediate,
},
I32Load16U {
memarg: MemoryImmediate,
},
I64Load8S {
memarg: MemoryImmediate,
},
I64Load8U {
memarg: MemoryImmediate,
},
I64Load16S {
memarg: MemoryImmediate,
},
I64Load16U {
memarg: MemoryImmediate,
},
I64Load32S {
memarg: MemoryImmediate,
},
I64Load32U {
memarg: MemoryImmediate,
},
I32Store {
memarg: MemoryImmediate,
},
I64Store {
memarg: MemoryImmediate,
},
F32Store {
memarg: MemoryImmediate,
},
F64Store {
memarg: MemoryImmediate,
},
I32Store8 {
memarg: MemoryImmediate,
},
I32Store16 {
memarg: MemoryImmediate,
},
I64Store8 {
memarg: MemoryImmediate,
},
I64Store16 {
memarg: MemoryImmediate,
},
I64Store32 {
memarg: MemoryImmediate,
},
MemorySize {
mem: u32,
mem_byte: u8,
},
MemoryGrow {
mem: u32,
mem_byte: u8,
},
I32Const {
value: i32,
},
I64Const {
value: i64,
},
F32Const {
value: Ieee32,
},
F64Const {
value: Ieee64,
},
RefNull {
ty: Type,
},
RefIsNull,
RefFunc {
function_index: u32,
},
I32Eqz,
I32Eq,
I32Ne,
I32LtS,
I32LtU,
I32GtS,
I32GtU,
I32LeS,
I32LeU,
I32GeS,
I32GeU,
I64Eqz,
I64Eq,
I64Ne,
I64LtS,
I64LtU,
I64GtS,
I64GtU,
I64LeS,
I64LeU,
I64GeS,
I64GeU,
F32Eq,
F32Ne,
F32Lt,
F32Gt,
F32Le,
F32Ge,
F64Eq,
F64Ne,
F64Lt,
F64Gt,
F64Le,
F64Ge,
I32Clz,
I32Ctz,
I32Popcnt,
I32Add,
I32Sub,
I32Mul,
I32DivS,
I32DivU,
I32RemS,
I32RemU,
I32And,
I32Or,
I32Xor,
I32Shl,
I32ShrS,
I32ShrU,
I32Rotl,
I32Rotr,
I64Clz,
I64Ctz,
I64Popcnt,
I64Add,
I64Sub,
I64Mul,
I64DivS,
I64DivU,
I64RemS,
I64RemU,
I64And,
I64Or,
I64Xor,
I64Shl,
I64ShrS,
I64ShrU,
I64Rotl,
I64Rotr,
F32Abs,
F32Neg,
F32Ceil,
F32Floor,
F32Trunc,
F32Nearest,
F32Sqrt,
F32Add,
F32Sub,
F32Mul,
F32Div,
F32Min,
F32Max,
F32Copysign,
F64Abs,
F64Neg,
F64Ceil,
F64Floor,
F64Trunc,
F64Nearest,
F64Sqrt,
F64Add,
F64Sub,
F64Mul,
F64Div,
F64Min,
F64Max,
F64Copysign,
I32WrapI64,
I32TruncF32S,
I32TruncF32U,
I32TruncF64S,
I32TruncF64U,
I64ExtendI32S,
I64ExtendI32U,
I64TruncF32S,
I64TruncF32U,
I64TruncF64S,
I64TruncF64U,
F32ConvertI32S,
F32ConvertI32U,
F32ConvertI64S,
F32ConvertI64U,
F32DemoteF64,
F64ConvertI32S,
F64ConvertI32U,
F64ConvertI64S,
F64ConvertI64U,
F64PromoteF32,
I32ReinterpretF32,
I64ReinterpretF64,
F32ReinterpretI32,
F64ReinterpretI64,
I32Extend8S,
I32Extend16S,
I64Extend8S,
I64Extend16S,
I64Extend32S,
I32TruncSatF32S,
I32TruncSatF32U,
I32TruncSatF64S,
I32TruncSatF64U,
I64TruncSatF32S,
I64TruncSatF32U,
I64TruncSatF64S,
I64TruncSatF64U,
MemoryInit {
segment: u32,
mem: u32,
},
DataDrop {
segment: u32,
},
MemoryCopy {
src: u32,
dst: u32,
},
MemoryFill {
mem: u32,
},
TableInit {
segment: u32,
table: u32,
},
ElemDrop {
segment: u32,
},
TableCopy {
dst_table: u32,
src_table: u32,
},
TableFill {
table: u32,
},
TableGet {
table: u32,
},
TableSet {
table: u32,
},
TableGrow {
table: u32,
},
TableSize {
table: u32,
},
MemoryAtomicNotify {
memarg: MemoryImmediate,
},
MemoryAtomicWait32 {
memarg: MemoryImmediate,
},
MemoryAtomicWait64 {
memarg: MemoryImmediate,
},
AtomicFence {
flags: u8,
},
I32AtomicLoad {
memarg: MemoryImmediate,
},
I64AtomicLoad {
memarg: MemoryImmediate,
},
I32AtomicLoad8U {
memarg: MemoryImmediate,
},
I32AtomicLoad16U {
memarg: MemoryImmediate,
},
I64AtomicLoad8U {
memarg: MemoryImmediate,
},
I64AtomicLoad16U {
memarg: MemoryImmediate,
},
I64AtomicLoad32U {
memarg: MemoryImmediate,
},
I32AtomicStore {
memarg: MemoryImmediate,
},
I64AtomicStore {
memarg: MemoryImmediate,
},
I32AtomicStore8 {
memarg: MemoryImmediate,
},
I32AtomicStore16 {
memarg: MemoryImmediate,
},
I64AtomicStore8 {
memarg: MemoryImmediate,
},
I64AtomicStore16 {
memarg: MemoryImmediate,
},
I64AtomicStore32 {
memarg: MemoryImmediate,
},
I32AtomicRmwAdd {
memarg: MemoryImmediate,
},
I64AtomicRmwAdd {
memarg: MemoryImmediate,
},
I32AtomicRmw8AddU {
memarg: MemoryImmediate,
},
I32AtomicRmw16AddU {
memarg: MemoryImmediate,
},
I64AtomicRmw8AddU {
memarg: MemoryImmediate,
},
I64AtomicRmw16AddU {
memarg: MemoryImmediate,
},
I64AtomicRmw32AddU {
memarg: MemoryImmediate,
},
I32AtomicRmwSub {
memarg: MemoryImmediate,
},
I64AtomicRmwSub {
memarg: MemoryImmediate,
},
I32AtomicRmw8SubU {
memarg: MemoryImmediate,
},
I32AtomicRmw16SubU {
memarg: MemoryImmediate,
},
I64AtomicRmw8SubU {
memarg: MemoryImmediate,
},
I64AtomicRmw16SubU {
memarg: MemoryImmediate,
},
I64AtomicRmw32SubU {
memarg: MemoryImmediate,
},
I32AtomicRmwAnd {
memarg: MemoryImmediate,
},
I64AtomicRmwAnd {
memarg: MemoryImmediate,
},
I32AtomicRmw8AndU {
memarg: MemoryImmediate,
},
I32AtomicRmw16AndU {
memarg: MemoryImmediate,
},
I64AtomicRmw8AndU {
memarg: MemoryImmediate,
},
I64AtomicRmw16AndU {
memarg: MemoryImmediate,
},
I64AtomicRmw32AndU {
memarg: MemoryImmediate,
},
I32AtomicRmwOr {
memarg: MemoryImmediate,
},
I64AtomicRmwOr {
memarg: MemoryImmediate,
},
I32AtomicRmw8OrU {
memarg: MemoryImmediate,
},
I32AtomicRmw16OrU {
memarg: MemoryImmediate,
},
I64AtomicRmw8OrU {
memarg: MemoryImmediate,
},
I64AtomicRmw16OrU {
memarg: MemoryImmediate,
},
I64AtomicRmw32OrU {
memarg: MemoryImmediate,
},
I32AtomicRmwXor {
memarg: MemoryImmediate,
},
I64AtomicRmwXor {
memarg: MemoryImmediate,
},
I32AtomicRmw8XorU {
memarg: MemoryImmediate,
},
I32AtomicRmw16XorU {
memarg: MemoryImmediate,
},
I64AtomicRmw8XorU {
memarg: MemoryImmediate,
},
I64AtomicRmw16XorU {
memarg: MemoryImmediate,
},
I64AtomicRmw32XorU {
memarg: MemoryImmediate,
},
I32AtomicRmwXchg {
memarg: MemoryImmediate,
},
I64AtomicRmwXchg {
memarg: MemoryImmediate,
},
I32AtomicRmw8XchgU {
memarg: MemoryImmediate,
},
I32AtomicRmw16XchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw8XchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw16XchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw32XchgU {
memarg: MemoryImmediate,
},
I32AtomicRmwCmpxchg {
memarg: MemoryImmediate,
},
I64AtomicRmwCmpxchg {
memarg: MemoryImmediate,
},
I32AtomicRmw8CmpxchgU {
memarg: MemoryImmediate,
},
I32AtomicRmw16CmpxchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw8CmpxchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw16CmpxchgU {
memarg: MemoryImmediate,
},
I64AtomicRmw32CmpxchgU {
memarg: MemoryImmediate,
},
V128Load {
memarg: MemoryImmediate,
},
V128Store {
memarg: MemoryImmediate,
},
V128Const {
value: V128,
},
I8x16Splat,
I8x16ExtractLaneS {
lane: SIMDLaneIndex,
},
I8x16ExtractLaneU {
lane: SIMDLaneIndex,
},
I8x16ReplaceLane {
lane: SIMDLaneIndex,
},
I16x8Splat,
I16x8ExtractLaneS {
lane: SIMDLaneIndex,
},
I16x8ExtractLaneU {
lane: SIMDLaneIndex,
},
I16x8ReplaceLane {
lane: SIMDLaneIndex,
},
I32x4Splat,
I32x4ExtractLane {
lane: SIMDLaneIndex,
},
I32x4ReplaceLane {
lane: SIMDLaneIndex,
},
I64x2Splat,
I64x2ExtractLane {
lane: SIMDLaneIndex,
},
I64x2ReplaceLane {
lane: SIMDLaneIndex,
},
F32x4Splat,
F32x4ExtractLane {
lane: SIMDLaneIndex,
},
F32x4ReplaceLane {
lane: SIMDLaneIndex,
},
F64x2Splat,
F64x2ExtractLane {
lane: SIMDLaneIndex,
},
F64x2ReplaceLane {
lane: SIMDLaneIndex,
},
I8x16Eq,
I8x16Ne,
I8x16LtS,
I8x16LtU,
I8x16GtS,
I8x16GtU,
I8x16LeS,
I8x16LeU,
I8x16GeS,
I8x16GeU,
I16x8Eq,
I16x8Ne,
I16x8LtS,
I16x8LtU,
I16x8GtS,
I16x8GtU,
I16x8LeS,
I16x8LeU,
I16x8GeS,
I16x8GeU,
I32x4Eq,
I32x4Ne,
I32x4LtS,
I32x4LtU,
I32x4GtS,
I32x4GtU,
I32x4LeS,
I32x4LeU,
I32x4GeS,
I32x4GeU,
I64x2Eq,
I64x2Ne,
I64x2LtS,
I64x2GtS,
I64x2LeS,
I64x2GeS,
F32x4Eq,
F32x4Ne,
F32x4Lt,
F32x4Gt,
F32x4Le,
F32x4Ge,
F64x2Eq,
F64x2Ne,
F64x2Lt,
F64x2Gt,
F64x2Le,
F64x2Ge,
V128Not,
V128And,
V128AndNot,
V128Or,
V128Xor,
V128Bitselect,
V128AnyTrue,
I8x16Abs,
I8x16Neg,
I8x16AllTrue,
I8x16Bitmask,
I8x16Shl,
I8x16ShrS,
I8x16ShrU,
I8x16Add,
I8x16AddSatS,
I8x16AddSatU,
I8x16Sub,
I8x16SubSatS,
I8x16SubSatU,
I8x16MinS,
I8x16MinU,
I8x16MaxS,
I8x16MaxU,
I16x8Abs,
I16x8Neg,
I16x8AllTrue,
I16x8Bitmask,
I16x8Shl,
I16x8ShrS,
I16x8ShrU,
I16x8Add,
I16x8AddSatS,
I16x8AddSatU,
I16x8Sub,
I16x8SubSatS,
I16x8SubSatU,
I16x8Mul,
I16x8MinS,
I16x8MinU,
I16x8MaxS,
I16x8MaxU,
I32x4Abs,
I32x4Neg,
I32x4AllTrue,
I32x4Bitmask,
I32x4Shl,
I32x4ShrS,
I32x4ShrU,
I32x4Add,
I32x4Sub,
I32x4Mul,
I32x4MinS,
I32x4MinU,
I32x4MaxS,
I32x4MaxU,
I32x4DotI16x8S,
I64x2Abs,
I64x2Neg,
I64x2AllTrue,
I64x2Bitmask,
I64x2Shl,
I64x2ShrS,
I64x2ShrU,
I64x2Add,
I64x2Sub,
I64x2Mul,
F32x4Ceil,
F32x4Floor,
F32x4Trunc,
F32x4Nearest,
F64x2Ceil,
F64x2Floor,
F64x2Trunc,
F64x2Nearest,
F32x4Abs,
F32x4Neg,
F32x4Sqrt,
F32x4Add,
F32x4Sub,
F32x4Mul,
F32x4Div,
F32x4Min,
F32x4Max,
F32x4PMin,
F32x4PMax,
F64x2Abs,
F64x2Neg,
F64x2Sqrt,
F64x2Add,
F64x2Sub,
F64x2Mul,
F64x2Div,
F64x2Min,
F64x2Max,
F64x2PMin,
F64x2PMax,
I32x4TruncSatF32x4S,
I32x4TruncSatF32x4U,
F32x4ConvertI32x4S,
F32x4ConvertI32x4U,
I8x16Swizzle,
I8x16Shuffle {
lanes: [SIMDLaneIndex; 16],
},
V128Load8Splat {
memarg: MemoryImmediate,
},
V128Load16Splat {
memarg: MemoryImmediate,
},
V128Load32Splat {
memarg: MemoryImmediate,
},
V128Load32Zero {
memarg: MemoryImmediate,
},
V128Load64Splat {
memarg: MemoryImmediate,
},
V128Load64Zero {
memarg: MemoryImmediate,
},
I8x16NarrowI16x8S,
I8x16NarrowI16x8U,
I16x8NarrowI32x4S,
I16x8NarrowI32x4U,
I16x8ExtendLowI8x16S,
I16x8ExtendHighI8x16S,
I16x8ExtendLowI8x16U,
I16x8ExtendHighI8x16U,
I32x4ExtendLowI16x8S,
I32x4ExtendHighI16x8S,
I32x4ExtendLowI16x8U,
I32x4ExtendHighI16x8U,
I64x2ExtendLowI32x4S,
I64x2ExtendHighI32x4S,
I64x2ExtendLowI32x4U,
I64x2ExtendHighI32x4U,
I16x8ExtMulLowI8x16S,
I16x8ExtMulHighI8x16S,
I16x8ExtMulLowI8x16U,
I16x8ExtMulHighI8x16U,
I32x4ExtMulLowI16x8S,
I32x4ExtMulHighI16x8S,
I32x4ExtMulLowI16x8U,
I32x4ExtMulHighI16x8U,
I64x2ExtMulLowI32x4S,
I64x2ExtMulHighI32x4S,
I64x2ExtMulLowI32x4U,
I64x2ExtMulHighI32x4U,
I16x8ExtAddPairwiseI8x16S,
I16x8ExtAddPairwiseI8x16U,
I32x4ExtAddPairwiseI16x8S,
I32x4ExtAddPairwiseI16x8U,
V128Load8x8S {
memarg: MemoryImmediate,
},
V128Load8x8U {
memarg: MemoryImmediate,
},
V128Load16x4S {
memarg: MemoryImmediate,
},
V128Load16x4U {
memarg: MemoryImmediate,
},
V128Load32x2S {
memarg: MemoryImmediate,
},
V128Load32x2U {
memarg: MemoryImmediate,
},
V128Load8Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Load16Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Load32Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Load64Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Store8Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Store16Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Store32Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
V128Store64Lane {
memarg: MemoryImmediate,
lane: SIMDLaneIndex,
},
I8x16RoundingAverageU,
I16x8RoundingAverageU,
I16x8Q15MulrSatS,
F32x4DemoteF64x2Zero,
F64x2PromoteLowF32x4,
F64x2ConvertLowI32x4S,
F64x2ConvertLowI32x4U,
I32x4TruncSatF64x2SZero,
I32x4TruncSatF64x2UZero,
I8x16Popcnt,
}