Enum wasmparser_nostd::Operator

source · [−]

pub enum Operator<'a> {
Show 533 variants    Unreachable,
    Nop,
    Block {
        ty: BlockType,
    },
    Loop {
        ty: BlockType,
    },
    If {
        ty: BlockType,
    },
    Else,
    Try {
        ty: BlockType,
    },
    Catch {
        tag_index: u32,
    },
    Throw {
        tag_index: u32,
    },
    Rethrow {
        relative_depth: u32,
    },
    End,
    Br {
        relative_depth: u32,
    },
    BrIf {
        relative_depth: u32,
    },
    BrTable {
        table: BrTable<'a>,
    },
    Return,
    Call {
        function_index: u32,
    },
    CallIndirect {
        type_index: u32,
        table_index: u32,
        table_byte: u8,
    },
    ReturnCall {
        function_index: u32,
    },
    ReturnCallIndirect {
        type_index: u32,
        table_index: u32,
    },
    Delegate {
        relative_depth: u32,
    },
    CatchAll,
    Drop,
    Select,
    TypedSelect {
        ty: ValType,
    },
    LocalGet {
        local_index: u32,
    },
    LocalSet {
        local_index: u32,
    },
    LocalTee {
        local_index: u32,
    },
    GlobalGet {
        global_index: u32,
    },
    GlobalSet {
        global_index: u32,
    },
    I32Load {
        memarg: MemArg,
    },
    I64Load {
        memarg: MemArg,
    },
    F32Load {
        memarg: MemArg,
    },
    F64Load {
        memarg: MemArg,
    },
    I32Load8S {
        memarg: MemArg,
    },
    I32Load8U {
        memarg: MemArg,
    },
    I32Load16S {
        memarg: MemArg,
    },
    I32Load16U {
        memarg: MemArg,
    },
    I64Load8S {
        memarg: MemArg,
    },
    I64Load8U {
        memarg: MemArg,
    },
    I64Load16S {
        memarg: MemArg,
    },
    I64Load16U {
        memarg: MemArg,
    },
    I64Load32S {
        memarg: MemArg,
    },
    I64Load32U {
        memarg: MemArg,
    },
    I32Store {
        memarg: MemArg,
    },
    I64Store {
        memarg: MemArg,
    },
    F32Store {
        memarg: MemArg,
    },
    F64Store {
        memarg: MemArg,
    },
    I32Store8 {
        memarg: MemArg,
    },
    I32Store16 {
        memarg: MemArg,
    },
    I64Store8 {
        memarg: MemArg,
    },
    I64Store16 {
        memarg: MemArg,
    },
    I64Store32 {
        memarg: MemArg,
    },
    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: ValType,
    },
    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 {
        dst: u32,
        src: 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: MemArg,
    },
    MemoryAtomicWait32 {
        memarg: MemArg,
    },
    MemoryAtomicWait64 {
        memarg: MemArg,
    },
    AtomicFence {
        flags: u8,
    },
    I32AtomicLoad {
        memarg: MemArg,
    },
    I64AtomicLoad {
        memarg: MemArg,
    },
    I32AtomicLoad8U {
        memarg: MemArg,
    },
    I32AtomicLoad16U {
        memarg: MemArg,
    },
    I64AtomicLoad8U {
        memarg: MemArg,
    },
    I64AtomicLoad16U {
        memarg: MemArg,
    },
    I64AtomicLoad32U {
        memarg: MemArg,
    },
    I32AtomicStore {
        memarg: MemArg,
    },
    I64AtomicStore {
        memarg: MemArg,
    },
    I32AtomicStore8 {
        memarg: MemArg,
    },
    I32AtomicStore16 {
        memarg: MemArg,
    },
    I64AtomicStore8 {
        memarg: MemArg,
    },
    I64AtomicStore16 {
        memarg: MemArg,
    },
    I64AtomicStore32 {
        memarg: MemArg,
    },
    I32AtomicRmwAdd {
        memarg: MemArg,
    },
    I64AtomicRmwAdd {
        memarg: MemArg,
    },
    I32AtomicRmw8AddU {
        memarg: MemArg,
    },
    I32AtomicRmw16AddU {
        memarg: MemArg,
    },
    I64AtomicRmw8AddU {
        memarg: MemArg,
    },
    I64AtomicRmw16AddU {
        memarg: MemArg,
    },
    I64AtomicRmw32AddU {
        memarg: MemArg,
    },
    I32AtomicRmwSub {
        memarg: MemArg,
    },
    I64AtomicRmwSub {
        memarg: MemArg,
    },
    I32AtomicRmw8SubU {
        memarg: MemArg,
    },
    I32AtomicRmw16SubU {
        memarg: MemArg,
    },
    I64AtomicRmw8SubU {
        memarg: MemArg,
    },
    I64AtomicRmw16SubU {
        memarg: MemArg,
    },
    I64AtomicRmw32SubU {
        memarg: MemArg,
    },
    I32AtomicRmwAnd {
        memarg: MemArg,
    },
    I64AtomicRmwAnd {
        memarg: MemArg,
    },
    I32AtomicRmw8AndU {
        memarg: MemArg,
    },
    I32AtomicRmw16AndU {
        memarg: MemArg,
    },
    I64AtomicRmw8AndU {
        memarg: MemArg,
    },
    I64AtomicRmw16AndU {
        memarg: MemArg,
    },
    I64AtomicRmw32AndU {
        memarg: MemArg,
    },
    I32AtomicRmwOr {
        memarg: MemArg,
    },
    I64AtomicRmwOr {
        memarg: MemArg,
    },
    I32AtomicRmw8OrU {
        memarg: MemArg,
    },
    I32AtomicRmw16OrU {
        memarg: MemArg,
    },
    I64AtomicRmw8OrU {
        memarg: MemArg,
    },
    I64AtomicRmw16OrU {
        memarg: MemArg,
    },
    I64AtomicRmw32OrU {
        memarg: MemArg,
    },
    I32AtomicRmwXor {
        memarg: MemArg,
    },
    I64AtomicRmwXor {
        memarg: MemArg,
    },
    I32AtomicRmw8XorU {
        memarg: MemArg,
    },
    I32AtomicRmw16XorU {
        memarg: MemArg,
    },
    I64AtomicRmw8XorU {
        memarg: MemArg,
    },
    I64AtomicRmw16XorU {
        memarg: MemArg,
    },
    I64AtomicRmw32XorU {
        memarg: MemArg,
    },
    I32AtomicRmwXchg {
        memarg: MemArg,
    },
    I64AtomicRmwXchg {
        memarg: MemArg,
    },
    I32AtomicRmw8XchgU {
        memarg: MemArg,
    },
    I32AtomicRmw16XchgU {
        memarg: MemArg,
    },
    I64AtomicRmw8XchgU {
        memarg: MemArg,
    },
    I64AtomicRmw16XchgU {
        memarg: MemArg,
    },
    I64AtomicRmw32XchgU {
        memarg: MemArg,
    },
    I32AtomicRmwCmpxchg {
        memarg: MemArg,
    },
    I64AtomicRmwCmpxchg {
        memarg: MemArg,
    },
    I32AtomicRmw8CmpxchgU {
        memarg: MemArg,
    },
    I32AtomicRmw16CmpxchgU {
        memarg: MemArg,
    },
    I64AtomicRmw8CmpxchgU {
        memarg: MemArg,
    },
    I64AtomicRmw16CmpxchgU {
        memarg: MemArg,
    },
    I64AtomicRmw32CmpxchgU {
        memarg: MemArg,
    },
    V128Load {
        memarg: MemArg,
    },
    V128Load8x8S {
        memarg: MemArg,
    },
    V128Load8x8U {
        memarg: MemArg,
    },
    V128Load16x4S {
        memarg: MemArg,
    },
    V128Load16x4U {
        memarg: MemArg,
    },
    V128Load32x2S {
        memarg: MemArg,
    },
    V128Load32x2U {
        memarg: MemArg,
    },
    V128Load8Splat {
        memarg: MemArg,
    },
    V128Load16Splat {
        memarg: MemArg,
    },
    V128Load32Splat {
        memarg: MemArg,
    },
    V128Load64Splat {
        memarg: MemArg,
    },
    V128Load32Zero {
        memarg: MemArg,
    },
    V128Load64Zero {
        memarg: MemArg,
    },
    V128Store {
        memarg: MemArg,
    },
    V128Load8Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Load16Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Load32Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Load64Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Store8Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Store16Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Store32Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Store64Lane {
        memarg: MemArg,
        lane: u8,
    },
    V128Const {
        value: V128,
    },
    I8x16Shuffle {
        lanes: [u8; 16],
    },
    I8x16ExtractLaneS {
        lane: u8,
    },
    I8x16ExtractLaneU {
        lane: u8,
    },
    I8x16ReplaceLane {
        lane: u8,
    },
    I16x8ExtractLaneS {
        lane: u8,
    },
    I16x8ExtractLaneU {
        lane: u8,
    },
    I16x8ReplaceLane {
        lane: u8,
    },
    I32x4ExtractLane {
        lane: u8,
    },
    I32x4ReplaceLane {
        lane: u8,
    },
    I64x2ExtractLane {
        lane: u8,
    },
    I64x2ReplaceLane {
        lane: u8,
    },
    F32x4ExtractLane {
        lane: u8,
    },
    F32x4ReplaceLane {
        lane: u8,
    },
    F64x2ExtractLane {
        lane: u8,
    },
    F64x2ReplaceLane {
        lane: u8,
    },
    I8x16Swizzle,
    I8x16Splat,
    I16x8Splat,
    I32x4Splat,
    I64x2Splat,
    F32x4Splat,
    F64x2Splat,
    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,
    I8x16Popcnt,
    I8x16AllTrue,
    I8x16Bitmask,
    I8x16NarrowI16x8S,
    I8x16NarrowI16x8U,
    I8x16Shl,
    I8x16ShrS,
    I8x16ShrU,
    I8x16Add,
    I8x16AddSatS,
    I8x16AddSatU,
    I8x16Sub,
    I8x16SubSatS,
    I8x16SubSatU,
    I8x16MinS,
    I8x16MinU,
    I8x16MaxS,
    I8x16MaxU,
    I8x16RoundingAverageU,
    I16x8ExtAddPairwiseI8x16S,
    I16x8ExtAddPairwiseI8x16U,
    I16x8Abs,
    I16x8Neg,
    I16x8Q15MulrSatS,
    I16x8AllTrue,
    I16x8Bitmask,
    I16x8NarrowI32x4S,
    I16x8NarrowI32x4U,
    I16x8ExtendLowI8x16S,
    I16x8ExtendHighI8x16S,
    I16x8ExtendLowI8x16U,
    I16x8ExtendHighI8x16U,
    I16x8Shl,
    I16x8ShrS,
    I16x8ShrU,
    I16x8Add,
    I16x8AddSatS,
    I16x8AddSatU,
    I16x8Sub,
    I16x8SubSatS,
    I16x8SubSatU,
    I16x8Mul,
    I16x8MinS,
    I16x8MinU,
    I16x8MaxS,
    I16x8MaxU,
    I16x8RoundingAverageU,
    I16x8ExtMulLowI8x16S,
    I16x8ExtMulHighI8x16S,
    I16x8ExtMulLowI8x16U,
    I16x8ExtMulHighI8x16U,
    I32x4ExtAddPairwiseI16x8S,
    I32x4ExtAddPairwiseI16x8U,
    I32x4Abs,
    I32x4Neg,
    I32x4AllTrue,
    I32x4Bitmask,
    I32x4ExtendLowI16x8S,
    I32x4ExtendHighI16x8S,
    I32x4ExtendLowI16x8U,
    I32x4ExtendHighI16x8U,
    I32x4Shl,
    I32x4ShrS,
    I32x4ShrU,
    I32x4Add,
    I32x4Sub,
    I32x4Mul,
    I32x4MinS,
    I32x4MinU,
    I32x4MaxS,
    I32x4MaxU,
    I32x4DotI16x8S,
    I32x4ExtMulLowI16x8S,
    I32x4ExtMulHighI16x8S,
    I32x4ExtMulLowI16x8U,
    I32x4ExtMulHighI16x8U,
    I64x2Abs,
    I64x2Neg,
    I64x2AllTrue,
    I64x2Bitmask,
    I64x2ExtendLowI32x4S,
    I64x2ExtendHighI32x4S,
    I64x2ExtendLowI32x4U,
    I64x2ExtendHighI32x4U,
    I64x2Shl,
    I64x2ShrS,
    I64x2ShrU,
    I64x2Add,
    I64x2Sub,
    I64x2Mul,
    I64x2ExtMulLowI32x4S,
    I64x2ExtMulHighI32x4S,
    I64x2ExtMulLowI32x4U,
    I64x2ExtMulHighI32x4U,
    F32x4Ceil,
    F32x4Floor,
    F32x4Trunc,
    F32x4Nearest,
    F32x4Abs,
    F32x4Neg,
    F32x4Sqrt,
    F32x4Add,
    F32x4Sub,
    F32x4Mul,
    F32x4Div,
    F32x4Min,
    F32x4Max,
    F32x4PMin,
    F32x4PMax,
    F64x2Ceil,
    F64x2Floor,
    F64x2Trunc,
    F64x2Nearest,
    F64x2Abs,
    F64x2Neg,
    F64x2Sqrt,
    F64x2Add,
    F64x2Sub,
    F64x2Mul,
    F64x2Div,
    F64x2Min,
    F64x2Max,
    F64x2PMin,
    F64x2PMax,
    I32x4TruncSatF32x4S,
    I32x4TruncSatF32x4U,
    F32x4ConvertI32x4S,
    F32x4ConvertI32x4U,
    I32x4TruncSatF64x2SZero,
    I32x4TruncSatF64x2UZero,
    F64x2ConvertLowI32x4S,
    F64x2ConvertLowI32x4U,
    F32x4DemoteF64x2Zero,
    F64x2PromoteLowF32x4,
    I8x16RelaxedSwizzle,
    I32x4RelaxedTruncSatF32x4S,
    I32x4RelaxedTruncSatF32x4U,
    I32x4RelaxedTruncSatF64x2SZero,
    I32x4RelaxedTruncSatF64x2UZero,
    F32x4RelaxedFma,
    F32x4RelaxedFnma,
    F64x2RelaxedFma,
    F64x2RelaxedFnma,
    I8x16RelaxedLaneselect,
    I16x8RelaxedLaneselect,
    I32x4RelaxedLaneselect,
    I64x2RelaxedLaneselect,
    F32x4RelaxedMin,
    F32x4RelaxedMax,
    F64x2RelaxedMin,
    F64x2RelaxedMax,
    I16x8RelaxedQ15mulrS,
    I16x8DotI8x16I7x16S,
    I32x4DotI8x16I7x16AddS,
    F32x4RelaxedDotBf16x8AddF32x4,
}

