Skip to content

'vm' Dialectlink

A dialect representing operations against an abstract virtual machine.

The virtual machine ops are designed to be either serialized to a bytecode representation that can be interpreted at runtime or lowered further to static representations such as LLVM IR, C, etc. The idea is that the types and operations performed are generally just encoding resource ownership rules and control flow that can be represented in many different ways by target runtimes. For example, it should be possible to lower the VM dialect to SPIR-V and run the VM entirely within a persistent Vulkan kernel.

With this scalable runtime approach we make some limiting assumptions to keep the required implementations simple. As we assume all real math is happening within dispatch regions the only math we provide is scalar operations used for offset and shape calculations. This also enables simple flow control such as fixed-range loops.

Besides integer values the only other storage type is a variant reference modeling an abstract iree_vm_ref_t. This allows automated reference counting to be relied upon by other dialects built on top of the VM dialect and avoids the need for more verbose manual reference counting logic (that may be difficult or impossible to manage given the coroutine-like nature of the VM). Lowering targets can insert the reference counting as needed.

The types in the VM dialect correspond to the storage rather than value type, with the interpretation of the type encoded on the op.

Operationslink

Async/fiber opslink

vm.yield (VM::YieldOp)link

Unconditional fiber yield operation

Syntax:

operation ::= `vm.yield` $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict

Yields the fiber for some (likely short) amount of time. This can be used to perform cooperative scheduling and ensure fair (enough) execution. Execution resumes at the specified target branch.

^bb0: vm.yield ^on_resume ^on_resume: ...

Traits: HasParent<IREE::VM::FuncOp>, Terminator, Util_YieldPoint

Interfaces: BranchOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
destOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
dest any successor

Bitwise shift and rotate opslink

vm.shl.i32 (VM::ShlI32Op)link

Integer shift left operation

Syntax:

operation ::= `vm.shl.i32` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.shl.i64 (VM::ShlI64Op)link

Integer shift left operation

Syntax:

operation ::= `vm.shl.i64` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.shr.i32.s (VM::ShrI32SOp)link

Signed integer (arithmetic) shift right operation

Syntax:

operation ::= `vm.shr.i32.s` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.shr.i32.u (VM::ShrI32UOp)link

Unsigned integer (logical) shift right operation

Syntax:

operation ::= `vm.shr.i32.u` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.shr.i64.s (VM::ShrI64SOp)link

Signed integer (arithmetic) shift right operation

Syntax:

operation ::= `vm.shr.i64.s` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.shr.i64.u (VM::ShrI64UOp)link

Unsigned integer (logical) shift right operation

Syntax:

operation ::= `vm.shr.i64.u` $operand `,` $amount attr-dict `:` type($operand)

Shifts the operand in a direction by the number of bits specified.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
amount 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

Buffer opslink

vm.buffer.alloc (VM::BufferAllocOp)link

Allocates a new zero-initialized buffer

Syntax:

operation ::= `vm.buffer.alloc` operands attr-dict `:` type($result)

Allocates a new zero-initialized buffer with the given size in bytes.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Allocate on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
length 64-bit signless integer
alignment 32-bit signless integer
Results:link
Result Description
result ref

vm.buffer.clone (VM::BufferCloneOp)link

Clones a buffer

Syntax:

operation ::= `vm.buffer.clone` operands attr-dict `:` type($source_buffer) `->` type($result)

Clones a range of the source buffer to produce a mutable buffer with the same contents.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Allocate on ::mlir::SideEffects::DefaultResource, MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
length 64-bit signless integer
alignment 32-bit signless integer
Results:link
Result Description
result ref

vm.buffer.compare (VM::BufferCompareOp)link

Compares a range of a buffer to another

Syntax:

operation ::= `vm.buffer.compare` operands attr-dict `:` type($lhs_buffer) `,` type($rhs_buffer)

Returns 1 if the two ranges are bitwise equivalent, somewhat like memcmp.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource, MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
lhs_buffer ref
lhs_offset 64-bit signless integer
rhs_buffer ref
rhs_offset 64-bit signless integer
length 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.buffer.copy (VM::BufferCopyOp)link

Copies a range of a buffer to another

Syntax:

operation ::= `vm.buffer.copy` operands attr-dict `:` type($source_buffer) `->` type($target_buffer)

Copies a range of one buffer to another, like memcpy.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource, MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer

vm.buffer.fill.f32 (VM::BufferFillF32Op)link

Fills the buffer with the given repeating 32-bit value

Syntax:

operation ::= `vm.buffer.fill.f32` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 32-bit float or 32-bit signless integer

vm.buffer.fill.f64 (VM::BufferFillF64Op)link

Fills the buffer with the given repeating 64-bit value

Syntax:

operation ::= `vm.buffer.fill.f64` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 64-bit float or 32-bit signless integer

vm.buffer.fill.i16 (VM::BufferFillI16Op)link

Fills the buffer with the given repeating 16-bit value

Syntax:

operation ::= `vm.buffer.fill.i16` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 16-bit signless integer or 32-bit signless integer

vm.buffer.fill.i32 (VM::BufferFillI32Op)link

Fills the buffer with the given repeating 32-bit value

Syntax:

operation ::= `vm.buffer.fill.i32` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 32-bit signless integer or 32-bit signless integer

vm.buffer.fill.i64 (VM::BufferFillI64Op)link

Fills the buffer with the given repeating 64-bit value

Syntax:

operation ::= `vm.buffer.fill.i64` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 64-bit signless integer or 32-bit signless integer

vm.buffer.fill.i8 (VM::BufferFillI8Op)link

Fills the buffer with the given repeating 8-bit value

Syntax:

operation ::= `vm.buffer.fill.i8` $target_buffer `,` $target_offset `,` $length `,` $value
              attr-dict `:` type($value) `->` type($target_buffer)

Fills an element range of the buffer with the given value, like memset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
length 64-bit signless integer
value 8-bit signless integer or 32-bit signless integer

vm.buffer.hash (VM::BufferHashOp)link

Syntax:

operation ::= `vm.buffer.hash` $source_buffer `,` $source_offset `,` $length
              attr-dict `:` type($source_buffer) `->` type($result)

Computes the SipHash-2-4 of the source buffer at the given offset for |length| bytes using seed 0x0001020304...0e0f.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
length 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.buffer.length (VM::BufferLengthOp)link

Returns the byte length of a buffer

Syntax:

operation ::= `vm.buffer.length` operands attr-dict `:` type($buffer) `->` type($result)

Returns the total byte length of the given buffer. This is the exact value as specified during buffer allocation though the underlying system buffer may have additional padding.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
buffer ref
Results:link
Result Description
result 64-bit signless integer

vm.buffer.load.f32 (VM::BufferLoadF32Op)link

32-bit floating-point load

Syntax:

operation ::= `vm.buffer.load.f32` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit float or 32-bit signless integer

vm.buffer.load.f64 (VM::BufferLoadF64Op)link

64-bit floating-point load

Syntax:

operation ::= `vm.buffer.load.f64` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 64-bit float or 32-bit signless integer

vm.buffer.load.i16.s (VM::BufferLoadI16SOp)link

Signed 16-bit integer load

Syntax:

operation ::= `vm.buffer.load.i16.s` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer or 32-bit signless integer

vm.buffer.load.i16.u (VM::BufferLoadI16UOp)link

Unsigned 16-bit integer load

Syntax:

operation ::= `vm.buffer.load.i16.u` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer or 32-bit signless integer

vm.buffer.load.i32 (VM::BufferLoadI32Op)link

32-bit integer load

Syntax:

operation ::= `vm.buffer.load.i32` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer or 32-bit signless integer

vm.buffer.load.i64 (VM::BufferLoadI64Op)link

64-bit integer load

Syntax:

operation ::= `vm.buffer.load.i64` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer or 32-bit signless integer

vm.buffer.load.i8.s (VM::BufferLoadI8SOp)link

Signed 8-bit integer load

Syntax:

operation ::= `vm.buffer.load.i8.s` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer or 32-bit signless integer

vm.buffer.load.i8.u (VM::BufferLoadI8UOp)link

Unsigned 8-bit integer load

Syntax:

operation ::= `vm.buffer.load.i8.u` $source_buffer `[` $source_offset `]`
              attr-dict `:` type($source_buffer) `->` type($result)

Loads a value from the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
source_buffer ref
source_offset 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer or 32-bit signless integer

vm.buffer.store.f32 (VM::BufferStoreF32Op)link

32-bit floating-point store

Syntax:

operation ::= `vm.buffer.store.f32` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 32-bit float or 32-bit signless integer

vm.buffer.store.f64 (VM::BufferStoreF64Op)link

64-bit floating-point store

Syntax:

operation ::= `vm.buffer.store.f64` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 64-bit float or 32-bit signless integer

vm.buffer.store.i16 (VM::BufferStoreI16Op)link

Unsigned 16-bit integer store

Syntax:

operation ::= `vm.buffer.store.i16` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 32-bit signless integer or 32-bit signless integer

vm.buffer.store.i32 (VM::BufferStoreI32Op)link

32-bit integer store

Syntax:

operation ::= `vm.buffer.store.i32` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 32-bit signless integer or 32-bit signless integer

vm.buffer.store.i64 (VM::BufferStoreI64Op)link

64-bit integer store

Syntax:

operation ::= `vm.buffer.store.i64` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 64-bit signless integer or 32-bit signless integer

vm.buffer.store.i8 (VM::BufferStoreI8Op)link

Unsigned 8-bit integer store

Syntax:

operation ::= `vm.buffer.store.i8` $value `,` $target_buffer `[` $target_offset `]`
              attr-dict `:` type($value) `->` type($target_buffer)

Stores a value to the buffer at the given element offset.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
target_buffer ref
target_offset 64-bit signless integer
value 32-bit signless integer or 32-bit signless integer

Casting and conversion opslink

Casting and type conversion/emulation.

vm.bitcast.f32.i32 (VM::BitcastF32I32Op)link

Bitcast from a 32-bit float-point value to a 32-bit integer

Syntax:

operation ::= `vm.bitcast.f32.i32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.bitcast.f64.i64 (VM::BitcastF64I64Op)link

Bitcast from a 64-bit float-point value to a 64-bit integer

Syntax:

operation ::= `vm.bitcast.f64.i64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit signless integer

vm.bitcast.i32.f32 (VM::BitcastI32F32Op)link

Bitcast from a 32-bit integer to a 32-bit float-point value

Syntax:

operation ::= `vm.bitcast.i32.f32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit float

vm.bitcast.i64.f64 (VM::BitcastI64F64Op)link

Bitcast from a 64-bit integer to a 64-bit float-point value

Syntax:

operation ::= `vm.bitcast.i64.f64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit float

vm.cast.any.ref (VM::CastAnyRefOp)link

Casts from any ref to a specific ref type

Syntax:

operation ::= `vm.cast.any.ref` $operand attr-dict `:` type($operand) `->` type($result)

Performs a runtime cast of an opaque !vm.ref<?> to a specific !vm.ref<T> and raises an error if the operand does not match the expected type. Null refs can always be cast between types.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand ref
Results:link
Result Description
result ref

vm.cast.f32.si32 (VM::CastF32SI32Op)link

Cast from a float-point value to a signed 32-bit integer

