This page describes the instruction set used in the IAL ISA.
These instructions serve no particular purpose as far as execution goes, but are useful for annotating the instruction stream.
Performs no actual operation. This can be useful to mark regions of code that will be patched later in the compilation process.
These instructions load constant values into registers.
Loads a constant 8-bit signed integer into the target register.
The target register must be of type int8.
Loads a constant 8-bit unsigned integer into the target register.
The target register must be of type uint8.
Loads a constant 16-bit signed integer into the target register.
The target register must be of type int16.
Loads a constant 16-bit unsigned integer into the target register.
The target register must be of type uint16.
Loads a constant 32-bit signed integer into the target register.
The target register must be of type int32.
Loads a constant 32-bit unsigned integer into the target register.
The target register must be of type uint32.
Loads a constant 64-bit signed integer into the target register.
The target register must be of type int64.
Loads a constant 64-bit unsigned integer into the target register.
The target register must be of type uint64.
Loads a constant 32-bit floating-point value into the target register.
The target register must be of type float32.
Loads a constant 64-bit floating-point value into the target register.
The target register must be of type float64.
Loads a constant array of 8-bit signed integers into the target register.
The target register must be of type int8[], int8*, or a vector or static array of int8 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 8-bit unsigned integers into the target register.
The target register must be of type uint8[], uint8*, or a vector or static array of uint8 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 16-bit signed integers into the target register.
The target register must be of type int16[], int16*, or a vector or static array of int16 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 16-bit unsigned integers into the target register.
The target register must be of type uint16[], uint16*, or a vector or static array of uint16 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 32-bit signed integers into the target register.
The target register must be of type int32[], int32*, or a vector or static array of int32 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 32-bit unsigned integers into the target register.
The target register must be of type uint32[], uint32*, or a vector or static array of uint32 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 64-bit signed integers into the target register.
The target register must be of type int64[], int64*, or a vector or static array of int64 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 64-bit unsigned integers into the target register.
The target register must be of type uint64[], uint64*, or a vector or static array of uint64 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 32-bit floating-point values into the target register.
The target register must be of type float32[], float32*, or a vector or static array of float32 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a constant array of 64-bit floating-point values into the target register.
The target register must be of type float64[], float64*, or a vector or static array of float64 with an element count matching that of the array operand.
When the target register is a pointer, the data must be explicitly freed with mem.free. If the given array is of zero length, a null pointer is assigned to the target register.
Loads a function pointer to the given function into the target register.
The target register must be of a function pointer type with a signature that matches the function reference. For example, a function declared as:
function int32 foo(float32, float64)
{
...
}
can be assigned to a register declared as:
register int32(float32, float64) bar;
The target may also have a specified calling convention (cdecl or stdcall), in which case the given function must have a matching calling convention.
Equality for function pointers obtained through this instruction is guaranteed. That is, if a function pointer to a specific function is loaded twice, the two pointers are guaranteed to be equal. Ordering is, however, not guaranteed.
Loads a null value into the target register.
The target register must be a pointer, a function pointer, an array, a vector, or a reference.
Loads the absolute size of a type specification’s layout in memory into the target register.
Note that for vectors, this is not the full size of the vector, but rather the size of the reference to the vector (as with arrays and pointers). For static arrays, this is the full size of the entire array.
The target register must be of type uint.
Loads the alignment of a type specification into the target register.
The target register must be of type uint.
Loads the offset of a field in its containing structure type into the target register.
The target register must be of type uint.
Loads a pointer to a data block into the target register. The pointer should never be explicitly freed and is always valid.
The target register must be of type uint8*.
These instructions provide the basic ALU.
Adds the value in the first source register to the value in the second source register and stores the result in the target register.
This instruction can have one of two forms:
Subtracts the value in the first source register from the value in the second source register and stores the result in the target register.
This instruction can have one of two forms:
Multiplies the value in the first source register with the value in the second source register and stores the result in the target register.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, and float64.
Divides the value in the first source register by the value in the second source register and stores the result in the target register.
If the divisor is zero and the computation involves integers, behavior is undefined. For floating-point types, behavior depends on the machine.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, and float64.
Computes the remainder resulting from dividing the first source register with the second source register and stores the result in the target register.
If the divisor is zero and the computation involves integers, behavior is undefined. For floating-point types, behavior depends on the machine.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, and float64.
Negates the value in the source register and assigns the result to the target register.
Both registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, and float64.
Performs a bit-wise AND operation on the two source registers and assigns the result to the target register.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
Performs a bit-wise OR operation on the two source registers and assigns the result to the target register.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
Performs a bit-wise XOR operation on the two source registers and assigns the result to the target register.
All three registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
Performs a bit-wise complement negation operation on the source register and assigns the result to the target register.
Both registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
Performs a logical negation operation on the source register and assigns the result to the target register.
If the source equals 0, the result is 1. In all other cases, the result is 0.
Both registers must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, and float64.
Shifts the bits of the first source register to the left by the amount given in the second source register and assigns the result to the target register.
If the second source register is larger than or equal to the amount of bits of the first source register’s type, behavior is undefined.
The first register and the target register must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
The second register must be of type uint.
Shifts the bits of the first source register to the right by the amount given in the second source register and assigns the result to the target register.
If the type of the values being shifted is signed, the shift is an arithmetic shift (i.e. it is done with sign extension); otherwise, a logical shift is done (i.e. zero extension is used).
If the second source register is larger than or equal to the amount of bits of the first source register’s type, behavior is undefined.
The first register and the target register must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
The second register must be of type uint.
Rotates the bits of the value in the first source register left by the amount given in the second source register. This is similar to shl, but instead of performing zero extension, the rotated bits are inserted.
If the second source register is larger than or equal to the amount of bits of the first source register’s type, behavior is undefined.
The first register and the target register must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
The second register must be of type uint.
Rotates the bits of the value in the first source register right by the amount given in the second source register. This is similar to shr, but instead of performing zero/sign extension, the rotated bits are inserted.
If the second source register is larger than or equal to the amount of bits of the first source register’s type, behavior is undefined.
The first register and the target register must be of the exact same type. Allowed types are int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, and uint.
The second register must be of type uint.
These instructions are used to allocate and free memory from the system. There are instructions that operate on the native heap and others that operate on the GC-managed heap.
Allocates memory from either the native heap (if the target register is a pointer) or from the GC currently in use (if the target register is an array).
The source register indicates how many elements to allocate memory for. This means that if the target register is a pointer, the total amount of memory allocated is the size of the target register’s element type times the element count. Otherwise, it represents the amount of array elements to be allocated. The source register must be of type uint.
If the target register is a pointer and the source register holds a zero value, the target register is set to a null pointer. For the array case, a zero-sized array will be allocated.
If the requested amount of memory could not be allocated, a null pointer is assigned to the target register; otherwise, the pointer to the allocated memory is assigned.
If the allocation was successful, all allocated memory is guaranteed to be completely zeroed out.
The target register must be a pointer or an array.
Allocates memory from the native heap (if the target register is a pointer) or from the GC currently in use (if the target register is a reference or a vector).
This operation allocates memory for a single fixed-size value. Thus, the the amount of memory allocated is the size of the element type of the target register (for vectors, this includes all elements).
If the requested amount of memory could not be allocated, a null pointer is assigned to the target register; otherwise, the pointer to the allocated memory is assigned.
If the allocation was successful, all allocated memory is guaranteed to be completely zeroed out.
The target register must be a pointer, a reference, or a vector.
Frees the memory pointed to by a pointer previously allocated with either mem.alloc or mem.new.
If the pointer passed in is null, no operation is performed. If the pointer is in some way invalid (e.g. it points to the interior of a block of allocated memory or has never been allocated in the first place), undefined behavior occurs.
This instruction deallocates from the right heap depending on the type of the source register (i.e. the GC-managed heap for arrays, vectors, and references, and the native heap for pointers).
The source register must be a pointer, a reference, an array, or a vector.
When invoking this instruction on a reference, an array, or a vector, it is assumed that the object being freed is only live in the source register, and absolutely nowhere else in the program. This makes this instruction very dangerous to use for managed objects. It is undefined behavior to use memory that has been freed.
Similar to mem.alloc. This instruction, however, allocates the memory on the stack. This means that memory allocated with this instruction shall not be freed manually with mem.free, as the code generator inserts cleanup code automatically.
As with mem.alloc, this instruction assigns a null pointer if the source register holds a value of zero.
If a stack overflow occurs in the allocation, behavior is undefined.
The source register must be of type uint.
The target register must be a pointer.
Similar to mem.new. This instruction, however, allocates the memory on the stack. This means that memory allocated with this instruction shall not be freed manually with mem.free, as the code generator inserts cleanup code automatically.
If a stack overflow occurs in the allocation, behavior is undefined.
The target register must be a pointer.
Pins a reference previously allocated with mem.new or mem.alloc so that the object it points to cannot be relocated by a compacting GC. This is useful when calling into external code via ffi, as the GC cannot track GC-managed memory beyond managed code. This also implies that the memory which is pinned will never be collected until it is unpinned. Therefore, memory leaks can happen if care is not taken to correctly mem.unpin the memory.
Passing a null or already-pinned reference to this instruction results in undefined behavior. The resulting value of this instruction is an opaque handle which only has meaning to the specific GC implementation. The handle is intended for use with mem.unpin later.
The source register must be a reference, an array, or a vector.
The target register must be of type uint.
Unpins memory previously pinned with mem.pin. The source register must be a handle returned by mem.pin. Any invalid handle value will result in undefined behavior (this includes handles already unpinned).
Care should be taken to only unpin the memory once it is certain that the memory is no longer referenced outside managed code. Failure to ensure this can result in undefined behavior.
These instructions can be used for general pointer manipulation, such as dereferencing, setting memory values, etc.
Dereferences the pointer in the source register and assigns the resulting element value to the target register.
If the dereference operation failed in some way (e.g. the source pointer is null or points to invalid memory), undefined behavior occurs.
Dereferencing function pointers is not possible. Doing so by casting a function pointer to a regular pointer results in undefined behavior.
The source register must be a pointer, while the target register must be the element type of the source register’s pointer type.
Sets the value of the memory pointed to by the pointer in the first register to the value of the second register.
If the memory addressing operation failed in some way (e.g. the target pointer is null or points to invalid memory), undefined behavior occurs.
Setting the pointed-to value of function pointers is not possible. Doing so by casting a function pointer to a regular pointer results in undefined behavior.
The first register must be a pointer type, while the second register must be the element type of the first register’s pointer type.
Takes the address of the value in the source register and assigns the address to the target register.
Dereferencing or writing to the resulting address once the current stack frame is no longer valid will result in undefined behavior.
The source register can be of any type, while the target register must be a pointer to the source register’s type.
These instructions are used to index into and manipulate arrays and vectors.
Retrieves the address to the element given in the second source register of the array given in the first source register and assigns it to the target register.
If the source array/vector is null, behavior is undefined. Taking the address of an element beyond the bounds of an array is acceptable, but dereferencing or writing to it results in undefined behavior.
The first source register must be an array, vector, or static array, while the second register must be of type uint.
The target register must be a pointer to the first source register’s element type.
Loads the length of an array into the target register. For arrays, this is the dynamic size, while for vectors and static arrays, it is the fixed size.
If the source array/vector is null, behavior is undefined.
The source register must be an array, vector, or static array.
The target register must be of type uint.
Performs arithmetic addition on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ari.add, and must have the same element type.
If the first source register is an array or vector of a pointer type, the third source register must either be of type uint or an array or vector of these. Otherwise, the third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs arithmetic subtraction on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ari.sub, and must have the same element type.
If the first source register is an array or vector of a pointer type, the third source register must either be of type uint or an array or vector of these. Otherwise, the third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs arithmetic multiplication on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ari.mul, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs arithmetic division on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs. If the divisor is zero and the computation involves integers, behavior is undefined. For floating-point types, behavior depends on the machine.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ari.div, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Computes the remainder resulting from dividing elements of arrays, vectors, or static arrays with the given value(s).
If any of the involved arrays/vectors are null, undefined behavior occurs. If the divisor is zero and the computation involves integers, behavior is undefined. For floating-point types, behavior depends on the machine.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ari.rem, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Negates all elements of an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The two source registers must be arrays, vectors, or static arrays of the types allowed in ari.neg, and must have the same element type.
Performs bit-wise AND on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in bit.and, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs bit-wise OR on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in bit.or, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs bit-wise XOR on elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in bit.xor, and must have the same element type.
The third source register must be of the element type of the first source register, or be an array or vector of the first source register’s element type.
Performs a bit-wise complement negation operation on all elements of an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The two source registers must be arrays, vectors, or static arrays of the types allowed in bit.neg, and must have the same element type.
Performs a logical negation on all elements of an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in not, and must have the same element type.
Performs a left shift of the bits of elements in an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs. If the shift amount is larger than or equal to the amount of bits of the element types involved, behavior is undefined.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in shl, and must have the same element type.
The third source register must be of type uint or an array, vector, or static array of these.
Performs a right shift of the bits of elements in an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs. If the shift amount is larger than or equal to the amount of bits of the element types involved, behavior is undefined.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in shr, and must have the same element type.
The third source register must be of type uint or an array, vector, or static array of these.
Performs a left rotation of bits of the elements in an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs. If the shift amount is larger than or equal to the amount of bits of the element types involved, behavior is undefined.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in rol, and must have the same element type.
The third source register must be of type uint or an array, vector, or static array of these.
Performs a right rotation of bits of the elements in an array, vector, or static array.
If any of the involved arrays/vectors are null, undefined behavior occurs. If the shift amount is larger than or equal to the amount of bits of the element types involved, behavior is undefined.
The first two source registers must be arrays, vectors, or static arrays of the types allowed in ror, and must have the same element type.
The third source register must be of type uint or an array, vector, or static array of these.
Converts elements in the array, vector, or static array in the first source register to the element type of the array, vector, or static array in the second source register and assigns them to the second source register’s elements incrementally.
The following conversions are valid:
If any of the involved arrays/vectors are null, undefined behavior occurs.
See also conv.
Performs a cmp.eq on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
Performs a cmp.neq on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
Performs a cmp.gt on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
Performs a cmp.lt on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
Performs a cmp.gteq on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
Performs a cmp.lteq on all elements of arrays, vectors, or static arrays.
If any of the involved arrays/vectors are null, undefined behavior occurs.
The first source register must be an array, vector, or static array of uint. The second and third source registers must be arrays, vectors, or static arrays having the same element type.
These instructions are used to operate on fields contained in structures types and pointers to them.
Gets the address of the field given as the operand on the structure given in the source register and assigns it to the target register.
If the source register is a reference or a pointer, and is null, behavior is undefined.
Note that if the given structure is in a register with no indirection (i.e. on the stack), dereferencing and writing to the pointer’s address when the current stack frame is no longer valid results in undefined behavior. Also, if the given structure is a reference, the resulting pointer is effectively an interior pointer. This means that reading and writing the memory it points to is only valid while the object it points into is live. Reading or writing to its address when the object is no longer live results in undefined behavior.
The source register must be a structure or a pointer or reference to a structure with at most one indirection.
The target register must be a pointer to the type of the field given in the operand.
Fetches the address of the source register’s header user data field and assigns it to the target register.
If the source register is null, behavior is undefined.
Note that, since the resulting address is effectively an interior pointer, it will only be recognized by the GC in roots. Dereferencing the pointer or writing to its address is only legal while the object it points into is live. Reading or writing to its address when the object is no longer live results in undefined behavior.
The source register must be a reference, an array, or a vector.
The target register must be a pointer to either a reference, an array, or a vector.
Similar to field.addr, but operates on global fields. This means that the instruction does not need an instance of the structure to set the value of the given field.
Pointers to global fields are always valid.
Similar to field.addr, but operates on TLS fields. This means that the instruction does not need an instance of the structure to set the value of the given field.
Pointers to TLS fields are valid so long as the thread owning the field instance that a pointer is pointing to has not exited.
These instructions test relativity of their source registers.
Compares the two source registers for equality. If they are equal, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared for equality).
The target register must be of type uint.
Compares the two source registers for inequality. If they are unequal, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared for equality).
The target register must be of type uint.
Determines if the value in the first source register is greater than the value in the second source register. If this is true, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared).
The target register must be of type uint.
Determines if the value in the first source register is lesser than the value in the second source register. If this is true, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared).
The target register must be of type uint.
Determines if the value in the first source register is greater than or equal to the value in the second source register. If this is true, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared).
The target register must be of type uint.
Determines if the value in the first source register is lesser than or equal to the value in the second source register. If this is true, the target register is set to 1; otherwise, 0.
The source registers must be of the exact same type, and can be one of int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, float32, float64, or any pointer type (in which case the pointers are compared).
The target register must be of type uint.
These instructions are used to call functions and function pointers.
Enqueues the value in the source register into the functiona call argument queue.
This instruction must be immediately followed by another arg.push or any of call, call.tail, call.indirect, invoke, invoke.tail, or invoke.indirect.
The type of the value must equal the type of the function parameter at the same index as this instruction.
Dequeues an argument given to a function. This instruction can only appear in the entry basic block of a function, and must either be the first instruction or come right after a previous arg.pop.
The target register must match the type of the function parameter at the same index as this instruction.
This performs a call to the function given as operand. This instruction expects that the function has a return type (i.e. it does not return void).
This instruction should follow immediately after a correct sequence of arg.push instructions.
The result (as returned by the called function) is assigned to the target register.
The target register’s type must match the given function’s return type.
Works exactly like a call, except that this instruction hints to the code generator that tail call optimization must be done.
This instruction must be immediately followed by a return instruction which must return the resulting value of this call.
Tail calls can only be done in functions with standard calling convention.
Performs a function call like the call instruction, but indirectly.
This instruction must (like call) be immediately preceeded by a correct arg.push sequence matching the function pointer’s signature.
If the given function pointer is null or does not point to a valid function entry point, behavior is undefined.
The result of the call is assigned to the target register.
The source register must be a function pointer to a function returning non-void, and the target register must match the function pointer’s return type.
This instruction does the same thing as call, but only works for functions with no return type (i.e. returning void), and thus has no target register.
This instruction does the same thing as call.tail, but only works for functions with no return type (i.e. returning void), and thus has no target register.
This instruction must be immediately followed by a leave instruction.
Tail calls can only be done in functions with standard calling convention.
This instruction does the same thing as call.indirect, but only works for function pointers with no return type (i.e. returning void), and thus has no target register.
These instructions are used to transfer control from one point in a program to another. Most are generally terminator instructions.
Performs an unconditional jump to the specified basic block.
This is a terminator instruction.
Performs a jump to the first basic block if the value in the source register does not equal 0; otherwise, jumps to the second basic block.
The source register must be of type uint.
This is a terminator instruction.
Leaves (i.e. returns from) the current function. This is only valid if the function returns void (or, in other words, has no return type).
Using this instruction in a noreturn function results in undefined behavior.
This is a terminator instruction.
Returns from the current function with the value in the source register as the return value. This is only valid in functions that don’t return void (i.e. have a return type).
Using this instruction in a noreturn function results in undefined behavior.
The source register must be the exact same type as the function’s return type.
This is a terminator instruction.
Informs the optimizer of a branch that can safely be assumed unreachable (and thus optimized out). Any code following this instruction is assumed to be dead.
This is a terminator instruction.
This instruction is used while the code is in SSA form. Due to the nature of SSA, it is often necessary to determine which register to use based on where control flow came from. This instruction picks the register which was assigned in the basic block control flow entered from and assigns it to the target register.
This instruction is valid only during analysis and optimization. It must not appear in code passed to the interpreter or JIT/AOT engines.
The target register and selector registers must all be of the same type.
Note that this instruction doesn’t count as a control flow instruction. That is to say, multiple phi instructions are allowed in a basic block while in SSA form, and they do not act as terminators.
This instruction tells the code generator to insert raw machine code (which is given as the byte array operand) in the generated machine code stream. This must be the only instruction in a raw function.
This instruction has a few consequences:
Of course, usage of this instruction results in unportable code.
This instruction is primarily intended to allow the implementation of inline assembly in high-level languages. Arguments given to raw functions are passed according to the calling convention of the function and the return value (if any) should be passed according to the calling convention too.
It should be noted that this is not sufficient to implement full-blown inline assembly as in many C and C++ compilers. A general requirement of inline assembly using this instruction is that the raw blob must contain code that is neutral to relocations, as it is not in any way guaranteed where the code blob will be emitted in memory.
If the raw machine code returns and the function is marked noreturn, undefined behavior results.
This is a terminator instruction.
This instruction marks the function as an FFI function. FFI functions must only contain this one instruction, which points the code generator to the actual function entry point in a native library.
This instruction has a few consequences:
Note that the native function isn’t linked to statically. The execution engine (either the interpreter or the JIT/AOT engines) will attempt to locate the native entry point when the FFI function is called.
If the native function returns and the function is marked noreturn, undefined behavior results.
This is a terminator instruction.
This instruction marks a function as a reference. This means that, when a call to the function containing this instruction is made, the execution engine will forward it to a function in another module, as specified in the signature in the operand.
The operand must point to a function with standard calling convention in a managed MCI module. The module name should not contain the file extension; only the base name.
The function, when located in the specified module, is expected to have the exact same return type, parameter types, and attributes as the function this instruction is used in. If it does not, a runtime error results.
Note that using forwarded functions results in some classes of optimizations (e.g. inlining) being disabled for calls to such functions.
This is a terminator instruction.
These are used to indicate and handle errors.
Throws an exception. This causes the runtime to unwind the stack until an appropriate unwind block is found. If an unwind block is found, control transfers to that block. If none is found, the program is terminated.
If the given reference is null, behavior is undefined.
The source register must be a reference.
This is a terminator instruction.
Rethrows an in-flight exception. This is different from using eh.throw to rethrow an exception reference in that this instruction does not reset the stack trace.
This instruction may only appear in unwind blocks.
This is a terminator instruction.
This catches the current in-flight exception and assigns it to the target register. Note that this is not type-safe; it’s similar to casting one reference type to another with conv. In order to determine the exact exception type, language/ABI-specific checks must be made.
This instruction may only appear in unwind blocks.
The target register must be a reference.
Instructions that don’t quite fit anywhere else.
This instruction copies the value in the source register into the target register. This is similar to a simple assignment in most programming languages; it is not a deep copy.
This instruction is not valid in SSA form.
The source register’s type must match the target register’s type.
Converts the value in the source register from one type to another, and assigns the resulting value to the target register.
The following conversions are valid:
Inserts a full read/write memory barrier. This ensures that all loads and stores prior to this instruction will always be executed before loads and stores following this instruction. This is particularly useful in lock-free data structures and similar low-level constructs.
Constructs a trampoline for a given function pointer. Trampolines are useful if the function pointer is to be passed to external code (e.g. via ffi) which might use the function pointer in threads not registered with the MCI. The generated trampoline will ensure that such an external thread is correctly registered before allowing it to call into managed code.
The source register must be any function pointer type. The target register must be a function pointer type with cdecl or stdcall calling convention matching the parameters and return type of the source register.