Expand description

Instructions as defined here.

Variants

`Unreachable`

`Nop`

`Block`

Fields

ty: BlockType

`Loop`

Fields

ty: BlockType

`If`

Fields

ty: BlockType

`Else`

`Try`

Fields

ty: BlockType

`Catch`

Fields

tag_index: u32

`Throw`

Fields

tag_index: u32

`Rethrow`

Fields

relative_depth: u32

`End`

`Br`

Fields

relative_depth: u32

`BrIf`

Fields

relative_depth: u32

`BrTable`

Fields

table: BrTable<'a>

`Return`

`Call`

Fields

function_index: u32

`CallIndirect`

Fields

type_index: u32

table_index: u32

table_byte: u8

`ReturnCall`

Fields

function_index: u32

`ReturnCallIndirect`

Fields

type_index: u32

table_index: u32

`Delegate`

Fields

relative_depth: u32

`CatchAll`

`Drop`

`Select`

`TypedSelect`

Fields

ty: ValType

`LocalGet`

Fields

local_index: u32

`LocalSet`

Fields

local_index: u32

`LocalTee`

Fields

local_index: u32

`GlobalGet`

Fields

global_index: u32

`GlobalSet`

Fields

global_index: u32

`I32Load`

Fields

memarg: MemArg

`I64Load`