Syntax:

operation ::= `vm.cast.f32.si32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cast.f32.si64 (VM::CastF32SI64Op)link

Cast from a float-point value to a signed 64-bit integer

Syntax:

operation ::= `vm.cast.f32.si64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 64-bit signless integer

vm.cast.f32.ui32 (VM::CastF32UI32Op)link

Cast from an float-point value to an unsigned 32-bit integer

Syntax:

operation ::= `vm.cast.f32.ui32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cast.f32.ui64 (VM::CastF32UI64Op)link

Cast from an float-point value to an unsigned 64-bit integer

Syntax:

operation ::= `vm.cast.f32.ui64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 64-bit signless integer

vm.cast.f64.si64 (VM::CastF64SI64Op)link

Cast from a float-point value to a signed integer

Syntax:

operation ::= `vm.cast.f64.si64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit signless integer

vm.cast.f64.ui64 (VM::CastF64UI64Op)link

Cast from an float-point value to an unsigned integer

Syntax:

operation ::= `vm.cast.f64.ui64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit signless integer

vm.cast.ref.any (VM::CastRefAnyOp)link

Casts from a specific ref to any ref type

Syntax:

operation ::= `vm.cast.ref.any` $operand attr-dict `:` type($operand) `->` type($result)

Performs a compile-time widening cast of a specific !vm.ref<T> to an opaque !vm.ref<?>.

Traits: AlwaysSpeculatableImplTrait, VM_AssignmentOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand ref
Results:link
Result Description
result ref

vm.cast.si32.f32 (VM::CastSI32F32Op)link

Cast from a signed integer to a float-point value

Syntax:

operation ::= `vm.cast.si32.f32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit float

vm.cast.si64.f32 (VM::CastSI64F32Op)link

Cast from a signed integer to a float-point value

Syntax:

operation ::= `vm.cast.si64.f32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 32-bit float

vm.cast.si64.f64 (VM::CastSI64F64Op)link

Cast from a signed integer to a float-point value

Syntax:

operation ::= `vm.cast.si64.f64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit float

vm.cast.ui32.f32 (VM::CastUI32F32Op)link

Cast from an unsigned integer to a float-point value

Syntax:

operation ::= `vm.cast.ui32.f32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit float

vm.cast.ui64.f64 (VM::CastUI64F64Op)link

Cast from an unsigned integer to a float-point value

Syntax:

operation ::= `vm.cast.ui64.f64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit float

vm.ext.f32.f64 (VM::ExtF32F64Op)link

Floating-point zero extend 32 bits to 64 bits

Syntax:

operation ::= `vm.ext.f32.f64` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 64-bit float

vm.ext.i16.i32.s (VM::ExtI16I32SOp)link

Integer sign extend 16 bits to 32 bits

Syntax:

operation ::= `vm.ext.i16.i32.s` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.ext.i16.i32.u (VM::ExtI16I32UOp)link

Integer zero extend 16 bits to 32 bits

Syntax:

operation ::= `vm.ext.i16.i32.u` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.ext.i16.i64.s (VM::ExtI16I64SOp)link

Integer sign extend 16 bits to 64 bits

Syntax:

operation ::= `vm.ext.i16.i64.s` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ext.i16.i64.u (VM::ExtI16I64UOp)link

Integer zero extend 16 bits to 64 bits

Syntax:

operation ::= `vm.ext.i16.i64.u` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ext.i32.i64.s (VM::ExtI32I64SOp)link

Integer sign extend 32 bits to 64 bits

Syntax:

operation ::= `vm.ext.i32.i64.s` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ext.i32.i64.u (VM::ExtI32I64UOp)link

Integer zero extend 32 bits to 64 bits

Syntax:

operation ::= `vm.ext.i32.i64.u` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ext.i8.i32.s (VM::ExtI8I32SOp)link

Integer sign extend 8 bits to 32 bits

Syntax:

operation ::= `vm.ext.i8.i32.s` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.ext.i8.i32.u (VM::ExtI8I32UOp)link

Integer zero extend 8 bits to 32 bits

Syntax:

operation ::= `vm.ext.i8.i32.u` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.ext.i8.i64.s (VM::ExtI8I64SOp)link

Integer sign extend 8 bits to 64 bits

Syntax:

operation ::= `vm.ext.i8.i64.s` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ext.i8.i64.u (VM::ExtI8I64UOp)link

Integer zero extend 8 bits to 64 bits

Syntax:

operation ::= `vm.ext.i8.i64.u` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.trunc.f64.f32 (VM::TruncF64F32Op)link

Floating-point truncate to 32 bits

Syntax:

operation ::= `vm.trunc.f64.f32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 32-bit float

vm.trunc.i16.i8 (VM::TruncI16I8Op)link

Integer truncate to 8 bits

Syntax:

operation ::= `vm.trunc.i16.i8` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.trunc.i32.i16 (VM::TruncI32I16Op)link

Integer truncate to 16 bits

Syntax:

operation ::= `vm.trunc.i32.i16` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.trunc.i32.i8 (VM::TruncI32I8Op)link

Integer truncate to 8 bits

Syntax:

operation ::= `vm.trunc.i32.i8` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.trunc.i64.i16 (VM::TruncI64I16Op)link

Integer truncate to 16 bits

Syntax:

operation ::= `vm.trunc.i64.i16` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.trunc.i64.i32 (VM::TruncI64I32Op)link

Integer truncate to 32 bits

Syntax:

operation ::= `vm.trunc.i64.i32` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.trunc.i64.i8 (VM::TruncI64I8Op)link

Integer truncate to 8 bits

Syntax:

operation ::= `vm.trunc.i64.i8` $operand attr-dict `:` type($operand) `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

Comparison opslink

vm.cmp.eq.i32 (VM::CmpEQI32Op)link

Integer equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.i32` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.i64 (VM::CmpEQI64Op)link

Integer equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.i64` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.i32.s (VM::CmpGTEI32SOp)link

Signed integer greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.i32.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.i32.u (VM::CmpGTEI32UOp)link

Unsigned integer greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.i32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.i64.s (VM::CmpGTEI64SOp)link

Signed integer greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.i64.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.i64.u (VM::CmpGTEI64UOp)link

Unsigned integer greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.i64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.i32.s (VM::CmpGTI32SOp)link

Signed integer greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.i32.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.i32.u (VM::CmpGTI32UOp)link

Unsigned integer greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.i32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.i64.s (VM::CmpGTI64SOp)link

Signed integer greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.i64.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.i64.u (VM::CmpGTI64UOp)link

Unsigned integer greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.i64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.i32.s (VM::CmpLTEI32SOp)link

Signed integer less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.i32.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.i32.u (VM::CmpLTEI32UOp)link

Unsigned integer less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.i32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.i64.s (VM::CmpLTEI64SOp)link

Signed integer less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.i64.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.i64.u (VM::CmpLTEI64UOp)link

Unsigned integer less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.i64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.i32.s (VM::CmpLTI32SOp)link

Signed integer less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.i32.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.i32.u (VM::CmpLTI32UOp)link

Unsigned integer less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.i32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.i64.s (VM::CmpLTI64SOp)link

Signed integer less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.i64.s` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.i64.u (VM::CmpLTI64UOp)link

Unsigned integer less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.i64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.i32 (VM::CmpNEI32Op)link

Integer inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.i32` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.i64 (VM::CmpNEI64Op)link

Integer inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.i64` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.i32 (VM::CmpNZI32Op)link

Integer non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.i32` $operand attr-dict `:` type($operand)

Compares the given integer operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.i64 (VM::CmpNZI64Op)link

Integer non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.i64` $operand attr-dict `:` type($operand)

Compares the given integer operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 32-bit signless integer

Conditional assignment opslink

vm.select.f32 (VM::SelectF32Op)link

Floating-point select operation

Syntax:

operation ::= `vm.select.f32` operands attr-dict `:` type($result)

Chooses one value based on a binary condition supplied as its first operand. If the value of the condition is true the true_value operand is chosen, otherwise the false_value operand is chosen. The true and false values must have the same types. For example, the maximum operation is obtained by combining "select" with "cmpi" as follows:

%2 = vm.cmp.gt.i32.s %0, %1 : i32
%3 = vm.select.i32 %2, %0, %1 : i32

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
condition 32-bit signless integer
true_value 32-bit float
false_value 32-bit float
Results:link
Result Description
result 32-bit float

vm.select.f64 (VM::SelectF64Op)link

Floating-point select operation

Syntax:

operation ::= `vm.select.f64` operands attr-dict `:` type($result)

Chooses one value based on a binary condition supplied as its first operand. If the value of the condition is true the true_value operand is chosen, otherwise the false_value operand is chosen. The true and false values must have the same types. For example, the maximum operation is obtained by combining "select" with "cmpi" as follows:

%2 = vm.cmp.gt.i32.s %0, %1 : i32
%3 = vm.select.i32 %2, %0, %1 : i32

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
condition 32-bit signless integer
true_value 64-bit float
false_value 64-bit float
Results:link
Result Description
result 64-bit float

vm.select.i32 (VM::SelectI32Op)link

Integer select operation

Syntax:

operation ::= `vm.select.i32` operands attr-dict `:` type($result)

Chooses one value based on a binary condition supplied as its first operand. If the value of the condition is true the true_value operand is chosen, otherwise the false_value operand is chosen. The true and false values must have the same types. For example, the maximum operation is obtained by combining "select" with "cmpi" as follows:

%2 = vm.cmp.gt.i32.s %0, %1 : i32
%3 = vm.select.i32 %2, %0, %1 : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
condition 32-bit signless integer
true_value 32-bit signless integer
false_value 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.select.i64 (VM::SelectI64Op)link

Integer select operation

Syntax:

operation ::= `vm.select.i64` operands attr-dict `:` type($result)

Chooses one value based on a binary condition supplied as its first operand. If the value of the condition is true the true_value operand is chosen, otherwise the false_value operand is chosen. The true and false values must have the same types. For example, the maximum operation is obtained by combining "select" with "cmpi" as follows:

%2 = vm.cmp.gt.i32.s %0, %1 : i32
%3 = vm.select.i32 %2, %0, %1 : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
condition 32-bit signless integer
true_value 64-bit signless integer
false_value 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.select.ref (VM::SelectRefOp)link

Ref select operation

Syntax:

operation ::= `vm.select.ref` operands attr-dict `:` type($result)

Chooses one value based on a binary condition supplied as its first operand. If the value of the condition is true the true_value operand is chosen, otherwise the false_value operand is chosen.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
condition 32-bit signless integer
true_value ref
false_value ref
Results:link
Result Description
result ref

vm.switch.f32 (VM::SwitchF32Op)link

Floating-point switch operation

Syntax:

operation ::= `vm.switch.f32` $index `[` $values `]` `else` $default_value attr-dict `:` type($result)

Returns the value with the given index in values or default_value if the index is out of bounds.

// Switch %index to cases of %c100/%c200/%c300 if index==0, ==1, ==2.
// If %index is out of range (<0 or >2) then default to %c5.
%0 = vm.switch.f32 %index[%c100, %c200, %c300] else %c5 : f32

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
index 32-bit signless integer
default_value 32-bit float
values variadic of 32-bit float
Results:link
Result Description
result 32-bit float

