Enum NumericInstruction

Source

pub enum NumericInstruction {
Show 53 variants
    I32Constant(i32),
    I64Constant(i64),
    F32Constant(f32),
    F64Constant(f64),
    CountLeadingZeros(IntegerType),
    CountTrailingZeros(IntegerType),
    CountOnes(IntegerType),
    AbsoluteValue(FloatType),
    Negate(FloatType),
    SquareRoot(FloatType),
    Ceiling(FloatType),
    Floor(FloatType),
    Truncate(FloatType),
    Nearest(FloatType),
    Add(NumberType),
    Subtract(NumberType),
    Multiply(NumberType),
    DivideInteger(IntegerType, SignExtension),
    DivideFloat(FloatType),
    Remainder(IntegerType, SignExtension),
    And(IntegerType),
    Or(IntegerType),
    Xor(IntegerType),
    ShiftLeft(IntegerType),
    ShiftRight(IntegerType, SignExtension),
    RotateLeft(IntegerType),
    RotateRight(IntegerType),
    Minimum(FloatType),
    Maximum(FloatType),
    CopySign(FloatType),
    EqualToZero(IntegerType),
    Equal(NumberType),
    NotEqual(NumberType),
    LessThanInteger(IntegerType, SignExtension),
    LessThanFloat(FloatType),
    GreaterThanInteger(IntegerType, SignExtension),
    GreaterThanFloat(FloatType),
    LessThanOrEqualToInteger(IntegerType, SignExtension),
    LessThanOrEqualToFloat(FloatType),
    GreaterThanOrEqualToInteger(IntegerType, SignExtension),
    GreaterThanOrEqualToFloat(FloatType),
    ExtendSigned8(IntegerType),
    ExtendSigned16(IntegerType),
    ExtendSigned32,
    Wrap,
    ExtendWithSignExtension(SignExtension),
    ConvertAndTruncate(IntegerType, FloatType, SignExtension),
    ConvertAndTruncateWithSaturation(IntegerType, FloatType, SignExtension),
    Demote,
    Promote,
    Convert(FloatType, IntegerType, SignExtension),
    ReinterpretFloat(IntegerType),
    ReinterpretInteger(FloatType),
}

Expand description

Numeric instructions provide basic operations over numeric values of specific type. These operations closely match respective operations available in hardware.

Some integer instructions come in two flavors, where a signedness annotation sx distinguishes whether the operands are to be interpreted as unsigned or signed integers. For the other integer instructions, the use of two’s complement for the signed interpretation means that they behave the same regardless of signedness.

See https://webassembly.github.io/spec/core/syntax/instructions.html#numeric-instructions

§Examples

§Constant

use wasm_ast::{NumericInstruction, Instruction};

assert_eq!(
    Instruction::Numeric(NumericInstruction::I32Constant(42)),
    42i32.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::I64Constant(42i64)),
    42i64.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::F32Constant(0.1)),
    0.1f32.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::F64Constant(0.2)),
    0.2f64.into()
);

§Integer

use wasm_ast::{NumericInstruction, Instruction, IntegerType, SignExtension};