Fields

memarg: MemArg

`F32Load`

Fields

memarg: MemArg

`F64Load`

Fields

memarg: MemArg

`I32Load8S`

Fields

memarg: MemArg

`I32Load8U`

Fields

memarg: MemArg

`I32Load16S`

Fields

memarg: MemArg

`I32Load16U`

Fields

memarg: MemArg

`I64Load8S`

Fields

memarg: MemArg

`I64Load8U`

Fields

memarg: MemArg

`I64Load16S`

Fields

memarg: MemArg

`I64Load16U`

Fields

memarg: MemArg

`I64Load32S`

Fields

memarg: MemArg

`I64Load32U`

Fields

memarg: MemArg

`I32Store`

Fields

memarg: MemArg

`I64Store`

Fields

memarg: MemArg

`F32Store`

Fields

memarg: MemArg

`F64Store`

Fields

memarg: MemArg

`I32Store8`

Fields

memarg: MemArg

`I32Store16`

Fields

memarg: MemArg

`I64Store8`

Fields

memarg: MemArg

`I64Store16`

Fields

memarg: MemArg

`I64Store32`

Fields

memarg: MemArg

`MemorySize`

Fields

mem: u32

mem_byte: u8

`MemoryGrow`

Fields

mem: u32

mem_byte: u8