vm.switch.f64 (VM::SwitchF64Op)link

Floating-point switch operation

Syntax:

operation ::= `vm.switch.f64` $index `[` $values `]` `else` $default_value attr-dict `:` type($result)

Returns the value with the given index in values or default_value if the index is out of bounds.

// Switch %index to cases of %c100/%c200/%c300 if index==0, ==1, ==2.
// If %index is out of range (<0 or >2) then default to %c5.
%0 = vm.switch.f32 %index[%c100, %c200, %c300] else %c5 : f32

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
index 32-bit signless integer
default_value 64-bit float
values variadic of 64-bit float
Results:link
Result Description
result 64-bit float

vm.switch.i32 (VM::SwitchI32Op)link

Integer switch operation

Syntax:

operation ::= `vm.switch.i32` $index `[` $values `]` `else` $default_value attr-dict `:` type($result)

Returns the value with the given index in values or default_value if the index is out of bounds.

// Switch %index to cases of %c100/%c200/%c300 if index==0, ==1, ==2.
// If %index is out of range (<0 or >2) then default to %c5.
%0 = vm.switch.i32 %index[%c100, %c200, %c300] else %c5 : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
index 32-bit signless integer
default_value 32-bit signless integer
values variadic of 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.switch.i64 (VM::SwitchI64Op)link

Integer switch operation

Syntax:

operation ::= `vm.switch.i64` $index `[` $values `]` `else` $default_value attr-dict `:` type($result)

Returns the value with the given index in values or default_value if the index is out of bounds.

// Switch %index to cases of %c100/%c200/%c300 if index==0, ==1, ==2.
// If %index is out of range (<0 or >2) then default to %c5.
%0 = vm.switch.i32 %index[%c100, %c200, %c300] else %c5 : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
index 32-bit signless integer
default_value 64-bit signless integer
values variadic of 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.switch.ref (VM::SwitchRefOp)link

Ref switch operation

Returns the value with the given index in values or default_value if the index is out of bounds.

// Switch %arg0 to cases of %r0/%r1/%r2 if arg0==0, ==1, ==2.
// If %arg0 is out of range (<0 or >2) then default to %null.
%0 = vm.switch.ref %index[%r0, %r1, %r2] else %null : vm.ref<!foo>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
index 32-bit signless integer
default_value ref
values variadic of ref
Results:link
Result Description
result ref

Constant opslink

vm.const.f32 (VM::ConstF32Op)link

32-bit floating-point constant operation

Syntax:

operation ::= `vm.const.f32` $value attr-dict

Defines a constant value that is treated as a scalar literal at runtime.

Traits: AlwaysSpeculatableImplTrait, ConstantLike, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
valueFloatAttr32-bit floating-point value
Results:link
Result Description
result 32-bit float

vm.const.f32.zero (VM::ConstF32ZeroOp)link

32-bit floating-point constant zero operation

Syntax:

operation ::= `vm.const.f32.zero` attr-dict

Defines a constant zero primitive.

Traits: AlwaysSpeculatableImplTrait, ConstantLike, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Results:link
Result Description
result 32-bit float

vm.const.f64 (VM::ConstF64Op)link

64-bit floating-point constant operation

Syntax:

operation ::= `vm.const.f64` $value attr-dict

Defines a constant value that is treated as a scalar literal at runtime.

Traits: AlwaysSpeculatableImplTrait, ConstantLike, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
valueFloatAttr64-bit floating-point value
Results:link
Result Description
result 64-bit float

vm.const.f64.zero (VM::ConstF64ZeroOp)link

64-bit floating-point constant zero operation

Syntax:

operation ::= `vm.const.f64.zero` attr-dict

Defines a constant zero primitive.

Traits: AlwaysSpeculatableImplTrait, ConstantLike, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Results:link
Result Description
result 64-bit float

vm.const.i32 (VM::ConstI32Op)link

32-bit integer constant operation

Syntax:

operation ::= `vm.const.i32` $value attr-dict

Defines a constant value that is treated as a scalar literal at runtime.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
valueIntegerAttr32-bit integer value
Results:link
Result Description
result 32-bit signless integer

vm.const.i32.zero (VM::ConstI32ZeroOp)link

32-bit integer constant zero operation

Syntax:

operation ::= `vm.const.i32.zero` attr-dict

Defines a constant zero primitive.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Results:link
Result Description
result 32-bit signless integer

vm.const.i64 (VM::ConstI64Op)link

64-bit integer constant operation

Syntax:

operation ::= `vm.const.i64` $value attr-dict

Defines a constant value that is treated as a scalar literal at runtime.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
valueIntegerAttr64-bit integer value
Results:link
Result Description
result 64-bit signless integer

vm.const.i64.zero (VM::ConstI64ZeroOp)link

64-bit integer constant zero operation

Syntax:

operation ::= `vm.const.i64.zero` attr-dict

Defines a constant zero primitive.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Results:link
Result Description
result 64-bit signless integer

vm.const.ref.rodata (VM::ConstRefRodataOp)link

Constant rodata access operation

Syntax:

operation ::= `vm.const.ref.rodata` $rodata attr-dict `:` type($value)

Returns a reference to a read-only buffer.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, SymbolUserOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
rodata::mlir::FlatSymbolRefAttrflat symbol reference attribute
Results:link
Result Description
value ref

vm.const.ref.zero (VM::ConstRefZeroOp)link

Null ref constant operation

Syntax:

operation ::= `vm.const.ref.zero` `:` type($result) attr-dict

Defines a constant null ref that can be used in comparisons and initialization.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Results:link
Result Description
result ref

vm.rodata.inline (VM::RodataInlineOp)link

Inlined constant rodata

Syntax:

operation ::= `vm.rodata.inline` ($name^)? attr-dict `:` type($result) `=` $value

vm.rodata that can be embedded inline in functions. See vm.rodata for more information.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
value::mlir::Attributebuffer-like constant attribute values
alignment::mlir::IntegerAttr64-bit signless integer attribute
mime_type::mlir::StringAttrstring attribute
Results:link
Result Description
result ref

vm.rodata (VM::RodataOp)link

Read-only data definition operation

Syntax:

operation ::= `vm.rodata` custom<SymbolVisibility>($sym_visibility) $sym_name attr-dict $value

Defines a blob of read-only constant data that can be represented as a ref. This can be used to store arbitrary data within modules such as large constant buffers and other file contents.

Note that the data is reference counted as a way to track its usage once the value leaves the module. For example, returning rodata from an exported function must keep the data (possibly backed by mmap) valid for its entire lifetime.

By default all rodata will be aligned in the final module output at a 16-byte granularity. An optional alignment can be specified to override the default for cases where larger or smaller alignments are needed.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
value::mlir::Attributebuffer-like constant attribute values
alignment::mlir::IntegerAttr64-bit signless integer attribute
ordinal::mlir::IntegerAttrordinal value
mime_type::mlir::StringAttrstring attribute

vm.rodata.table.inline (VM::RodataTableInlineOp)link

Inlined constant rodata table

Syntax:

operation ::= `vm.rodata.table.inline` $table_type attr-dict `:` type($table_result) `,` type($data_result) `=` $data_array

vm.rodata with another associated vm.rodata table specifying byte offsets and sizes as a subview into the flattened data. The table is a flat array of 32 or 64-bit integers storing (offset, size) in element order.

The optional alignment attribute applies to both the table and data rodata. The data_alignment attribute can be used to specify an alignment for the elements of the table, padding to the data alignment with zeros. The element sizes reflect the unpadded attribute storage sizes.

See vm.rodata for more information.

Traits: AlwaysSpeculatableImplTrait, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
table_name::mlir::StringAttrstring attribute
data_name::mlir::StringAttrstring attribute
table_type::mlir::TypeAttrtype attribute of 32/64-bit integer
data_array::mlir::ArrayAttrarray attribute of serializable attributes
alignment::mlir::IntegerAttr64-bit signless integer attribute
data_alignment::mlir::IntegerAttr64-bit signless integer attribute
mime_type::mlir::StringAttrstring attribute
Results:link
Result Description
table_result ref
data_result ref

Control flow opslink

vm.br (VM::BranchOp)link

Unconditional branch operation

Syntax:

operation ::= `vm.br` $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict

Represents an unconditional branch operation that branches to a target block with the given set of arguments.

^bb0(...): vm.br ^bb1(%a) ^bb1(%blockArg1): ...

Traits: Terminator

Interfaces: BranchOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
destOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
dest any successor

vm.br_table (VM::BranchTableOp)link

Branch table operation

Syntax:

operation ::= `vm.br_table` $index ` ` `{` `\n`
              custom<BranchTableCases>(
              $defaultDestination, $defaultOperands, type($defaultOperands),
              $caseDestinations, $caseOperands, type($caseOperands))
              `}`
              attr-dict

Represents a branch table instructing execution to branch to the block with the specified index. If the index is out of bounds then execution will branch to the default block.

vm.br_table %index { default: ^bb1(%a : i64), 0: ^bb2, 1: ^bb3(%c : i64) }

Traits: AlwaysSpeculatableImplTrait, AttrSizedOperandSegments, Terminator

Interfaces: BranchOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
case_operand_segments::mlir::DenseI32ArrayAttri32 dense array attribute
Operands:link
Operand Description
index 32-bit signless integer
defaultOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
caseOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
defaultDestination any successor
caseDestinations any successor

vm.call (VM::CallOp)link

Call operation

Syntax:

operation ::= `vm.call` $callee `(` operands `)` attr-dict `:` functional-type(operands, results)

Calls an internal VM function with the given arguments.

Interfaces: CallOpInterface, MemoryEffectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
calleeFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
operands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Results:link
Result Description
results variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.call.variadic (VM::CallVariadicOp)link

Call operation with variadic arguments

Calls an internal VM function with the given arguments. One or more of the arguments may be variadic, encoded as segmented sized operand lists.

Variadic arguments must be specified with a total count in the segment_sizes attribute.

Interfaces: CallOpInterface, MemoryEffectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
calleeFlatSymbolRefAttrsymbol reference attribute
segment_sizes::mlir::DenseIntElementsAttr16-bit signless integer elements attribute
segment_types::mlir::ArrayAttrtype array attribute
Operands:link
Operand Description
operands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Results:link
Result Description
results variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.check.eq (VM::CheckEQOp)link

Raises a global failure if the condition is true

Syntax:

operation ::= `vm.check.eq` $lhs `,` $rhs (`,` $message^)? attr-dict `:` type($lhs)

When the condition is true this signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

This is implemented as a pseudo-op that transforms into a vm.cond_fail operation.

vm.check.eq %a, %b, "a == b" : i32
vm.check.nz %ref, "!null" : !vm.ref<?>

Traits: Commutative, VM_PseudoOp

Interfaces: VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
lhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
rhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.check.ne (VM::CheckNEOp)link

Raises a global failure if the condition is true

Syntax:

operation ::= `vm.check.ne` $lhs `,` $rhs (`,` $message^)? attr-dict `:` type($lhs)

When the condition is true this signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

This is implemented as a pseudo-op that transforms into a vm.cond_fail operation.

vm.check.eq %a, %b, "a == b" : i32
vm.check.nz %ref, "!null" : !vm.ref<?>

Traits: Commutative, VM_PseudoOp