assert_eq!(
    Instruction::Numeric(NumericInstruction::CountLeadingZeros(IntegerType::I32)),
    NumericInstruction::CountLeadingZeros(IntegerType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::CountTrailingZeros(IntegerType::I64)),
    NumericInstruction::CountTrailingZeros(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::CountOnes(IntegerType::I64)),
    NumericInstruction::CountOnes(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::DivideInteger(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::DivideInteger(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Remainder(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::Remainder(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::And(IntegerType::I64)),
    NumericInstruction::And(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Or(IntegerType::I64)),
    NumericInstruction::Or(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Xor(IntegerType::I64)),
    NumericInstruction::Xor(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ShiftLeft(IntegerType::I64)),
    NumericInstruction::ShiftLeft(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ShiftRight(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::ShiftRight(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::RotateLeft(IntegerType::I64)),
    NumericInstruction::RotateLeft(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::RotateRight(IntegerType::I64)),
    NumericInstruction::RotateRight(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::EqualToZero(IntegerType::I64)),
    NumericInstruction::EqualToZero(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::LessThanInteger(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::LessThanInteger(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::GreaterThanInteger(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::GreaterThanInteger(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::LessThanOrEqualToInteger(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::LessThanOrEqualToInteger(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::GreaterThanOrEqualToInteger(IntegerType::I64, SignExtension::Unsigned)),
    NumericInstruction::GreaterThanOrEqualToInteger(IntegerType::I64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ExtendSigned8(IntegerType::I64)),
    NumericInstruction::ExtendSigned8(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ExtendSigned16(IntegerType::I64)),
    NumericInstruction::ExtendSigned16(IntegerType::I64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ExtendSigned32),
    NumericInstruction::ExtendSigned32.into()
);

§Float

use wasm_ast::{NumericInstruction, Instruction, FloatType};

assert_eq!(
    Instruction::Numeric(NumericInstruction::AbsoluteValue(FloatType::F32)),
    NumericInstruction::AbsoluteValue(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Negate(FloatType::F64)),
    NumericInstruction::Negate(FloatType::F64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::SquareRoot(FloatType::F64)),
    NumericInstruction::SquareRoot(FloatType::F64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Ceiling(FloatType::F32)),
    NumericInstruction::Ceiling(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Floor(FloatType::F64)),
    NumericInstruction::Floor(FloatType::F64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Truncate(FloatType::F64)),
    NumericInstruction::Truncate(FloatType::F64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Nearest(FloatType::F64)),
    NumericInstruction::Nearest(FloatType::F64).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::DivideFloat(FloatType::F32)),
    NumericInstruction::DivideFloat(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Minimum(FloatType::F32)),
    NumericInstruction::Minimum(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Maximum(FloatType::F32)),
    NumericInstruction::Maximum(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::CopySign(FloatType::F32)),
    NumericInstruction::CopySign(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::LessThanFloat(FloatType::F32)),
    NumericInstruction::LessThanFloat(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::GreaterThanFloat(FloatType::F32)),
    NumericInstruction::GreaterThanFloat(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::LessThanOrEqualToFloat(FloatType::F32)),
    NumericInstruction::LessThanOrEqualToFloat(FloatType::F32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::GreaterThanOrEqualToFloat(FloatType::F32)),
    NumericInstruction::GreaterThanOrEqualToFloat(FloatType::F32).into()
);

§Number

use wasm_ast::{NumericInstruction, Instruction, NumberType};

assert_eq!(
    Instruction::Numeric(NumericInstruction::Add(NumberType::I32)),
    NumericInstruction::Add(NumberType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Subtract(NumberType::I32)),
    NumericInstruction::Subtract(NumberType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Multiply(NumberType::I32)),
    NumericInstruction::Multiply(NumberType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Equal(NumberType::I32)),
    NumericInstruction::Equal(NumberType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::NotEqual(NumberType::I32)),
    NumericInstruction::NotEqual(NumberType::I32).into()
);

§Convert

use wasm_ast::{NumericInstruction, Instruction, NumberType, SignExtension, IntegerType, FloatType};

assert_eq!(
    Instruction::Numeric(NumericInstruction::Wrap),
    NumericInstruction::Wrap.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ExtendWithSignExtension(SignExtension::Signed)),
    NumericInstruction::ExtendWithSignExtension(SignExtension::Signed).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ConvertAndTruncate(IntegerType::I32, FloatType::F64, SignExtension::Unsigned)),
    NumericInstruction::ConvertAndTruncate(IntegerType::I32, FloatType::F64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ConvertAndTruncateWithSaturation(IntegerType::I32, FloatType::F64, SignExtension::Unsigned)),
    NumericInstruction::ConvertAndTruncateWithSaturation(IntegerType::I32, FloatType::F64, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Demote),
    NumericInstruction::Demote.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Promote),
    NumericInstruction::Promote.into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::Convert(FloatType::F64, IntegerType::I32, SignExtension::Unsigned)),
    NumericInstruction::Convert(FloatType::F64, IntegerType::I32, SignExtension::Unsigned).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ReinterpretFloat(IntegerType::I32)),
    NumericInstruction::ReinterpretFloat(IntegerType::I32).into()
);
assert_eq!(
    Instruction::Numeric(NumericInstruction::ReinterpretInteger(FloatType::F64)),
    NumericInstruction::ReinterpretInteger(FloatType::F64).into()
);