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 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.ui32 (VM::CastF32UI32Op)link

Cast from an float-point value to an unsigned 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.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.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.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, 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_ExtF32

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