Interfaces: VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
lhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
rhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.check.nz (VM::CheckNZOp)link

Raises a global failure if the condition is true

Syntax:

operation ::= `vm.check.nz` $value (`,` $message^)? attr-dict `:` type($value)

When the condition is true this signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

This is implemented as a pseudo-op that transforms into a vm.cond_fail operation.

vm.check.eq %a, %b, "a == b" : i32
vm.check.nz %ref, "!null" : !vm.ref<?>

Traits: VM_PseudoOp

Interfaces: VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
value 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.check.nearly_eq (VM::CheckNearlyEQOp)link

Raises a global failure if the condition is true

Syntax:

operation ::= `vm.check.nearly_eq` $lhs `,` $rhs (`,` $message^)? attr-dict `:` type($lhs)

When the condition is true this signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

This is implemented as a pseudo-op that transforms into a vm.cond_fail operation.

vm.check.eq %a, %b, "a == b" : i32
vm.check.nz %ref, "!null" : !vm.ref<?>

Traits: Commutative, VM_PseudoOp

Interfaces: VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
lhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
rhs 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.cond_br (VM::CondBranchOp)link

Conditional branch operation

Syntax:

operation ::= `vm.cond_br` $condition `,`
              $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
              $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
              attr-dict

Represents a conditional branch operation that branches to one of the two target blocks with the given set of arguments.

^bb0(...): vm.cond_br %condition, ^bb1(%a), ^bb2(%b) ^bb1(%blockArg1): ... ^bb2(%blockArg2): ...

Traits: AttrSizedOperandSegments, Terminator

Interfaces: BranchOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
condition 32-bit signless integer
trueDestOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
falseDestOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
trueDest any successor
falseDest any successor

vm.cond_fail (VM::CondFailOp)link

Raises a global failure if the condition is true

When the condition is true this signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail with the given status. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

As the IREE execution model is deeply pipelined it's possible that failures have a latency between when they are emitted and when the application can observe the failure. It's also possible that other work that is in-flight or pending when the failure occurs will complete.

This is implemented as a pseudo-op that transforms into a vm.fail operation guarded by the condition.

%nz = vm.cmp.nz.i32 %value : i32
%statusCode = vm.const.i32 9
vm.cond_fail %nz, %statusCode, "expected non-zero"

Traits: VM_PseudoOp

Interfaces: VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
condition 32-bit signless integer
status 32-bit signless integer

vm.fail (VM::FailOp)link

Raises a global failure

Syntax:

operation ::= `vm.fail` $status (`,` $message^)? attr-dict

Signals a runtime failure that causes the entire active invocation - and possibly all in-flight and pending invocations - to fail with the given status. The status will be propagated back via the available runtime error handling mechanisms such as semaphores or synchronous invocation results.

As the IREE execution model is deeply pipelined it's possible that failures have a latency between when they are emitted and when the application can observe the failure. It's also possible that other work that is in-flight or pending when the failure occurs will complete.

%statusCode = vm.const.i32 9
vm.fail %statusCode, "oh no!"

Traits: Terminator

Interfaces: VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
status 32-bit signless integer

vm.import.resolved (VM::ImportResolvedOp)link

Returns true if an optional import was resolved at runtime

Syntax:

operation ::= `vm.import.resolved` $import attr-dict `:` type($result)

Allows for checking whether a optional import was resolved at runtime. If this returns false then attempting to call the imported function will result in a failure at runtime.

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
importFlatSymbolRefAttrsymbol reference attribute
Results:link
Result Description
result 32-bit signless integer

vm.return (VM::ReturnOp)link

Return operation

Syntax:

operation ::= `vm.return` attr-dict ($operands^ `:` type($operands))?

Represents a return operation within a function.

vm.func @foo(%0: i32, %1: f8) -> (i32, f8) {
  vm.return %0, %1 : i32, f8
}

Traits: AlwaysSpeculatableImplTrait, ReturnLike, Terminator

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), RegionBranchTerminatorOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

Debugging opslink

vm.break (VM::BreakOp)link

Unconditional debug break operation

Syntax:

operation ::= `vm.break` $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict

Breaks into the attached debugger or asks for attaching a debugger. After resuming (or if a debugger is not attached) execution will continue at the target block.

Traits: Terminator, Util_YieldPoint, VM_DebugOnly, VM_FullBarrier

Interfaces: BranchOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
destOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
dest any successor

vm.cond_break (VM::CondBreakOp)link

Conditional debug break operation

Syntax:

operation ::= `vm.cond_break` $condition `,` $dest (`(` $destOperands^ `:` type($destOperands) `)`)?
              attr-dict

Breaks into the attached debugger or asks for attaching a debugger if the provided condition is true. After resuming (or if a debugger is not attached) execution will continue at the target block.

Traits: Terminator, Util_YieldPoint, VM_DebugOnly, VM_FullBarrier

Interfaces: BranchOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
condition 32-bit signless integer
destOperands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref
Successors:link
Successor Description
dest any successor

vm.print (VM::PrintOp)link

Message printing operation

Syntax:

operation ::= `vm.print` $message `(` operands `)` attr-dict `:` type(operands)

Prints the given string message and zero or more values.

Traits: VM_DebugOnly, VM_FullBarrier

Interfaces: VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
message::mlir::StringAttrstring attribute
Operands:link
Operand Description
operands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

vm.trace (VM::TraceOp)link

Trace value(s) operation

Syntax:

operation ::= `vm.trace` $event_name `(` operands `)` attr-dict `:` type(operands)

Traces one or more values at the time the operation is executed. These values will be encoded into the active trace depending on the active trace verbosity setting.

Traits: VM_DebugOnly, VM_FullBarrier

Interfaces: VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
event_name::mlir::StringAttrstring attribute
Operands:link
Operand Description
operands variadic of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float or 32-bit signless integer or ref

Floating-point arithmetic opslink

vm.abs.f32 (VM::AbsF32Op)link

Floating point absolute-value operation

Syntax:

operation ::= `vm.abs.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.abs.f64 (VM::AbsF64Op)link

Floating point absolute-value operation

Syntax:

operation ::= `vm.abs.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.add.f32 (VM::AddF32Op)link

Floating-point add operation

Syntax:

operation ::= `vm.add.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.add.f64 (VM::AddF64Op)link

Floating-point add operation

Syntax:

operation ::= `vm.add.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.ceil.f32 (VM::CeilF32Op)link

Floating point ceiling operation

Syntax:

operation ::= `vm.ceil.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.ceil.f64 (VM::CeilF64Op)link

Floating point ceiling operation

Syntax:

operation ::= `vm.ceil.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.div.f32 (VM::DivF32Op)link

Floating point division operation

Syntax:

operation ::= `vm.div.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.div.f64 (VM::DivF64Op)link

Floating point division operation

Syntax:

operation ::= `vm.div.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.fma.f32 (VM::FMAF32Op)link

Floating point fused multiply-add operation (a*b+c)

Syntax:

operation ::= `vm.fma.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
a 32-bit float
b 32-bit float
c 32-bit float
Results:link
Result Description
result 32-bit float

vm.fma.f64 (VM::FMAF64Op)link

Floating point fused multiply-add operation (a*b+c)

Syntax:

operation ::= `vm.fma.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
a 64-bit float
b 64-bit float
c 64-bit float
Results:link
Result Description
result 64-bit float

vm.floor.f32 (VM::FloorF32Op)link

Floating point floor operation

Syntax:

operation ::= `vm.floor.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.floor.f64 (VM::FloorF64Op)link

Floating point floor operation

Syntax:

operation ::= `vm.floor.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.max.f32 (VM::MaxF32Op)link

Floating point maximum operation

Syntax:

operation ::= `vm.max.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.max.f64 (VM::MaxF64Op)link

Floating point maximum operation

Syntax:

operation ::= `vm.max.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.min.f32 (VM::MinF32Op)link

Floating point minimum operation

Syntax:

operation ::= `vm.min.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.min.f64 (VM::MinF64Op)link

Floating point minimum operation

Syntax:

operation ::= `vm.min.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.mul.f32 (VM::MulF32Op)link

Floating point multiplication operation

Syntax:

operation ::= `vm.mul.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.mul.f64 (VM::MulF64Op)link

Floating point multiplication operation

Syntax:

operation ::= `vm.mul.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.neg.f32 (VM::NegF32Op)link

Floating point negation operation

Syntax:

operation ::= `vm.neg.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.neg.f64 (VM::NegF64Op)link

Floating point negation operation

Syntax:

operation ::= `vm.neg.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.rem.f32 (VM::RemF32Op)link

Floating point remainder operation

Syntax:

operation ::= `vm.rem.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.rem.f64 (VM::RemF64Op)link

Floating point remainder operation

Syntax:

operation ::= `vm.rem.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.round.f32.even (VM::RoundF32EvenOp)link

Rounds the value to the nearest even integer

Syntax:

operation ::= `vm.round.f32.even` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.round.f32 (VM::RoundF32Op)link

Rounds the value to the nearest integer away from zero

Syntax:

operation ::= `vm.round.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.round.f64.even (VM::RoundF64EvenOp)link

Rounds the value to the nearest even integer

Syntax:

operation ::= `vm.round.f64.even` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.round.f64 (VM::RoundF64Op)link

Rounds the value to the nearest integer away from zero

Syntax:

operation ::= `vm.round.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.sub.f32 (VM::SubF32Op)link

Floating point subtraction operation

Syntax:

operation ::= `vm.sub.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.sub.f64 (VM::SubF64Op)link

Floating point subtraction operation

Syntax:

operation ::= `vm.sub.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

Floating-point comparison opslink

vm.cmp.eq.f32.near (VM::CmpEQF32NearOp)link

Near floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f32.near` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.f32.o (VM::CmpEQF32OOp)link

Ordered floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.f32.u (VM::CmpEQF32UOp)link

Unordered floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.f64.near (VM::CmpEQF64NearOp)link

Near floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f64.near` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.f64.o (VM::CmpEQF64OOp)link

Ordered floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.eq.f64.u (VM::CmpEQF64UOp)link

Unordered floating-point equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.f32.o (VM::CmpGTEF32OOp)link

Ordered floating-point greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.f32.u (VM::CmpGTEF32UOp)link

Unordered floating-point greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.f64.o (VM::CmpGTEF64OOp)link

Ordered floating-point greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gte.f64.u (VM::CmpGTEF64UOp)link

Unordered floating-point greater-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.gte.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.f32.o (VM::CmpGTF32OOp)link

Ordered floating-point greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.f32.u (VM::CmpGTF32UOp)link

Unordered floating-point greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.f64.o (VM::CmpGTF64OOp)link

Ordered floating-point greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.gt.f64.u (VM::CmpGTF64UOp)link

Unordered floating-point greater-than comparison operation

Syntax:

operation ::= `vm.cmp.gt.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.f32.o (VM::CmpLTEF32OOp)link

Ordered floating-point less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.f32.u (VM::CmpLTEF32UOp)link

Unordered floating-point less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.f64.o (VM::CmpLTEF64OOp)link

Ordered floating-point less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lte.f64.u (VM::CmpLTEF64UOp)link

Unordered floating-point less-than-or-equal comparison operation

Syntax:

operation ::= `vm.cmp.lte.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.f32.o (VM::CmpLTF32OOp)link