`I32Const`

Fields

value: i32

`I64Const`

Fields

value: i64

`F32Const`

Fields

value: Ieee32

`F64Const`

Fields

value: Ieee64

`RefNull`

Fields

ty: ValType

`RefIsNull`

`RefFunc`

Fields

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`

Fields

segment: u32

mem: u32

`DataDrop`

Fields

segment: u32

`MemoryCopy`

Fields

dst: u32

src: u32

`MemoryFill`

Fields

mem: u32

`TableInit`

Fields

segment: u32

table: u32

`ElemDrop`

Fields

segment: u32

`TableCopy`

Fields

dst_table: u32

src_table: u32

`TableFill`

Fields

table: u32

`TableGet`

Fields

table: u32

`TableSet`

Fields

table: u32

`TableGrow`

Fields

table: u32

`TableSize`

Fields

table: u32

`MemoryAtomicNotify`

Fields

memarg: MemArg

`MemoryAtomicWait32`

Fields

memarg: MemArg

`MemoryAtomicWait64`

Fields

memarg: MemArg

`AtomicFence`

Fields

flags: u8

`I32AtomicLoad`

Fields

memarg: MemArg

`I64AtomicLoad`

Fields

memarg: MemArg

`I32AtomicLoad8U`

Fields

memarg: MemArg

`I32AtomicLoad16U`

Fields

memarg: MemArg

`I64AtomicLoad8U`

Fields

memarg: MemArg

`I64AtomicLoad16U`

Fields

memarg: MemArg

`I64AtomicLoad32U`

Fields

memarg: MemArg

`I32AtomicStore`

Fields

memarg: MemArg

`I64AtomicStore`

Fields

memarg: MemArg

`I32AtomicStore8`

Fields

memarg: MemArg

`I32AtomicStore16`

Fields

memarg: MemArg

`I64AtomicStore8`

Fields

memarg: MemArg

`I64AtomicStore16`

Fields

memarg: MemArg

`I64AtomicStore32`

Fields

memarg: MemArg

`I32AtomicRmwAdd`

Fields

memarg: MemArg

`I64AtomicRmwAdd`

Fields

memarg: MemArg

`I32AtomicRmw8AddU`

Fields

memarg: MemArg

`I32AtomicRmw16AddU`

Fields

memarg: MemArg

`I64AtomicRmw8AddU`

Fields

memarg: MemArg

`I64AtomicRmw16AddU`

Fields

memarg: MemArg

`I64AtomicRmw32AddU`

Fields

memarg: MemArg

`I32AtomicRmwSub`

Fields

memarg: MemArg

`I64AtomicRmwSub`

Fields

memarg: MemArg

`I32AtomicRmw8SubU`

Fields

memarg: MemArg

`I32AtomicRmw16SubU`

Fields

memarg: MemArg

`I64AtomicRmw8SubU`

Fields

memarg: MemArg

`I64AtomicRmw16SubU`

Fields

memarg: MemArg

`I64AtomicRmw32SubU`

Fields

memarg: MemArg

`I32AtomicRmwAnd`

Fields

memarg: MemArg

`I64AtomicRmwAnd`

Fields

memarg: MemArg

`I32AtomicRmw8AndU`

Fields

memarg: MemArg

`I32AtomicRmw16AndU`

Fields

memarg: MemArg

`I64AtomicRmw8AndU`

Fields

memarg: MemArg

`I64AtomicRmw16AndU`

Fields

memarg: MemArg

`I64AtomicRmw32AndU`

Fields

memarg: MemArg

`I32AtomicRmwOr`

Fields

memarg: MemArg

`I64AtomicRmwOr`

Fields

memarg: MemArg

`I32AtomicRmw8OrU`

Fields

memarg: MemArg

`I32AtomicRmw16OrU`

Fields

memarg: MemArg

`I64AtomicRmw8OrU`

Fields

memarg: MemArg

`I64AtomicRmw16OrU`

Fields

memarg: MemArg

`I64AtomicRmw32OrU`

Fields

memarg: MemArg

`I32AtomicRmwXor`

Fields

memarg: MemArg

`I64AtomicRmwXor`

Fields

memarg: MemArg

`I32AtomicRmw8XorU`

Fields

memarg: MemArg

`I32AtomicRmw16XorU`

Fields

memarg: MemArg

`I64AtomicRmw8XorU`

Fields

memarg: MemArg

`I64AtomicRmw16XorU`

Fields

memarg: MemArg

`I64AtomicRmw32XorU`

Fields

memarg: MemArg

`I32AtomicRmwXchg`

Fields

memarg: MemArg

`I64AtomicRmwXchg`

Fields

memarg: MemArg

`I32AtomicRmw8XchgU`

Fields

memarg: MemArg

`I32AtomicRmw16XchgU`

Fields

memarg: MemArg

`I64AtomicRmw8XchgU`

Fields

memarg: MemArg

`I64AtomicRmw16XchgU`

Fields

memarg: MemArg

`I64AtomicRmw32XchgU`

Fields

memarg: MemArg

`I32AtomicRmwCmpxchg`

Fields

memarg: MemArg

`I64AtomicRmwCmpxchg`

Fields

memarg: MemArg

`I32AtomicRmw8CmpxchgU`

Fields

memarg: MemArg

`I32AtomicRmw16CmpxchgU`

Fields

memarg: MemArg

`I64AtomicRmw8CmpxchgU`

Fields

memarg: MemArg

`I64AtomicRmw16CmpxchgU`

Fields

memarg: MemArg

`I64AtomicRmw32CmpxchgU`

Fields

memarg: MemArg

`V128Load`

Fields

memarg: MemArg

`V128Load8x8S`

Fields

memarg: MemArg

`V128Load8x8U`

Fields

memarg: MemArg

`V128Load16x4S`

Fields

memarg: MemArg

`V128Load16x4U`

Fields

memarg: MemArg

`V128Load32x2S`

Fields

memarg: MemArg

`V128Load32x2U`

Fields

memarg: MemArg

`V128Load8Splat`

Fields

memarg: MemArg

`V128Load16Splat`

Fields

memarg: MemArg

`V128Load32Splat`

Fields

memarg: MemArg

`V128Load64Splat`

Fields

memarg: MemArg

`V128Load32Zero`

Fields

memarg: MemArg

`V128Load64Zero`

Fields

memarg: MemArg

`V128Store`

Fields

memarg: MemArg

`V128Load8Lane`

Fields

memarg: MemArg

lane: u8

`V128Load16Lane`

Fields

memarg: MemArg

lane: u8

`V128Load32Lane`

Fields

memarg: MemArg

lane: u8

`V128Load64Lane`

Fields

memarg: MemArg

lane: u8

`V128Store8Lane`

Fields

memarg: MemArg

lane: u8

`V128Store16Lane`

Fields

memarg: MemArg

lane: u8

`V128Store32Lane`

Fields

memarg: MemArg

lane: u8

`V128Store64Lane`

Fields

memarg: MemArg

lane: u8

`V128Const`

Fields

value: V128

`I8x16Shuffle`

Fields

lanes: [u8; 16]

`I8x16ExtractLaneS`

Fields

lane: u8

`I8x16ExtractLaneU`

Fields

lane: u8

`I8x16ReplaceLane`

Fields

lane: u8

`I16x8ExtractLaneS`

Fields

lane: u8

`I16x8ExtractLaneU`

Fields

lane: u8

`I16x8ReplaceLane`

Fields

lane: u8

`I32x4ExtractLane`

Fields

lane: u8

`I32x4ReplaceLane`

Fields

lane: u8

`I64x2ExtractLane`

Fields

lane: u8

`I64x2ReplaceLane`

Fields

lane: u8

`F32x4ExtractLane`

Fields

lane: u8

`F32x4ReplaceLane`

Fields

lane: u8

`F64x2ExtractLane`

Fields

lane: u8

`F64x2ReplaceLane`

Fields

lane: u8

`I8x16Swizzle`

`I8x16Splat`

`I16x8Splat`

`I32x4Splat`

`I64x2Splat`

`F32x4Splat`

`F64x2Splat`

`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`

`I8x16Popcnt`

`I8x16AllTrue`

`I8x16Bitmask`

`I8x16NarrowI16x8S`

`I8x16NarrowI16x8U`

`I8x16Shl`

`I8x16ShrS`

`I8x16ShrU`

`I8x16Add`

`I8x16AddSatS`

`I8x16AddSatU`

`I8x16Sub`

`I8x16SubSatS`

`I8x16SubSatU`

`I8x16MinS`

`I8x16MinU`

`I8x16MaxS`

`I8x16MaxU`

`I8x16RoundingAverageU`

`I16x8ExtAddPairwiseI8x16S`

`I16x8ExtAddPairwiseI8x16U`

`I16x8Abs`

`I16x8Neg`

`I16x8Q15MulrSatS`

`I16x8AllTrue`

`I16x8Bitmask`

`I16x8NarrowI32x4S`

`I16x8NarrowI32x4U`

`I16x8ExtendLowI8x16S`

`I16x8ExtendHighI8x16S`

`I16x8ExtendLowI8x16U`

`I16x8ExtendHighI8x16U`

`I16x8Shl`

`I16x8ShrS`

`I16x8ShrU`

`I16x8Add`

`I16x8AddSatS`

`I16x8AddSatU`

`I16x8Sub`

`I16x8SubSatS`

`I16x8SubSatU`

`I16x8Mul`

`I16x8MinS`

`I16x8MinU`

`I16x8MaxS`

`I16x8MaxU`

`I16x8RoundingAverageU`

`I16x8ExtMulLowI8x16S`

`I16x8ExtMulHighI8x16S`

`I16x8ExtMulLowI8x16U`

`I16x8ExtMulHighI8x16U`

`I32x4ExtAddPairwiseI16x8S`

`I32x4ExtAddPairwiseI16x8U`

`I32x4Abs`

`I32x4Neg`

`I32x4AllTrue`

`I32x4Bitmask`

`I32x4ExtendLowI16x8S`

`I32x4ExtendHighI16x8S`

`I32x4ExtendLowI16x8U`

`I32x4ExtendHighI16x8U`

`I32x4Shl`

`I32x4ShrS`

`I32x4ShrU`

`I32x4Add`

`I32x4Sub`

`I32x4Mul`

`I32x4MinS`

`I32x4MinU`

`I32x4MaxS`

`I32x4MaxU`

`I32x4DotI16x8S`

`I32x4ExtMulLowI16x8S`

`I32x4ExtMulHighI16x8S`

`I32x4ExtMulLowI16x8U`

`I32x4ExtMulHighI16x8U`

`I64x2Abs`

`I64x2Neg`

`I64x2AllTrue`

`I64x2Bitmask`

`I64x2ExtendLowI32x4S`

`I64x2ExtendHighI32x4S`

`I64x2ExtendLowI32x4U`

`I64x2ExtendHighI32x4U`

`I64x2Shl`

`I64x2ShrS`

`I64x2ShrU`

`I64x2Add`

`I64x2Sub`

`I64x2Mul`

`I64x2ExtMulLowI32x4S`

`I64x2ExtMulHighI32x4S`

`I64x2ExtMulLowI32x4U`

`I64x2ExtMulHighI32x4U`

`F32x4Ceil`

`F32x4Floor`

`F32x4Trunc`

`F32x4Nearest`

`F32x4Abs`

`F32x4Neg`

`F32x4Sqrt`

`F32x4Add`

`F32x4Sub`

`F32x4Mul`

`F32x4Div`

`F32x4Min`

`F32x4Max`

`F32x4PMin`

`F32x4PMax`

`F64x2Ceil`

`F64x2Floor`

`F64x2Trunc`

`F64x2Nearest`

`F64x2Abs`

`F64x2Neg`

`F64x2Sqrt`

`F64x2Add`

`F64x2Sub`

`F64x2Mul`

`F64x2Div`

`F64x2Min`

`F64x2Max`

`F64x2PMin`

`F64x2PMax`

`I32x4TruncSatF32x4S`

`I32x4TruncSatF32x4U`

`F32x4ConvertI32x4S`

`F32x4ConvertI32x4U`

`I32x4TruncSatF64x2SZero`

`I32x4TruncSatF64x2UZero`

`F64x2ConvertLowI32x4S`

`F64x2ConvertLowI32x4U`

`F32x4DemoteF64x2Zero`

`F64x2PromoteLowF32x4`

`I8x16RelaxedSwizzle`

`I32x4RelaxedTruncSatF32x4S`

`I32x4RelaxedTruncSatF32x4U`

`I32x4RelaxedTruncSatF64x2SZero`

`I32x4RelaxedTruncSatF64x2UZero`

`F32x4RelaxedFma`

`F32x4RelaxedFnma`

`F64x2RelaxedFma`

`F64x2RelaxedFnma`

`I8x16RelaxedLaneselect`

`I16x8RelaxedLaneselect`

`I32x4RelaxedLaneselect`

`I64x2RelaxedLaneselect`

`F32x4RelaxedMin`

`F32x4RelaxedMax`

`F64x2RelaxedMin`

`F64x2RelaxedMax`

`I16x8RelaxedQ15mulrS`

`I16x8DotI8x16I7x16S`

`I32x4DotI8x16I7x16AddS`

`F32x4RelaxedDotBf16x8AddF32x4`

Trait Implementations

source

impl<'a> Clone for Operator<'a>

source

fn clone(&self) -> Operator<'a>

Returns a copy of the value. Read more

1.0.0 · source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

source

impl<'a> Debug for Operator<'a>

source

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl<'a> RefUnwindSafe for Operator<'a>

impl<'a> Send for Operator<'a>

impl<'a> Sync for Operator<'a>

impl<'a> Unpin for Operator<'a>

impl<'a> UnwindSafe for Operator<'a>

Blanket Implementations

source

impl<T> Any for Twhere
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.