Ordered floating-point less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.f32.u (VM::CmpLTF32UOp)link

Unordered floating-point less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.f64.o (VM::CmpLTF64OOp)link

Ordered floating-point less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.lt.f64.u (VM::CmpLTF64UOp)link

Unordered floating-point less-than comparison operation

Syntax:

operation ::= `vm.cmp.lt.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.f32.o (VM::CmpNEF32OOp)link

Ordered floating-point inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.f32.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.f32.u (VM::CmpNEF32UOp)link

Unordered floating-point inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.f32.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.f64.o (VM::CmpNEF64OOp)link

Ordered floating-point inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.f64.o` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.f64.u (VM::CmpNEF64UOp)link

Unordered floating-point inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.f64.u` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.f32.o (VM::CmpNZF32OOp)link

Ordered floating-point non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.f32.o` operands attr-dict `:` type($operand)

Compares the given floating-point operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.f32.u (VM::CmpNZF32UOp)link

Unordered floating-point non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.f32.u` operands attr-dict `:` type($operand)

Compares the given floating-point operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.f64.o (VM::CmpNZF64OOp)link

Ordered floating-point non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.f64.o` operands attr-dict `:` type($operand)

Compares the given floating-point operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.f64.u (VM::CmpNZF64UOp)link

Unordered floating-point non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.f64.u` operands attr-dict `:` type($operand)

Compares the given floating-point operand for a non-zero value.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64, VM_PseudoOp

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nan.f32 (VM::CmpNaNF32Op)link

Floating-point NaN comparison operation

Syntax:

operation ::= `vm.cmp.nan.f32` $operand attr-dict `:` type($operand)

Returns 1 if the value is NaN.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nan.f64 (VM::CmpNaNF64Op)link

Floating-point NaN comparison operation

Syntax:

operation ::= `vm.cmp.nan.f64` $operand attr-dict `:` type($operand)

Returns 1 if the value is NaN.

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 32-bit signless integer

Floating-point math opslink

These map directly to the math dialect.

vm.atan2.f32 (VM::Atan2F32Op)link

2-argument arcus tangent of the given values

Syntax:

operation ::= `vm.atan2.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.atan2.f64 (VM::Atan2F64Op)link

2-argument arcus tangent of the given values

Syntax:

operation ::= `vm.atan2.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.atan.f32 (VM::AtanF32Op)link

Arcus tangent of the given value

Syntax:

operation ::= `vm.atan.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.atan.f64 (VM::AtanF64Op)link

Arcus tangent of the given value

Syntax:

operation ::= `vm.atan.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.cos.f32 (VM::CosF32Op)link

Cosine of the specified value

Syntax:

operation ::= `vm.cos.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.cos.f64 (VM::CosF64Op)link

Cosine of the specified value

Syntax:

operation ::= `vm.cos.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.erf.f32 (VM::ErfF32Op)link

Computes the error function of the specified value

Syntax:

operation ::= `vm.erf.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.erf.f64 (VM::ErfF64Op)link

Computes the error function of the specified value

Syntax:

operation ::= `vm.erf.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.exp2.f32 (VM::Exp2F32Op)link

Base-2 exponential of the specified value

Syntax:

operation ::= `vm.exp2.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.exp2.f64 (VM::Exp2F64Op)link

Base-2 exponential of the specified value

Syntax:

operation ::= `vm.exp2.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.exp.f32 (VM::ExpF32Op)link

Base-e exponential of the specified value

Syntax:

operation ::= `vm.exp.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.exp.f64 (VM::ExpF64Op)link

Base-e exponential of the specified value

Syntax:

operation ::= `vm.exp.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.expm1.f32 (VM::ExpM1F32Op)link

Base-e exponential of the specified value minus 1

Syntax:

operation ::= `vm.expm1.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.expm1.f64 (VM::ExpM1F64Op)link

Base-e exponential of the specified value minus 1

Syntax:

operation ::= `vm.expm1.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.log10.f32 (VM::Log10F32Op)link

Base-10 logarithm of the specified value

Syntax:

operation ::= `vm.log10.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.log10.f64 (VM::Log10F64Op)link

Base-10 logarithm of the specified value

Syntax:

operation ::= `vm.log10.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.log1p.f32 (VM::Log1pF32Op)link

Natural logarithm of one plus the given value

Syntax:

operation ::= `vm.log1p.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.log1p.f64 (VM::Log1pF64Op)link

Natural logarithm of one plus the given value

Syntax:

operation ::= `vm.log1p.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.log2.f32 (VM::Log2F32Op)link

Base-2 logarithm of the specified value

Syntax:

operation ::= `vm.log2.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.log2.f64 (VM::Log2F64Op)link

Base-2 logarithm of the specified value

Syntax:

operation ::= `vm.log2.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.log.f32 (VM::LogF32Op)link

Base-e logarithm of the specified value

Syntax:

operation ::= `vm.log.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.log.f64 (VM::LogF64Op)link

Base-e logarithm of the specified value

Syntax:

operation ::= `vm.log.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.pow.f32 (VM::PowF32Op)link

Floating point raised to the power of operation

Syntax:

operation ::= `vm.pow.f32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit float
rhs 32-bit float
Results:link
Result Description
result 32-bit float

vm.pow.f64 (VM::PowF64Op)link

Floating point raised to the power of operation

Syntax:

operation ::= `vm.pow.f64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit float
rhs 64-bit float
Results:link
Result Description
result 64-bit float

vm.rsqrt.f32 (VM::RsqrtF32Op)link

Reciprocal of sqrt (1 / sqrt of the specified value)

Syntax:

operation ::= `vm.rsqrt.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.rsqrt.f64 (VM::RsqrtF64Op)link

Reciprocal of sqrt (1 / sqrt of the specified value)

Syntax:

operation ::= `vm.rsqrt.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.sin.f32 (VM::SinF32Op)link

Sine of the specified value

Syntax:

operation ::= `vm.sin.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.sin.f64 (VM::SinF64Op)link

Sine of the specified value

Syntax:

operation ::= `vm.sin.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.sqrt.f32 (VM::SqrtF32Op)link

Sqrt of the specified value

Syntax:

operation ::= `vm.sqrt.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.sqrt.f64 (VM::SqrtF64Op)link

Sqrt of the specified value

Syntax:

operation ::= `vm.sqrt.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

vm.tanh.f32 (VM::TanhF32Op)link

Hyperbolic tangent of the specified value

Syntax:

operation ::= `vm.tanh.f32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF32

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit float
Results:link
Result Description
result 32-bit float

vm.tanh.f64 (VM::TanhF64Op)link

Hyperbolic tangent of the specified value

Syntax:

operation ::= `vm.tanh.f64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, VM_ExtF64

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit float
Results:link
Result Description
result 64-bit float

Global opslink

vm.global.address (VM::GlobalAddressOp)link

Returns an address reference to a global

Syntax:

operation ::= `vm.global.address` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($result)

Returns an indirect address reference to the given global. During export the address will be converted to the natural format of the global table (for example, ordinals for refs and byte offsets for primitive types).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), SymbolUserOpInterface, Util_GlobalAddressOpInterface, VM_OpInterface

Effects: MemoryEffects::Effect{}

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
result 32-bit signless integer or a pointer-like reference

vm.global.f32 (VM::GlobalF32Op)link

32-bit floating-point global declaration

Syntax:

operation ::= `vm.global.f32` custom<SymbolVisibility>($sym_visibility)
              (`mutable` $is_mutable^)?
              $sym_name
              attr-dict
              custom<TypeOrAttr>($type, $initial_value)

Defines a global value that is treated as a scalar literal at runtime. Initialized to zero unless an initial value is specified.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove, VM_ExtF32

Interfaces: GlobalOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
is_mutable::mlir::UnitAttrunit attribute
initial_valueFloatAttr32-bit floating-point value
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
ordinal::mlir::IntegerAttrordinal value

vm.global.f64 (VM::GlobalF64Op)link

64-bit floating-point global declaration

Syntax:

operation ::= `vm.global.f64` custom<SymbolVisibility>($sym_visibility)
              (`mutable` $is_mutable^)?
              $sym_name
              attr-dict
              custom<TypeOrAttr>($type, $initial_value)

Defines a global value that is treated as a scalar literal at runtime. Initialized to zero unless an initial value is specified.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove, VM_ExtF64

Interfaces: GlobalOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
is_mutable::mlir::UnitAttrunit attribute
initial_valueFloatAttr64-bit floating-point value
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
ordinal::mlir::IntegerAttrordinal value

vm.global.i32 (VM::GlobalI32Op)link

32-bit integer global declaration

Syntax:

operation ::= `vm.global.i32` custom<SymbolVisibility>($sym_visibility)
              (`mutable` $is_mutable^)?
              $sym_name
              attr-dict
              custom<TypeOrAttr>($type, $initial_value)

Defines a global value that is treated as a scalar literal at runtime. Initialized to zero unless an initial value is specified.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: GlobalOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
is_mutable::mlir::UnitAttrunit attribute
initial_valueIntegerAttr32-bit integer value
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
ordinal::mlir::IntegerAttrordinal value

vm.global.i64 (VM::GlobalI64Op)link

64-bit integer global declaration

Syntax:

operation ::= `vm.global.i64` custom<SymbolVisibility>($sym_visibility)
              (`mutable` $is_mutable^)?
              $sym_name
              attr-dict
              custom<TypeOrAttr>($type, $initial_value)

Defines a global value that is treated as a scalar literal at runtime. Initialized to zero unless an initial value is specified.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: GlobalOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
is_mutable::mlir::UnitAttrunit attribute
initial_valueIntegerAttr64-bit integer value
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
ordinal::mlir::IntegerAttrordinal value

vm.global.load.f32 (VM::GlobalLoadF32Op)link

Global 32-bit floating-point load operation

Syntax:

operation ::= `vm.global.load.f32` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($value)

Loads the value of a global containing an primitive value.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface, OpAsmOpInterface, SymbolUserOpInterface, Util_GlobalLoadOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
value 32-bit float

vm.global.load.f64 (VM::GlobalLoadF64Op)link

Global 64-bit floating-point load operation

Syntax:

operation ::= `vm.global.load.f64` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($value)

Loads the value of a global containing an primitive value.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface, OpAsmOpInterface, SymbolUserOpInterface, Util_GlobalLoadOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
value 64-bit float

vm.global.load.i32 (VM::GlobalLoadI32Op)link

Global 32-bit integer load operation

Syntax:

operation ::= `vm.global.load.i32` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($value)

Loads the value of a global containing an primitive value.

Interfaces: MemoryEffectOpInterface, OpAsmOpInterface, SymbolUserOpInterface, Util_GlobalLoadOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
value 32-bit signless integer

vm.global.load.i64 (VM::GlobalLoadI64Op)link

Global 64-bit integer load operation

Syntax:

operation ::= `vm.global.load.i64` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($value)

Loads the value of a global containing an primitive value.

Interfaces: MemoryEffectOpInterface, OpAsmOpInterface, SymbolUserOpInterface, Util_GlobalLoadOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
value 64-bit signless integer

vm.global.load.indirect.f32 (VM::GlobalLoadIndirectF32Op)link

Global 32-bit floating-point load operation

Syntax:

operation ::= `vm.global.load.indirect.f32` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($global) `->` type($value)

Loads the value of a global containing a primitive value.

Traits: VM_ExtF64

Interfaces: Util_GlobalLoadIndirectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
is_immutable::mlir::UnitAttrunit attribute
Operands:link
Operand Description
global 32-bit signless integer or ptr<32-bit float>
Results:link
Result Description
value 32-bit float

vm.global.load.indirect.f64 (VM::GlobalLoadIndirectF64Op)link

Global 64-bit floating-point load operation

Syntax:

operation ::= `vm.global.load.indirect.f64` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($global) `->` type($value)

Loads the value of a global containing a primitive value.

Traits: VM_ExtF64

Interfaces: Util_GlobalLoadIndirectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
is_immutable::mlir::UnitAttrunit attribute
Operands:link
Operand Description
global 32-bit signless integer or ptr<64-bit float>
Results:link
Result Description
value 64-bit float

vm.global.load.indirect.i32 (VM::GlobalLoadIndirectI32Op)link

Global 32-bit integer load operation

Syntax:

operation ::= `vm.global.load.indirect.i32` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($global) `->` type($value)

Loads the value of a global containing a primitive value.

Interfaces: Util_GlobalLoadIndirectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
is_immutable::mlir::UnitAttrunit attribute
Operands:link
Operand Description
global 32-bit signless integer or ptr<32-bit signless integer>
Results:link
Result Description
value 32-bit signless integer

vm.global.load.indirect.i64 (VM::GlobalLoadIndirectI64Op)link

Global 64-bit integer load operation

Syntax:

operation ::= `vm.global.load.indirect.i64` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($global) `->` type($value)

Loads the value of a global containing a primitive value.

Interfaces: Util_GlobalLoadIndirectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
is_immutable::mlir::UnitAttrunit attribute
Operands:link
Operand Description
global 32-bit signless integer or ptr<64-bit signless integer>
Results:link
Result Description
value 64-bit signless integer

vm.global.load.indirect.ref (VM::GlobalLoadIndirectRefOp)link

Global ref load operation

Syntax:

operation ::= `vm.global.load.indirect.ref` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($global) `->` type($value)

Loads the value of a global containing a ref of the given type.

Interfaces: Util_GlobalLoadIndirectOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
is_immutable::mlir::UnitAttrunit attribute
Operands:link
Operand Description
global 32-bit signless integer or ptr
Results:link
Result Description
value ref

vm.global.load.ref (VM::GlobalLoadRefOp)link

Global ref load operation

Syntax:

operation ::= `vm.global.load.ref` (`immutable` $is_immutable^)?
              $global attr-dict `:` type($value)

Loads the value of a global containing a ref of the given type.

Interfaces: MemoryEffectOpInterface, OpAsmOpInterface, SymbolUserOpInterface, Util_GlobalLoadOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
is_immutable::mlir::UnitAttrunit attribute
Results:link
Result Description
value ref

vm.global.ref (VM::GlobalRefOp)link

Ref global declaration

Syntax:

operation ::= `vm.global.ref` custom<SymbolVisibility>($sym_visibility)
              (`mutable` $is_mutable^)?
              $sym_name
              attr-dict
              `:` $type

Defines a global value that is a ref of a specific type. The global will retain the ref object for the lifetime of the context or until the value is replaced with a store or reset. Initialized to null unless an initial value is specified.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: GlobalOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
is_mutable::mlir::UnitAttrunit attribute
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
ordinal::mlir::IntegerAttrordinal value

vm.global.store.f32 (VM::GlobalStoreF32Op)link

Global 32-bit floating-point store operation

Syntax:

operation ::= `vm.global.store.f32` $value `,` $global attr-dict `:` type($value)

Stores a primitive value value to a global.

Traits: VM_ExtF32

Interfaces: SymbolUserOpInterface, Util_GlobalStoreOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
value 32-bit float

vm.global.store.f64 (VM::GlobalStoreF64Op)link

Global 64-bit floating-point store operation

Syntax:

operation ::= `vm.global.store.f64` $value `,` $global attr-dict `:` type($value)

Stores a primitive value value to a global.

Traits: VM_ExtF64

Interfaces: SymbolUserOpInterface, Util_GlobalStoreOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
value 64-bit float

vm.global.store.i32 (VM::GlobalStoreI32Op)link

Global 32-bit integer store operation

Syntax:

operation ::= `vm.global.store.i32` $value `,` $global attr-dict `:` type($value)

Stores a primitive value value to a global.

Interfaces: SymbolUserOpInterface, Util_GlobalStoreOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
value 32-bit signless integer

vm.global.store.i64 (VM::GlobalStoreI64Op)link

Global 64-bit integer store operation

Syntax:

operation ::= `vm.global.store.i64` $value `,` $global attr-dict `:` type($value)

Stores a primitive value value to a global.

Interfaces: SymbolUserOpInterface, Util_GlobalStoreOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
value 64-bit signless integer

vm.global.store.indirect.f32 (VM::GlobalStoreIndirectF32Op)link

Global 32-bit floating-point store operation

Syntax:

operation ::= `vm.global.store.indirect.f32` $value `,` $global attr-dict `:` type($value) `->` type($global)

Stores a primitive value to a global.

Traits: VM_ExtF32

Interfaces: Util_GlobalStoreIndirectOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
value 32-bit float
global 32-bit signless integer or ptr<32-bit float>

vm.global.store.indirect.f64 (VM::GlobalStoreIndirectF64Op)link

Global 64-bit floating-point store operation

Syntax:

operation ::= `vm.global.store.indirect.f64` $value `,` $global attr-dict `:` type($value) `->` type($global)

Stores a primitive value to a global.

Traits: VM_ExtF64

Interfaces: Util_GlobalStoreIndirectOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
value 64-bit float
global 32-bit signless integer or ptr<64-bit float>

vm.global.store.indirect.i32 (VM::GlobalStoreIndirectI32Op)link

Global 32-bit integer store operation

Syntax:

operation ::= `vm.global.store.indirect.i32` $value `,` $global attr-dict `:` type($value) `->` type($global)

Stores a primitive value to a global.

Interfaces: Util_GlobalStoreIndirectOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
value 32-bit signless integer
global 32-bit signless integer or ptr<32-bit signless integer>

vm.global.store.indirect.i64 (VM::GlobalStoreIndirectI64Op)link

Global 64-bit integer store operation

Syntax:

operation ::= `vm.global.store.indirect.i64` $value `,` $global attr-dict `:` type($value) `->` type($global)

Stores a primitive value to a global.

Interfaces: Util_GlobalStoreIndirectOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
value 64-bit signless integer
global 32-bit signless integer or ptr<64-bit signless integer>

vm.global.store.indirect.ref (VM::GlobalStoreIndirectRefOp)link

Global ref stores operation

Syntax:

operation ::= `vm.global.store.indirect.ref` $value `,` $global attr-dict `:` type($value) `->` type($global)

Stores a ref to a global, retaining it until the global is reset.

Interfaces: Util_GlobalStoreIndirectOpInterface, VMSerializableOp, VM_OpInterface

Operands:link
Operand Description
value ref
global 32-bit signless integer or ptr

vm.global.store.ref (VM::GlobalStoreRefOp)link

Global ref stores operation

Syntax:

operation ::= `vm.global.store.ref` $value `,` $global attr-dict `:` type($value)

Stores a ref to a global, retaining it until the global is reset.

Interfaces: SymbolUserOpInterface, Util_GlobalStoreOpInterface, VMSerializableOp, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
globalFlatSymbolRefAttrsymbol reference attribute
Operands:link
Operand Description
value ref

Integer arithmetic opslink

vm.abs.i32 (VM::AbsI32Op)link

Integer absolute-value operation

Syntax:

operation ::= `vm.abs.i32` $operand attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.abs.i64 (VM::AbsI64Op)link

Integer absolute-value operation

Syntax:

operation ::= `vm.abs.i64` $operand attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.add.i32 (VM::AddI32Op)link

Integer add operation

Syntax:

operation ::= `vm.add.i32` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.add.i64 (VM::AddI64Op)link

Integer add operation

Syntax:

operation ::= `vm.add.i64` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.div.i32.s (VM::DivI32SOp)link

Signed integer division operation

Syntax:

operation ::= `vm.div.i32.s` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.div.i32.u (VM::DivI32UOp)link

Unsigned integer division operation

Syntax:

operation ::= `vm.div.i32.u` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.div.i64.s (VM::DivI64SOp)link

Signed integer division operation

Syntax:

operation ::= `vm.div.i64.s` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.div.i64.u (VM::DivI64UOp)link

Unsigned integer division operation

Syntax:

operation ::= `vm.div.i64.u` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.fma.i32 (VM::FMAI32Op)link

Integer fused-multiply add operation (a*b+c)

Syntax:

operation ::= `vm.fma.i32` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
a 32-bit signless integer
b 32-bit signless integer
c 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.fma.i64 (VM::FMAI64Op)link

Integer fused-multiply add operation (a*b+c)

Syntax:

operation ::= `vm.fma.i64` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
a 64-bit signless integer
b 64-bit signless integer
c 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.max.i32.s (VM::MaxI32SOp)link

Signed integer maximum operation

Syntax:

operation ::= `vm.max.i32.s` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.max.i32.u (VM::MaxI32UOp)link

Unsigned integer maximum operation

Syntax:

operation ::= `vm.max.i32.u` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.max.i64.s (VM::MaxI64SOp)link

Signed integer maximum operation

Syntax:

operation ::= `vm.max.i64.s` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.max.i64.u (VM::MaxI64UOp)link

Unsigned integer maximum operation

Syntax:

operation ::= `vm.max.i64.u` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.min.i32.s (VM::MinI32SOp)link

Signed integer minimum operation

Syntax:

operation ::= `vm.min.i32.s` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.min.i32.u (VM::MinI32UOp)link

Unsigned integer minimum operation

Syntax:

operation ::= `vm.min.i32.u` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.min.i64.s (VM::MinI64SOp)link

Signed integer minimum operation

Syntax:

operation ::= `vm.min.i64.s` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.min.i64.u (VM::MinI64UOp)link

Unsigned integer minimum operation

Syntax:

operation ::= `vm.min.i64.u` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.mul.i32 (VM::MulI32Op)link

Integer multiplication operation

Syntax:

operation ::= `vm.mul.i32` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.mul.i64 (VM::MulI64Op)link

Integer multiplication operation

Syntax:

operation ::= `vm.mul.i64` operands attr-dict `:` type($result)

Traits: Commutative

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.rem.i32.s (VM::RemI32SOp)link

Signed integer division remainder operation

Syntax:

operation ::= `vm.rem.i32.s` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.rem.i32.u (VM::RemI32UOp)link

Unsigned integer division remainder operation

Syntax:

operation ::= `vm.rem.i32.u` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.rem.i64.s (VM::RemI64SOp)link

Signed integer division remainder operation

Syntax:

operation ::= `vm.rem.i64.s` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.rem.i64.u (VM::RemI64UOp)link

Unsigned integer division remainder operation

Syntax:

operation ::= `vm.rem.i64.u` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.sub.i32 (VM::SubI32Op)link

Integer subtract operation

Syntax:

operation ::= `vm.sub.i32` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.sub.i64 (VM::SubI64Op)link

Integer subtract operation

Syntax:

operation ::= `vm.sub.i64` operands attr-dict `:` type($result)

Interfaces: NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

Integer bit manipulation opslink

vm.and.i32 (VM::AndI32Op)link

Integer binary and operation

Syntax:

operation ::= `vm.and.i32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.and.i64 (VM::AndI64Op)link

Integer binary and operation

Syntax:

operation ::= `vm.and.i64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.ctlz.i32 (VM::CtlzI32Op)link

Counts the leading zeros in an integer value

Syntax:

operation ::= `vm.ctlz.i32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.ctlz.i64 (VM::CtlzI64Op)link

Counts the leading zeros in an integer value

Syntax:

operation ::= `vm.ctlz.i64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.not.i32 (VM::NotI32Op)link

Integer binary not operation

Syntax:

operation ::= `vm.not.i32` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.not.i64 (VM::NotI64Op)link

Integer binary not operation

Syntax:

operation ::= `vm.not.i64` $operand attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.or.i32 (VM::OrI32Op)link

Integer binary or operation

Syntax:

operation ::= `vm.or.i32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.or.i64 (VM::OrI64Op)link

Integer binary or operation

Syntax:

operation ::= `vm.or.i64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.xor.i32 (VM::XorI32Op)link

Integer binary exclusive-or operation

Syntax:

operation ::= `vm.xor.i32` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 32-bit signless integer
rhs 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.xor.i64 (VM::XorI64Op)link

Integer binary exclusive-or operation

Syntax:

operation ::= `vm.xor.i64` operands attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs 64-bit signless integer
rhs 64-bit signless integer
Results:link
Result Description
result 64-bit signless integer

List opslink

vm.list.alloc (VM::ListAllocOp)link

Allocates a new empty list

Syntax:

operation ::= `vm.list.alloc` operands attr-dict `:` `(` type($initial_capacity) `)` `->` type($result)

Allocates a new typed list with a minimum initial_capacity.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Allocate on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
initial_capacity 32-bit signless integer
Results:link
Result Description
result list

vm.list.get.f32 (VM::ListGetF32Op)link

Primitive type element accessor

Syntax:

operation ::= `vm.list.get.f32` operands attr-dict `:` `(` type($list) `,` type($index) `)` `->` type($result)

Returns the value of the element at the given index.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
Results:link
Result Description
result 32-bit float

vm.list.get.f64 (VM::ListGetF64Op)link

Primitive type element accessor

Syntax:

operation ::= `vm.list.get.f64` operands attr-dict `:` `(` type($list) `,` type($index) `)` `->` type($result)

Returns the value of the element at the given index.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
Results:link
Result Description
result 64-bit float

vm.list.get.i32 (VM::ListGetI32Op)link

Primitive type element accessor

Syntax:

operation ::= `vm.list.get.i32` operands attr-dict `:` `(` type($list) `,` type($index) `)` `->` type($result)

Returns the value of the element at the given index.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
Results:link
Result Description
result 32-bit signless integer

vm.list.get.i64 (VM::ListGetI64Op)link

Primitive type element accessor

Syntax:

operation ::= `vm.list.get.i64` operands attr-dict `:` `(` type($list) `,` type($index) `)` `->` type($result)

Returns the value of the element at the given index.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
Results:link
Result Description
result 64-bit signless integer

vm.list.get.ref (VM::ListGetRefOp)link

Ref type element accessor

Syntax:

operation ::= `vm.list.get.ref` operands attr-dict `:` `(` type($list) `,` type($index) `)` `->` type($result)

Returns the ref value of the element at the given index. Note that the value may be null if the element is null or the type does not match.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list
index 32-bit signless integer
Results:link
Result Description
result ref

vm.list.reserve (VM::ListReserveOp)link

Reserves capacity for list growth

Syntax:

operation ::= `vm.list.reserve` operands attr-dict `:` `(` type($list) `,` type($minimum_capacity) `)`

Reserves storage for at least minimum_capacity elements. If the list already has at least the specified capacity the operation is ignored.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Allocate on ::mlir::SideEffects::DefaultResource, MemoryEffects::Read on ::mlir::SideEffects::DefaultResource, MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list
minimum_capacity 32-bit signless integer

vm.list.resize (VM::ListResizeOp)link

Resizes the list to a new count in elements

Syntax:

operation ::= `vm.list.resize` operands attr-dict `:` `(` type($list) `,` type($new_size) `)`

Resizes the list to contain new_size elements. This will either truncate the list if the existing size is greater than new_size or extend the list with the default list value of 0 if storing primitives and null if refs.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list
new_size 32-bit signless integer

vm.list.set.f32 (VM::ListSetF32Op)link

Primitive type element mutator

Syntax:

operation ::= `vm.list.set.f32` operands attr-dict `:` `(` type($list) `,` type($index) `,` type($value) `)`

Sets the element at the given index to the new value.

Traits: VM_ExtF32

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
value 32-bit float

vm.list.set.f64 (VM::ListSetF64Op)link

Primitive type element mutator

Syntax:

operation ::= `vm.list.set.f64` operands attr-dict `:` `(` type($list) `,` type($index) `,` type($value) `)`

Sets the element at the given index to the new value.

Traits: VM_ExtF64

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
value 64-bit float

vm.list.set.i32 (VM::ListSetI32Op)link

Primitive type element mutator

Syntax:

operation ::= `vm.list.set.i32` operands attr-dict `:` `(` type($list) `,` type($index) `,` type($value) `)`

Sets the element at the given index to the new value.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
value 32-bit signless integer

vm.list.set.i64 (VM::ListSetI64Op)link

Primitive type element mutator

Syntax:

operation ::= `vm.list.set.i64` operands attr-dict `:` `(` type($list) `,` type($index) `,` type($value) `)`

Sets the element at the given index to the new value.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list<8/16/32/64-bit integer or 16/32/64-bit float>
index 32-bit signless integer
value 64-bit signless integer

vm.list.set.ref (VM::ListSetRefOp)link

Ref type element mutator

Syntax:

operation ::= `vm.list.set.ref` operands attr-dict `:` `(` type($list) `,` type($index) `,` type($value) `)`

Sets the element at the given index to the new ref value (possibly null).

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Write on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list
index 32-bit signless integer
value ref

vm.list.size (VM::ListSizeOp)link

The size of the list in elements

Syntax:

operation ::= `vm.list.size` operands attr-dict `:` `(` type($list) `)` `->` type($result)

Returns the current size of the list in elements.

Interfaces: MemoryEffectOpInterface (MemoryEffectOpInterface), VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{MemoryEffects::Read on ::mlir::SideEffects::DefaultResource}

Operands:link
Operand Description
list list
Results:link
Result Description
result 32-bit signless integer

Ref comparison opslink

Comparison ops for vm.ref.

vm.cmp.eq.ref (VM::CmpEQRefOp)link

Ref equality comparison operation

Syntax:

operation ::= `vm.cmp.eq.ref` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs ref
rhs ref
Results:link
Result Description
result 32-bit signless integer

vm.cmp.ne.ref (VM::CmpNERefOp)link

Ref inequality comparison operation

Syntax:

operation ::= `vm.cmp.ne.ref` operands attr-dict `:` type($lhs)

Compares two operands with the specified predicate.

Traits: AlwaysSpeculatableImplTrait, Commutative

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
lhs ref
rhs ref
Results:link
Result Description
result 32-bit signless integer

vm.cmp.nz.ref (VM::CmpNZRefOp)link

Ref non-zero comparison operation

Syntax:

operation ::= `vm.cmp.nz.ref` $operand attr-dict `:` type($operand)

Compares the given ref operand for a non-zero/null value.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), OpAsmOpInterface, VMSerializableOp, VM_OpInterface

Effects: MemoryEffects::Effect{}

Operands:link
Operand Description
operand ref
Results:link
Result Description
result 32-bit signless integer

Structural opslink

vm.export (VM::ExportOp)link

Exports a function from the module

Specifies an exported function with an externally-visible alias. Multiple exports can reference the same internal functions.

Interfaces: SymbolUserOpInterface, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
function_ref::mlir::FlatSymbolRefAttrflat symbol reference attribute
export_name::mlir::StringAttrstring attribute
ordinal::mlir::IntegerAttrordinal value

vm.func (VM::FuncOp)link

Function defined with VM control flow ops

Represents a function containing VM ops and those of compatible dialects. All flow control is performed by VM ops.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: CallableOpInterface, FunctionOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
function_type::mlir::TypeAttrtype attribute of function type
ordinal::mlir::IntegerAttrordinal value
inlining_policy::mlir::iree_compiler::IREE::Util::InliningPolicyAttrInterfaceInliningPolicyAttrInterface instance
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes

vm.import (VM::ImportOp)link

Imports a function from an external module

Specifies a function that should be imported from either the runtime or an external VM module.

Required imports can be declared with a minimum version of the module that contains the import. The maximum declared minimum version of all required imports from the module will become the required minimum version at runtime.

Optional imports not present at runtime will be invalid to call and whether they were resolved can be queried with vm.import.resolved.

Interfaces: CallableOpInterface, FunctionOpInterface, Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of function type
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
sym_visibility::mlir::StringAttrstring attribute
ordinal::mlir::IntegerAttrordinal value
is_optional::mlir::UnitAttrunit attribute
minimum_version::mlir::IntegerAttr32-bit signless integer attribute

vm.initializer (VM::InitializerOp)link

Global initialization function

A function that is called in definition order upon module initialization. Must not load any globals that are defined or initialized after it in the module.

Traits: HasParent<IREE::VM::ModuleOp>, IsolatedFromAbove

Interfaces: CallableOpInterface, FunctionOpInterface, Symbol, Util_InitializerOpInterface, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
function_type::mlir::TypeAttrtype attribute of function type
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes

vm.module (VM::ModuleOp)link

Module containing VM functions and variables

Syntax:

operation ::= `vm.module` custom<SymbolVisibility>($sym_visibility)
              $sym_name
              attr-dict-with-keyword
              regions

Top-level container for VM functions.

Traits: IsolatedFromAbove, SingleBlockImplicitTerminator<IREE::VM::ModuleTerminatorOp>, SingleBlock, SymbolTable

Interfaces: Symbol, VM_OpInterface

Attributes:link
AttributeMLIR TypeDescription
sym_visibility::mlir::StringAttrstring attribute
sym_name::mlir::StringAttrstring attribute
ordinal_counts::mlir::iree_compiler::IREE::VM::OrdinalCountsAttr
version::mlir::IntegerAttr32-bit signless integer attribute

vm.module_terminator (VM::ModuleTerminatorOp)link

Terminator pseudo-op for the module op

Syntax:

operation ::= `vm.module_terminator` attr-dict

Traits: HasParent<IREE::VM::ModuleOp>, Terminator

Interfaces: VM_OpInterface

Attributeslink

OrdinalCountsAttrlink

Syntax:

#vm.ordinal_counts<
  int32_t,   # import_funcs
  int32_t,   # export_funcs
  int32_t,   # internal_funcs
  int32_t,   # global_bytes
  int32_t,   # global_refs
  int32_t,   # rodatas
  int32_t   # rwdatas
>
Parameters:link
Parameter C++ type Description
import_funcs int32_t
export_funcs int32_t
internal_funcs int32_t
global_bytes int32_t
global_refs int32_t
rodatas int32_t
rwdatas int32_t

Enumslink

Opcodelink

valid VM core operation encodings

Cases:link

Symbol Value String
GlobalLoadI32 0 GlobalLoadI32
GlobalStoreI32 1 GlobalStoreI32
GlobalLoadIndirectI32 2 GlobalLoadIndirectI32
GlobalStoreIndirectI32 3 GlobalStoreIndirectI32
GlobalLoadI64 4 GlobalLoadI64
GlobalStoreI64 5 GlobalStoreI64
GlobalLoadIndirectI64 6 GlobalLoadIndirectI64
GlobalStoreIndirectI64 7 GlobalStoreIndirectI64
GlobalLoadRef 8 GlobalLoadRef
GlobalStoreRef 9 GlobalStoreRef
GlobalLoadIndirectRef 10 GlobalLoadIndirectRef
GlobalStoreIndirectRef 11 GlobalStoreIndirectRef
ConstI32Zero 12 ConstI32Zero
ConstI32 13 ConstI32
ConstI64Zero 14 ConstI64Zero
ConstI64 15 ConstI64
ConstRefZero 16 ConstRefZero
ConstRefRodata 17 ConstRefRodata
ListAlloc 18 ListAlloc
ListReserve 19 ListReserve
ListSize 20 ListSize
ListResize 21 ListResize
ListGetI32 22 ListGetI32
ListSetI32 23 ListSetI32
ListGetI64 24 ListGetI64
ListSetI64 25 ListSetI64
ListGetRef 26 ListGetRef
ListSetRef 27 ListSetRef
SelectI32 28 SelectI32
SelectI64 29 SelectI64
SelectRef 30 SelectRef
SwitchI32 31 SwitchI32
SwitchI64 32 SwitchI64
SwitchRef 33 SwitchRef
AddI32 34 AddI32
SubI32 35 SubI32
MulI32 36 MulI32
DivI32S 37 DivI32S
DivI32U 38 DivI32U
RemI32S 39 RemI32S
RemI32U 40 RemI32U
FMAI32 41 FMAI32
AbsI32 119 AbsI32
MinI32S 122 MinI32S
MinI32U 123 MinI32U
MaxI32S 124 MaxI32S
MaxI32U 125 MaxI32U
AddI64 42 AddI64
SubI64 43 SubI64
MulI64 44 MulI64
DivI64S 45 DivI64S
DivI64U 46 DivI64U
RemI64S 47 RemI64S
RemI64U 48 RemI64U
FMAI64 49 FMAI64
AbsI64 120 AbsI64
MinI64S 126 MinI64S
MinI64U 127 MinI64U
MaxI64S 128 MaxI64S
MaxI64U 129 MaxI64U
NotI32 50 NotI32
AndI32 51 AndI32
OrI32 52 OrI32
XorI32 53 XorI32
CtlzI32 117 CtlzI32
NotI64 54 NotI64
AndI64 55 AndI64
OrI64 56 OrI64
XorI64 57 XorI64
CtlzI64 118 CtlzI64
ShlI32 58 ShlI32
ShrI32S 59 ShrI32S
ShrI32U 60 ShrI32U
ShlI64 61 ShlI64
ShrI64S 62 ShrI64S
ShrI64U 63 ShrI64U
TruncI32I8 64 TruncI32I8
TruncI32I16 65 TruncI32I16
TruncI64I32 66 TruncI64I32
ExtI8I32S 67 ExtI8I32S
ExtI8I32U 68 ExtI8I32U
ExtI16I32S 69 ExtI16I32S
ExtI16I32U 70 ExtI16I32U
ExtI32I64S 71 ExtI32I64S
ExtI32I64U 72 ExtI32I64U
CastAnyRef 130 CastAnyRef
CmpEQI32 73 CmpEQI32
CmpNEI32 74 CmpNEI32
CmpLTI32S 75 CmpLTI32S
CmpLTI32U 76 CmpLTI32U
CmpNZI32 77 CmpNZI32
CmpEQI64 78 CmpEQI64
CmpNEI64 79 CmpNEI64
CmpLTI64S 80 CmpLTI64S
CmpLTI64U 81 CmpLTI64U
CmpNZI64 82 CmpNZI64
CmpEQRef 83 CmpEQRef
CmpNERef 84 CmpNERef
CmpNZRef 85 CmpNZRef
Branch 86 Branch
CondBranch 87 CondBranch
BranchTable 131 BranchTable
Call 88 Call
CallVariadic 89 CallVariadic
Return 90 Return
Fail 91 Fail
ImportResolved 92 ImportResolved
Yield 93 Yield
Trace 94 Trace
Print 95 Print
CondBreak 96 CondBreak
Break 97 Break
BufferLoadI8U 98 BufferLoadI8U
BufferLoadI8S 99 BufferLoadI8S
BufferLoadI16U 100 BufferLoadI16U
BufferLoadI16S 101 BufferLoadI16S
BufferLoadI32 102 BufferLoadI32
BufferLoadI64 103 BufferLoadI64
BufferStoreI8 104 BufferStoreI8
BufferStoreI16 105 BufferStoreI16
BufferStoreI32 106 BufferStoreI32
BufferStoreI64 107 BufferStoreI64
BufferAlloc 108 BufferAlloc
BufferClone 109 BufferClone
BufferLength 110 BufferLength
BufferFillI8 113 BufferFillI8
BufferFillI16 114 BufferFillI16
BufferFillI32 115 BufferFillI32
BufferFillI64 116 BufferFillI64
BufferCopy 111 BufferCopy
BufferCompare 112 BufferCompare
BufferHash 132 BufferHash
Block 121 Block
PrefixExtF32 224 PrefixExtF32
PrefixExtF64 225 PrefixExtF64

ExtF32Opcodelink

valid VM operation encodings in the f32 extension

Cases:link

Symbol Value String
GlobalLoadF32 0 GlobalLoadF32
GlobalStoreF32 1 GlobalStoreF32
GlobalLoadIndirectF32 2 GlobalLoadIndirectF32
GlobalStoreIndirectF32 3 GlobalStoreIndirectF32
ConstF32Zero 4 ConstF32Zero
ConstF32 5 ConstF32
ListGetF32 6 ListGetF32
ListSetF32 7 ListSetF32
SelectF32 8 SelectF32
SwitchF32 9 SwitchF32
AddF32 10 AddF32
SubF32 11 SubF32
MulF32 12 MulF32
DivF32 13 DivF32
RemF32 14 RemF32
FMAF32 15 FMAF32
AbsF32 16 AbsF32
NegF32 17 NegF32
CeilF32 18 CeilF32
FloorF32 19 FloorF32
RoundF32 54 RoundF32
RoundF32Even 57 RoundF32Even
MinF32 55 MinF32
MaxF32 56 MaxF32
CastSI32F32 20 CastSI32F32
CastSI64F32 60 CastSI64F32
CastUI32F32 21 CastUI32F32
CastF32SI32 22 CastF32SI32
CastF32SI64 58 CastF32SI64
CastF32UI32 23 CastF32UI32
CastF32UI64 59 CastF32UI64
BitcastI32F32 24 BitcastI32F32
BitcastF32I32 25 BitcastF32I32
AtanF32 26 AtanF32
Atan2F32 27 Atan2F32
CosF32 28 CosF32
SinF32 29 SinF32
ExpF32 30 ExpF32
Exp2F32 31 Exp2F32
ExpM1F32 32 ExpM1F32
LogF32 33 LogF32
Log10F32 34 Log10F32
Log1pF32 35 Log1pF32
Log2F32 36 Log2F32
PowF32 37 PowF32
RsqrtF32 38 RsqrtF32
SqrtF32 39 SqrtF32
TanhF32 40 TanhF32
ErfF32 41 ErfF32
CmpEQF32O 42 CmpEQF32O
CmpEQF32U 43 CmpEQF32U
CmpNEF32O 44 CmpNEF32O
CmpNEF32U 45 CmpNEF32U
CmpLTF32O 46 CmpLTF32O
CmpLTF32U 47 CmpLTF32U
CmpLTEF32O 48 CmpLTEF32O
CmpLTEF32U 49 CmpLTEF32U
CmpNaNF32 50 CmpNaNF32
BufferLoadF32 51 BufferLoadF32
BufferStoreF32 52 BufferStoreF32
BufferFillF32 53 BufferFillF32

ExtF64Opcodelink

valid VM operation encodings in the f64 extension

Cases:link

Symbol Value String
GlobalLoadF64 0 GlobalLoadF64
GlobalStoreF64 1 GlobalStoreF64
GlobalLoadIndirectF64 2 GlobalLoadIndirectF64
GlobalStoreIndirectF64 3 GlobalStoreIndirectF64
ConstF64Zero 4 ConstF64Zero
ConstF64 5 ConstF64
ListGetF64 6 ListGetF64
ListSetF64 7 ListSetF64
SelectF64 8 SelectF64
SwitchF64 9 SwitchF64
AddF64 10 AddF64
SubF64 11 SubF64
MulF64 12 MulF64
DivF64 13 DivF64
RemF64 14 RemF64
FMAF64 15 FMAF64
AbsF64 16 AbsF64
NegF64 17 NegF64
CeilF64 18 CeilF64
FloorF64 19 FloorF64
RoundF64 60 RoundF64
RoundF64Even 63 RoundF64Even
MinF64 61 MinF64
MaxF64 62 MaxF64
TruncF64F32 20 TruncF64F32
ExtF32F64 21 ExtF32F64
CastSI32F64 22 CastSI32F64
CastUI32F64 23 CastUI32F64
CastF64SI32 24 CastF64SI32
CastF64UI32 25 CastF64UI32
CastSI64F64 26 CastSI64F64
CastUI64F64 27 CastUI64F64
CastF64SI64 28 CastF64SI64
CastF64UI64 29 CastF64UI64
BitcastI64F64 30 BitcastI64F64
BitcastF64I64 31 BitcastF64I64
AtanF64 32 AtanF64
Atan2F64 33 Atan2F64
CosF64 34 CosF64
SinF64 35 SinF64
ExpF64 36 ExpF64
Exp2F64 37 Exp2F64
ExpM1F64 38 ExpM1F64
LogF64 39 LogF64
Log10F64 40 Log10F64
Log1pF64 41 Log1pF64
Log2F64 42 Log2F64
PowF64 43 PowF64
RsqrtF64 44 RsqrtF64
SqrtF64 45 SqrtF64
TanhF64 46 TanhF64
ErfF64 47 ErfF64
CmpEQF64O 48 CmpEQF64O
CmpEQF64U 49 CmpEQF64U
CmpNEF64O 50 CmpNEF64O
CmpNEF64U 51 CmpNEF64U
CmpLTF64O 52 CmpLTF64O
CmpLTF64U 53 CmpLTF64U
CmpLTEF64O 54 CmpLTEF64O
CmpLTEF64U 55 CmpLTEF64U
CmpNaNF64 56 CmpNaNF64
BufferLoadF64 57 BufferLoadF64
BufferStoreF64 58 BufferStoreF64
BufferFillF64 59 BufferFillF64