IndexUniversal JIT

Universal JIT [¶]

Universal JIT abstracts X86, X86_64, and AArch64 code generation.

Overview

Universal JIT (UJIT) is an abstraction that uses AsmJit's Compiler, but provides target independent API that users can use to target multiple target architectures at a time. The goal of Universal JIT is not to provide its own IR. Instead, it translates user calls into target-dependent instructions (or instruction sequences) and allows users to switch to target-specific assembly only where required for extra performance.

Warning

UJIT is still in an experimental phase, expect minor API breaks in the future especially towards API stabilization.

API Overview

Compiler:

Operands:

Conditions:

Instructions:

UniCompiler Example

Using UniCompiler is like using a regular platform-dependent AsmJit's Compiler - UniCompiler wraps its API and delegates most of non-emit calls to Compiler, however, it abstracts how instructions are emitted so it could offer universal API for both general-purpose and SIMD instructions. The following example demonstrates how to use it:

#include <asmjit/ujit.h>
#include <stdio.h>
using namespace asmjit;
int main() {
// Signature of the generated function.
using Func = void (*)(uint32_t* dst, const uint32_t* src1, const uint32_t* src2);
JitRuntime rt; // Creates a JIT runtime that holds executable code.
FileLogger logger(stdout); // Creates a logger that prints to stdout.
CodeHolder code; // Creates a CodeHolder - holds code and other information.
code.init(rt.environment(), // Initializes CodeHolder to match the JIT environment.
rt.cpu_features());
code.set_logger(&logger); // Initializes CodeHolder's logger.
ujit::BackendCompiler backend_cc(&code); // Creates a regular backend compiler instance.
ujit::UniCompiler uc(&backend_cc, // Creates UniCompiler with attached backend compiler.
rt.cpu_features(), // CPU features must be passed explicitly.
rt.cpu_hints()); // CPU hints must be passed explicitly.
// Begin a function of the required signature (this exactly matches the Compiler use).
ujit::Gp d_ptr = uc.new_gp_ptr(); // Creates a destination pointer.
ujit::Gp a_ptr = uc.new_gp_ptr(); // Creates a first source pointer.
ujit::Gp b_ptr = uc.new_gp_ptr(); // Creates a second source pointer.
func->set_arg(0, d_ptr); // Assigns 1st argument.
func->set_arg(1, a_ptr); // Assigns 2nd argument.
func->set_arg(2, b_ptr); // Assigns 3rd argument.
ujit::Vec v0 = uc.new_vec128(); // Creates a 128-bit vector register.
ujit::Vec v1 = uc.new_vec128(); // Creates a 128-bit vector register.
uc.v_loadu128(v0, ujit::mem_ptr(a_ptr)); // Unaligned load of 128 bits from [a_ptr] into v0.
uc.v_loadu128(v1, ujit::mem_ptr(b_ptr)); // Unaligned load of 128 bits from [b_ptr] into v1.
uc.v_add_i32(v0, v0, v1); // Vector addition of 4 32-bit integers.
uc.v_storeu128(ujit::mem_ptr(d_ptr), v0);// Unaligned store of 128 bits from v0 to [d_ptr].
uc.end_func(); // End of the function body.
Error err1 = uc.finalize(); // Translates and assembles the whole 'backend_cc' content.
if (err1 != Error::kOk) {
// Handle a possible error returned by AsmJit as finalize can fail. One reason could be wrong operands
// to some instruction or other platform constraints. Usually UniCompiler handles most of platform
// constraints by itself, but this error code must be checked regardless.
return 1;
}
// ----> Both BackendCompiler and UniCompiler are no longer needed from here and can be destroyed <----
Func fn;
Error err2 = rt.add(&fn, &code); // Add the generated code to JIT runtime (executable memory).
if (err2 != Error::kOk) {
// Handle a possible error returned by AsmJit. This would be either out of executable memory or failure
// to allocate it (for example excessive user-space hardening or making the allocation of executable
// memory forbidden).
return 1;
}
// ----> CodeHolder is no longer needed from here and can be destroyed <----
// Input data.
static constexpr uint32_t a_data[4] = {1u,2u,4u,8u};
static constexpr uint32_t b_data[4] = {6u,4u,3u,1u};
// Output data.
uint32_t d_data[4] {};
// Calls the generated function.
fn(d_data, a_data, b_data);
// Prints both inputs and the output.
printf("a_data={%u,%u,%u,%u}\n", a_data[0], a_data[1], a_data[2], a_data[3]);
printf("b_data={%u,%u,%u,%u}\n", b_data[0], b_data[1], b_data[2], b_data[3]);
printf("d_data={%u,%u,%u,%u}\n", d_data[0], d_data[1], d_data[2], d_data[3]);
// Explicitly removes the function from JIT runtime.
rt.release(fn);
return 0;
}

Emitting Backend-Specific Code

In cases, in which backend-specific code is required for performance reasons, it's possible to use the underlying backend-specific Compiler, which is provided as a cc member of UniCompiler. The next example demonstrates how to use AArch64-specific code path during code generation:

#include <asmjit/ujit.h>
using namespace asmjit;
void emit_backend_specific_code(UniCompiler& uc, const ujit::Gp& a, const ujit::Gp& b, const ujit::Gp& c) {
#if defined(ASMJIT_UJIT_AARCH64)
// Emit aarch64 specific code via `uc.cc`:
uc.cc->orn(a, b, c);
#else
// Generic code.
ujit::Gp tmp = uc.new_similar_reg(a);
uc.not_(tmp, c);
uc.or_(a, b, tmp);
#endif

Namespaces

Typedefs

Enumerations

Functions

Variables

using ujit::BackendCompiler = host::Compiler[¶]

Backend compiler is simply an alias to a host::Compiler, which would be used by UniCompiler.

using ujit::CondCode = host::CondCode[¶]

Condition code is simply an alias to a host::CondCode.

using ujit::Mem = host::Mem[¶]

Target memory operand.

using ujit::Gp = host::Gp[¶]

Target general-purpose register.

using ujit::Vec = host::Vec[¶]

Target vector register.

ujit::Alignment : uint32_tenum class[¶]

Data alignment.

ujit::ScalarOpBehavior : uint8_tenum class[¶]

The behavior of a floating point scalar operation.

ConstantDescription
kZeroing 

The rest of the elements are zeroed, only the first element would contain the result (AArch64).

kPreservingVec128 

The rest of the elements are unchanged, elements above 128-bits are zeroed.

ujit::FloatToIntOutsideRangeBehavior : uint8_tenum class[¶]

The behavior of floating point to int conversion.

ConstantDescription
kSmallestValue 

In case that the floating point is outside of the integer range, the value is the smallest integer value, which would be 0x80, 0x8000, 0x80000000, or 0x8000000000000000 depending on the target integer width.

kSaturatedValue 

In case that the floating point is outside of the integer range, the resulting integer will be saturated. If the floating point is NaN, the resulting integer value would be zero.

ujit::FMinFMaxOpBehavior : uint8_tenum class[¶]

The behavior of a floating point min/max instructions when comparing against NaN.

ConstantDescription
kFiniteValue 

Min and max selects a finite value if one of the compared values is NaN.

kTernaryLogic 

Min and max is implemented like if a <|> b ? a : b.

ujit::FMAddOpBehavior : uint8_tenum class[¶]

The behavior of floating point madd instructions.

ConstantDescription
kNoFMA 

FMA is not available, thus madd is translated into two instructions (MUL + ADD).

kFMAStoreToAny 

FMA is available, the ISA allows to store the result to any of the inputs (X86|X86_64).

kFMAStoreToAccumulator 

FMA is available, the ISA always uses accumulator register as a destination register (AArch64).

ujit::DataWidth : uint8_tenum class[¶]

SIMD data width.

ConstantDescription
k8 

8-bit elements.

k16 

16-bit elements.

k32 

32-bit elements.

k64 

64-bit elements or 64-bit wide data is used.

k128 

128-bit elements or 128-bit wide data is used.

ujit::VecWidth : uint8_tenum class[¶]

Vector register width.

ConstantDescription
k128 

128-bit vector register (baseline, SSE/AVX, NEON, etc...).

k256 

256-bit vector register (AVX2+).

k512 

512-bit vector register (AVX512_DQ & AVX512_BW & AVX512_VL).

k1024 

1024-bit vector register (no backend at the moment).

ujit::Bcst : uint8_tenum class[¶]

Broadcast width.

ConstantDescription
k8 

Broadcast 8-bit elements.

k16 

Broadcast 16-bit elements.

k32 

Broadcast 32-bit elements.

k64 

Broadcast 64-bit elements.

ujit::UniOpCond : uint32_tenum class[¶]

Instruction that can be used by UniCondition.

ConstantDescription
kAssignAnd 

Assign-and a &= b.

kAssignOr 

Assign-or a |= b.

kAssignXor 

Assign-xor a ^= b.

kAssignAdd 

Assign-add a += b.

kAssignSub 

Assign-sub a -= b.

kAssignShr 

Assign-shr a >>= b.

kTest 

Test a & b.

kBitTest 

Bit-test a & (1 << b).

kCompare 

Compare a <=> b.

ujit::UniOpM : uint32_tenum class[¶]

Instruction with a single memory operand.

ConstantDescription
kPrefetch 

Explicitly prefetch memory for reading (can be implemented as NOP).

kStoreZeroReg 

Store zero (data-width depends on register size).

kStoreZeroU8 

Store zero (8-bit).

kStoreZeroU16 

Store zero (16-bit).

kStoreZeroU32 

Store zero (32-bit).

kStoreZeroU64 

Store zero (64-bit).

ujit::UniOpRM : uint32_tenum class[¶]

Instruction with [reg, mem] operands.

ConstantDescription
kLoadReg 

N-bit load (the size depends on the register size).

kLoadI8 

8-bit load, sign extended.

kLoadU8 

8-bit load, zero extended.

kLoadI16 

16-bit load, sign extended.

kLoadU16 

16-bit load, zero extended.

kLoadI32 

32-bit load, sign extended.

kLoadU32 

32-bit load, zero extended.

kLoadI64 

64-bit load.

kLoadU64 

64-bit load.

kLoadMergeU8 

8-bit load and merge.

kLoadShiftU8 

8-bit load, shift, and merge.

kLoadMergeU16 

16-bit load and merge.

kLoadShiftU16 

16-bit load, shift, and merge.

ujit::UniOpMR : uint32_tenum class[¶]

Instruction with [mem, reg] operands.

ConstantDescription
kStoreReg 

N-bit store (the size depends on the register size).

kStoreU8 

8-bit store.

kStoreU16 

16-bit store.

kStoreU32 

32-bit store.

kStoreU64 

64-bit store.

kAddReg 

N-bit load+add+store (the size depends on the register size).

kAddU8 

8-bit load+add+store.

kAddU16 

16-bit load+add+store.

kAddU32 

32-bit load+add+store.

kAddU64 

64-bit load+add+store.

ujit::UniOpRR : uint32_tenum class[¶]

Instruction with [reg, reg] operands.

Arithmetic operations having 2 operands (dst, src).

Note

For convenience, the second operand can be register, memory, or immediate value.

ConstantDescription
kAbs 

Absolute value of a signed integer - dst = abs(src).

kNeg 

Arithmetic negation - dst = -src (dst = ~src + 1).

kNot 

Bitwise-not - dst = ~src.

kBSwap 

Byteswap - dst = bswap(src).

kCLZ 

Count leading zeros - dst = clz(src).

kCTZ 

Count trailing zeros - dst = ctz(src).

kReflect 

Integer reflection.

ujit::UniOpRRR : uint32_tenum class[¶]

Instruction with [reg, reg, reg] operands.

Arithmetic operation having 3 operands (dst, src1, src2).

Note

For convenience, the third operand can be register, memory, or immediate value.

ConstantDescription
kAnd 

Bitwise AND dst = src1 & src2.

kOr 

Bitwise OR dst = src1 | src2.

kXor 

Bitwise XOR dst = src1 ^ src2.

kBic 

Bitwise BIC dst = src1 & ~src2.

kAdd 

Add dst = src1 + src2.

kSub 

Subtract dst = src1 - src2.

kMul 

Multiply dst = src1 * src2.

kUDiv 

Unsigned divide dst = src1 / src2.

kUMod 

Unsigned modulo dst = src1 & src2.

kSMin 

Signed minimum dst = smin(src1, src2).

kSMax 

Signed maximum dst = smax(src1, src2).

kUMin 

Unsigned minimum dst = umin(src1, src2).

kUMax 

Unsigned maximum dst = umax(src1, src2).

kSll 

Shift left logical dst = src1 << src2.

kSrl 

Shift left logical dst = src1 >> src2.

kSra 

Shift left logical dst = sra(src1, src2).

kRol 

Rotate left dst = (src1 << src2) | (src1 >> (N_BITS - src2)).

kRor 

Rotate right dst = (src1 >> src2) | (src1 << (N_BITS - src2)).

kSBound 

Signed bounds.

ujit::UniOpVR : uint32_tenum class[¶]

Instruction with [vec, reg] operands.

Describes instructions where general-purpose is either moved, converted, or inserted to a vector register.

ConstantDescription
kMov 

N-bit move into a vector register (the size depends on source register width).

kMovU32 

32-bit move into a vector register.

kMovU64 

64-bit move into a vector register.

kInsertU8 

8-bit insertion into a vector register.

kInsertU16 

16-bit insertion into a vector register.

kInsertU32 

32-bit insertion into a vector register.

kInsertU64 

64-bit insertion into a vector register.

kExtractU8 

8-bit extraction from a vector register.

kExtractU16 

16-bit extraction from a vector register.

kExtractU32 

32-bit extraction from a vector register.

kExtractU64 

64-bit extraction from a vector register.

kCvtIntToF32 

Int to float32 conversion.

kCvtIntToF64 

Int to float64 conversion.

kCvtTruncF32ToInt 

Float32 to int conversion with truncation semantics.

kCvtRoundF32ToInt 

Float64 to int conversion with round-to-even semantics.

kCvtTruncF64ToInt 

Float32 to int conversion with truncation semantics.

kCvtRoundF64ToInt 

Float64 to int conversion with round-to-even semantics.

ujit::UniOpVM : uint32_tenum class[¶]

Instruction with [vec, mem] operands.

Describes load, convert, and insert instructions.

ConstantDescription
kLoad8 

8-bit load into a vector register (the rest is cleared).

kLoad16_U16 

16-bit load into a vector register (the rest is cleared).

kLoad32_U32 

32-bit load (int) into a vector register (the rest is cleared).

kLoad32_F32 

32-bit load (f32) into a vector register (the rest is cleared).

kLoad64_U32 

32-bit load (int) into a vector register (the rest is cleared).

kLoad64_U64 

64-bit load (int) into a vector register (the rest is cleared).

kLoad64_F32 

32-bit load (f32) into a vector register (the rest is cleared).

kLoad64_F64 

64-bit load (f64) into a vector register (the rest is cleared).

kLoad128_U32 

128-bit load (int) into a vector register (the rest is cleared).

kLoad128_U64 

128-bit load (int) into a vector register (the rest is cleared).

kLoad128_F32 

128-bit load (f32) into a vector register (the rest is cleared).

kLoad128_F64 

128-bit load (f64) into a vector register (the rest is cleared).

kLoad256_U32 

256-bit load (int) into a vector register (the rest is cleared).

kLoad256_U64 

256-bit load (int) into a vector register (the rest is cleared).

kLoad256_F32 

256-bit load (f32) into a vector register (the rest is cleared).

kLoad256_F64 

256-bit load (f64) into a vector register (the rest is cleared).

kLoad512_U32 

512-bit load (int) into a vector register (the rest is cleared).

kLoad512_U64 

512-bit load (int) into a vector register (the rest is cleared).

kLoad512_F32 

512-bit load (f32) into a vector register (the rest is cleared).

kLoad512_F64 

512-bit load (f64) into a vector register (the rest is cleared).

kLoadN_U32 

N-bit load (int) into a vector register (the size depends on the vector width).

kLoadN_U64 

N-bit load (int) into a vector register (the size depends on the vector width).

kLoadN_F32 

N-bit load (f32) into a vector register (the size depends on the vector width).

kLoadN_F64 

N-bit load (f64) into a vector register (the size depends on the vector width).

kLoadCvt16_U8ToU64 

16-bit load into a vector register with 8-bit to 64-bit zero extension (128-bit result).

kLoadCvt32_U8ToU64 

32-bit load into a vector register with 8-bit to 64-bit zero extension (256-bit result).

kLoadCvt64_U8ToU64 

64-bit load into a vector register with 8-bit to 64-bit zero extension (512-bit result).

kLoadCvt32_I8ToI16 

32-bit load into a vector register with 8-bit to 16-bit sign extension (64-bit result).

kLoadCvt32_U8ToU16 

32-bit load into a vector register with 8-bit to 16-bit zero extension (64-bit result).

kLoadCvt32_I8ToI32 

32-bit load into a vector register with 8-bit to 32-bit sign extension (128-bit result).

kLoadCvt32_U8ToU32 

32-bit load into a vector register with 8-bit to 32-bit zero extension (128-bit result).

kLoadCvt32_I16ToI32 

32-bit load into a vector register with 16-bit to 32-bit sign extension (64-bit result).

kLoadCvt32_U16ToU32 

32-bit load into a vector register with 16-bit to 32-bit zero extension (64-bit result).

kLoadCvt32_I32ToI64 

32-bit load into a vector register with 32-bit to 64-bit sign extension (64-bit result).

kLoadCvt32_U32ToU64 

32-bit load into a vector register with 32-bit to 64-bit zero extension (64-bit result).

kLoadCvt64_I8ToI16 

64-bit load into a vector register with 8-bit to 16-bit sign extension (128-bit result).

kLoadCvt64_U8ToU16 

64-bit load into a vector register with 8-bit to 16-bit zero extension (128-bit result).

kLoadCvt64_I8ToI32 

64-bit load into a vector register with 8-bit to 32-bit sign extension (256-bit result).

kLoadCvt64_U8ToU32 

64-bit load into a vector register with 8-bit to 32-bit zero extension (256-bit result).

kLoadCvt64_I16ToI32 

64-bit load into a vector register with 16-bit to 32-bit sign extension (128-bit result).

kLoadCvt64_U16ToU32 

64-bit load into a vector register with 16-bit to 32-bit zero extension (128-bit result).

kLoadCvt64_I32ToI64 

64-bit load into a vector register with 32-bit to 64-bit sign extension (128-bit result).

kLoadCvt64_U32ToU64 

64-bit load into a vector register with 32-bit to 64-bit zero extension (128-bit result).

kLoadCvt128_I8ToI16 

128-bit load into a vector register with 8-bit to 16-bit sign extension (256-bit result).

kLoadCvt128_U8ToU16 

128-bit load into a vector register with 8-bit to 16-bit zero extension (256-bit result).

kLoadCvt128_I8ToI32 

128-bit load into a vector register with 8-bit to 32-bit sign extension (512-bit result).

kLoadCvt128_U8ToU32 

128-bit load into a vector register with 8-bit to 32-bit zero extension (512-bit result).

kLoadCvt128_I16ToI32 

128-bit load into a vector register with 16-bit to 32-bit sign extension (256-bit result).

kLoadCvt128_U16ToU32 

128-bit load into a vector register with 16-bit to 32-bit zero extension (256-bit result).

kLoadCvt128_I32ToI64 

128-bit load into a vector register with 32-bit to 64-bit sign extension (256-bit result).

kLoadCvt128_U32ToU64 

128-bit load into a vector register with 32-bit to 64-bit zero extension (256-bit result).

kLoadCvt256_I8ToI16 

256-bit load into a vector register with 8-bit to 16-bit sign extension (512-bit result).

kLoadCvt256_U8ToU16 

256-bit load into a vector register with 8-bit to 16-bit zero extension (512-bit result).

kLoadCvt256_I16ToI32 

256-bit load into a vector register with 16-bit to 32-bit sign extension (512-bit result).

kLoadCvt256_U16ToU32 

256-bit load into a vector register with 16-bit to 32-bit zero extension (512-bit result).

kLoadCvt256_I32ToI64 

256-bit load into a vector register with 32-bit to 64-bit sign extension (512-bit result).

kLoadCvt256_U32ToU64 

256-bit load into a vector register with 32-bit to 64-bit zero extension (512-bit result).

kLoadCvtN_U8ToU64 

N-bit load with 8-bit to 64-bit zero extension (the size depends on the vector width).

kLoadCvtN_I8ToI16 

N-bit load with 8-bit to 16-bit sign extension (the size depends on the vector width).

kLoadCvtN_U8ToU16 

N-bit load with 8-bit to 16-bit zero extension (the size depends on the vector width).

kLoadCvtN_I8ToI32 

N-bit load with 8-bit to 32-bit sign extension (the size depends on the vector width).

kLoadCvtN_U8ToU32 

N-bit load with 8-bit to 32-bit zero extension (the size depends on the vector width).

kLoadCvtN_I16ToI32 

N-bit load with 16-bit to 32-bit sign extension (the size depends on the vector width).

kLoadCvtN_U16ToU32 

N-bit load with 16-bit to 32-bit zero extension (the size depends on the vector width).

kLoadCvtN_I32ToI64 

N-bit load with 32-bit to 64-bit sign extension (the size depends on the vector width).

kLoadCvtN_U32ToU64 

N-bit load with 32-bit to 64-bit zero extension (the size depends on the vector width).

kLoadInsertU8 

8-bit insert (int) into a vector register from memory.

kLoadInsertU16 

16-bit insert (int) into a vector register from memory.

kLoadInsertU32 

32-bit insert (int) into a vector register from memory.

kLoadInsertU64 

64-bit insert (int) into a vector register from memory.

kLoadInsertF32 

32-bit insert (f32) into a vector register from memory.

kLoadInsertF32x2 

64-bit insert (f32x2) into a vector register from memory.

kLoadInsertF64 

64-bit insert (f64) into a vector register from memory.

ujit::UniOpMV : uint32_tenum class[¶]

Instruction with [mem, vec] operands.

Describes store and extract instructions.

ConstantDescription
kStore8 

8-bit store (int) of a vector register.

kStore16_U16 

16-bit store (int) of a vector register.

kStore32_U32 

16-bit store (int) of a vector register.

kStore32_F32 

16-bit store (f32) of a vector register.

kStore64_U32 

64-bit store (int) of a vector register.

kStore64_U64 

64-bit store (int) of a vector register.

kStore64_F32 

64-bit store (f32) of a vector register.

kStore64_F64 

64-bit store (f64) of a vector register.

kStore128_U32 

128-bit store (int) of a vector register.

kStore128_U64 

128-bit store (int) of a vector register.

kStore128_F32 

128-bit store (f32) of a vector register.

kStore128_F64 

128-bit store (f64) of a vector register.

kStore256_U32 

256-bit store (int) of a vector register.

kStore256_U64 

256-bit store (int) of a vector register.

kStore256_F32 

256-bit store (f32) of a vector register.

kStore256_F64 

256-bit store (f64) of a vector register.

kStore512_U32 

512-bit store (int) of a vector register.

kStore512_U64 

512-bit store (int) of a vector register.

kStore512_F32 

512-bit store (f32) of a vector register.

kStore512_F64 

512-bit store (f64) of a vector register.

kStoreN_U32 

N-bit store (int) of a vector register (the size depends on the vector width).

kStoreN_U64 

N-bit store (int) of a vector register (the size depends on the vector width).

kStoreN_F32 

N-bit store (f32) of a vector register (the size depends on the vector width).

kStoreN_F64 

N-bit store (f64) of a vector register (the size depends on the vector width).

kStoreExtractU16 

16-bit extract from lane and store.

kStoreExtractU32 

32-bit extract from lane and store.

kStoreExtractU64 

64-bit extract from lane and store.

ujit::UniOpVV : uint32_tenum class[¶]

Instruction with [vec, vec] operands.

Describes vector arithmetic that has one destination and one source.

Note

For convenience, the second operand can be register, memory, or immediate value.

ConstantDescription
kMov 

Vector move.

kMovU64 

Vector move of the low 64-bit data, the rest is set to zero.

kBroadcastU8Z 

Vector u8 broadcast with an assumption that the rest of the source vector is zero.

kBroadcastU16Z 

Vector u16 broadcast with an assumption that the rest of the source vector is zero.

kBroadcastU8 

Vector u8 broadcast to all lanes.

kBroadcastU16 

Vector u16 broadcast to all lanes.

kBroadcastU32 

Vector u32 broadcast to all lanes.

kBroadcastU64 

Vector u64 broadcast to all lanes.

kBroadcastF32 

Vector f32 broadcast to all lanes.

kBroadcastF64 

Vector f64 broadcast to all lanes.

kBroadcastV128_U32 

Vector broadcast of 128-bit lanes.

kBroadcastV128_U64 

Vector broadcast of 128-bit lanes.

kBroadcastV128_F32 

Vector broadcast of 128-bit lanes.

kBroadcastV128_F64 

Vector broadcast of 128-bit lanes.

kBroadcastV256_U32 

Vector broadcast of 256-bit lanes.

kBroadcastV256_U64 

Vector broadcast of 256-bit lanes.

kBroadcastV256_F32 

Vector broadcast of 256-bit lanes.

kBroadcastV256_F64 

Vector broadcast of 256-bit lanes.

kAbsI8 

Vector i8 absolute value - dst = abs(src).

kAbsI16 

Vector i16 absolute value - dst = abs(src).

kAbsI32 

Vector i32 absolute value - dst = abs(src).

kAbsI64 

Vector i64 absolute value - dst = abs(src).

kNotU32 

Vector u32 bitwise NOT - dst = ~src.

kNotU64 

Vector u64 bitwise NOT - dst = ~src.

kCvtI8LoToI16 

Vector sign extend low i8 to i16.

kCvtI8HiToI16 

Vector sign extend high i8 to i16.

kCvtU8LoToU16 

Vector zero extend low u8 to u16.

kCvtU8HiToU16 

Vector zero extend high u8 to u16.

kCvtI8ToI32 

Vector zero extend low i8 to i32.

kCvtU8ToU32 

Vector zero extend high u8 to u32.

kCvtI16LoToI32 

Vector sign extend low i16 to i32.

kCvtI16HiToI32 

Vector sign extend high i16 to i32.

kCvtU16LoToU32 

Vector zero extend low u16 to u32.

kCvtU16HiToU32 

Vector zero extend high u16 to u32.

kCvtI32LoToI64 

Vector sign extend low i32 to i64.

kCvtI32HiToI64 

Vector sign extend high i32 to i64.

kCvtU32LoToU64 

Vector zero extend low u32 to u64.

kCvtU32HiToU64 

Vector zero extend high u32 to u64.

kAbsF32S 

Scalar f32 absolute value.

kAbsF64S 

Scalar f64 absolute value.

kAbsF32 

Vector f32 absolute value.

kAbsF64 

Vector f64 absolute value.

kNegF32S 

Scalar f32 negate.

kNegF64S 

Scalar f64 negate.

kNegF32 

Vector f32 negate.

kNegF64 

Vector f64 negate.

kNotF32 

Vector f32 bitwise NOT.

kNotF64 

Vector f64 bitwise NOT.

kTruncF32S 

Scalar f32 truncate.

kTruncF64S 

Scalar f64 truncate.

kTruncF32 

Vector f32 truncate.

kTruncF64 

Vector f64 truncate.

kFloorF32S 

Scalar f32 floor.

kFloorF64S 

Scalar f64 floor.

kFloorF32 

Vector f32 floor.

kFloorF64 

Vector f64 floor.

kCeilF32S 

Scalar f32 ceil.

kCeilF64S 

Scalar f64 ceil.

kCeilF32 

Vector f32 ceil.

kCeilF64 

Vector f64 ceil.

kRoundEvenF32S 

Scalar f32 round-even.

kRoundEvenF64S 

Scalar f64 round-even.

kRoundEvenF32 

Vector f32 round-even.

kRoundEvenF64 

Vector f64 round-even.

kRoundHalfAwayF32S 

Scalar f32 round-half-away (0.5 and greater fraction rounds away from zero).

kRoundHalfAwayF64S 

Scalar f64 round-half-away (0.5 and greater fraction rounds away from zero).

kRoundHalfAwayF32 

Vector f32 round-half-away (0.5 and greater fraction rounds away from zero).

kRoundHalfAwayF64 

Vector f64 round-half-away (0.5 and greater fraction rounds away from zero).

kRoundHalfUpF32S 

Scalar f32 round-half-up (0.5 and greater fraction rounds up).

kRoundHalfUpF64S 

Scalar f64 round-half-up (0.5 and greater fraction rounds up).

kRoundHalfUpF32 

Vector f32 round-half-up (0.5 and greater fraction rounds up).

kRoundHalfUpF64 

Vector f64 round-half-up (0.5 and greater fraction rounds up).

kRcpF32 

Vector f32 reciprocal - dst = 1.0 / src.

kRcpF64 

Vector f64 reciprocal - dst = 1.0 / src.

kSqrtF32S 

Scalar f32 square root.

kSqrtF64S 

Scalar f64 square root.

kSqrtF32 

Vector f32 square root.

kSqrtF64 

Vector f64 square root.

ujit::UniOpVVI : uint32_tenum class[¶]

Instruction with [vec, vec, imm] operands.

Describes vector arithmetic that has one destination, one source, and one immediate.

Note

For convenience, the second operand can be register, memory, or immediate value.

ConstantDescription
kSllU16 

Vector u16 shift left logical.

kSllU32 

Vector u32 shift left logical.

kSllU64 

Vector u64 shift left logical.

kSrlU16 

Vector u16 shift right logical.

kSrlU32 

Vector u32 shift right logical.

kSrlU64 

Vector u64 shift right logical.

kSraI16 

Vector u16 shift right arithmetic.

kSraI32 

Vector u32 shift right arithmetic.

kSraI64 

Vector u64 shift right arithmetic.

kSllbU128 

Vector shift bytes (128-bit lanes).

kSrlbU128 

Vector shift bytes (128-bit lanes).

kSwizzleU16x4 

Vector swizzle u16x4 (128-bit lanes).

kSwizzleLoU16x4 

Vector swizzle u16x4 (low 64-bit lanes).

kSwizzleHiU16x4 

Vector swizzle u16x4 (high 64-bit lanes)

kSwizzleU32x4 

Vector swizzle u32x4 (128-bit lanes).

kSwizzleU64x2 

Vector swizzle u64x2 (128-bit lanes).

kSwizzleF32x4 

Vector swizzle f32x4 (128-bit lanes).

kSwizzleF64x2 

Vector swizzle f64x2 (128-bit lanes).

kSwizzleU64x4 

Vector swizzle u64x4 (256-bit lanes).

kSwizzleF64x4 

Vector swizzle f64x4 (256-bit lanes).

kExtractV128_I32 

Vector extract 128-bit lane from 256-bit or 512-bit vector.

kExtractV128_I64 

Vector extract 128-bit lane from 256-bit or 512-bit vector.

kExtractV128_F32 

Vector extract 128-bit lane from 256-bit or 512-bit vector.

kExtractV128_F64 

Vector extract 128-bit lane from 256-bit or 512-bit vector.

kExtractV256_I32 

Vector extract 256-bit lane from 512-bit vector.

kExtractV256_I64 

Vector extract 256-bit lane from 512-bit vector.

kExtractV256_F32 

Vector extract 256-bit lane from 512-bit vector.

kExtractV256_F64 

Vector extract 256-bit lane from 512-bit vector.

ujit::UniOpVVV : uint32_tenum class[¶]

Instruction with [vec, vec, vec] operands.

Describes vector arithmetic that has one destination and two sources.

Note

For convenience, the third operand can be register, memory, or immediate value.

ConstantDescription
kAndU32 

Vector u32 bitwise AND - dst = src1 & src2.

kAndU64 

Vector u64 bitwise AND - dst = src1 & src2.

kOrU32 

Vector u32 bitwise OR - dst = src1 | src2.

kOrU64 

Vector u64 bitwise OR - dst = src1 | src2.

kXorU32 

Vector u32 bitwise XOR - dst = src1 ^ src2.

kXorU64 

Vector u64 bitwise XOR - dst = src1 ^ src2.

kAndnU32 

Vector u32 bitwise ANDN - dst = ~src1 & src2.

kAndnU64 

Vector u64 bitwise ANDN - dst = ~src1 & src2.

kBicU32 

Vector u32 bitwise BIC - dst = src1 & ~src2.

kBicU64 

Vector u64 bitwise BIC - dst = src1 & ~src2.

kAvgrU8 

Vector u8 average rounded half up dst = (src1 + src2 + 1) >> 1.

kAvgrU16 

Vector u16 average rounded half up dst = (src1 + src2 + 1) >> 1.

kAddU8 

Vector u8 add.

kAddU16 

Vector u16 add.

kAddU32 

Vector u32 add.

kAddU64 

Vector u64 add.

kSubU8 

Vector u8 sub.

kSubU16 

Vector u16 sub.

kSubU32 

Vector u32 sub.

kSubU64 

Vector u64 sub.

kAddsI8 

Vector i8 add with saturation (signed).

kAddsU8 

Vector u8 add with saturation (unsigned).

kAddsI16 

Vector i16 add with saturation (signed).

kAddsU16 

Vector u16 add with saturation (unsigned).

kSubsI8 

Vector i8 sub with saturation (signed).

kSubsU8 

Vector u8 sub with saturation (unsigned).

kSubsI16 

Vector i16 sub with saturation (signed).

kSubsU16 

Vector u16 sub with saturation (unsigned).

kMulU16 

Vector u16 multiply.

kMulU32 

Vector u32 multiply.

kMulU64 

Vector u64 multiply.

kMulhI16 

Vector i16 multiply high - dst = (src1 * src2) >> 16.

kMulhU16 

Vector u16 multiply high - dst = (src1 * src2) >> 16.

kMulU64_LoU32 

Vector u64xu32 multiply.

kMHAddI16_I32 

Vector i16 multiply with horizontal widening add to form a 32-bit result.

kMinI8 

Vector i8 minimum.

kMinU8 

Vector u8 minimum.

kMinI16 

Vector i16 minimum.

kMinU16 

Vector u16 minimum.

kMinI32 

Vector i32 minimum.

kMinU32 

Vector u32 minimum.

kMinI64 

Vector i64 minimum.

kMinU64 

Vector u64 minimum.

kMaxI8 

Vector i8 maximum.

kMaxU8 

Vector u8 maximum.

kMaxI16 

Vector i16 maximum.

kMaxU16 

Vector u16 maximum.

kMaxI32 

Vector i32 maximum.

kMaxU32 

Vector u32 maximum.

kMaxI64 

Vector i64 maximum.

kMaxU64 

Vector u64 maximum.

kCmpEqU8 

Vector u8 compare equal.

kCmpEqU16 

Vector u16 compare equal.

kCmpEqU32 

Vector u32 compare equal.

kCmpEqU64 

Vector u64 compare equal.

kCmpGtI8 

Vector i8 compare greater-than.

kCmpGtU8 

Vector u8 compare greater-than.

kCmpGtI16 

Vector i16 compare greater-than.

kCmpGtU16 

Vector u16 compare greater-than.

kCmpGtI32 

Vector i32 compare greater-than.

kCmpGtU32 

Vector u32 compare greater-than.

kCmpGtI64 

Vector i64 compare greater-than.

kCmpGtU64 

Vector u64 compare greater-than.

kCmpGeI8 

Vector i8 compare greater-or-equal.

kCmpGeU8 

Vector u8 compare greater-or-equal.

kCmpGeI16 

Vector i16 compare greater-or-equal.

kCmpGeU16 

Vector u16 compare greater-or-equal.

kCmpGeI32 

Vector i32 compare greater-or-equal.

kCmpGeU32 

Vector u32 compare greater-or-equal.

kCmpGeI64 

Vector i64 compare greater-or-equal.

kCmpGeU64 

Vector u64 compare greater-or-equal.

kCmpLtI8 

Vector i8 compare lesser-than.

kCmpLtU8 

Vector u8 compare lesser-than.

kCmpLtI16 

Vector i16 compare lesser-than.

kCmpLtU16 

Vector u16 compare lesser-than.

kCmpLtI32 

Vector i32 compare lesser-than.

kCmpLtU32 

Vector u32 compare lesser-than.

kCmpLtI64 

Vector i64 compare lesser-than.

kCmpLtU64 

Vector u64 compare lesser-than.

kCmpLeI8 

Vector i8 compare lesser-or-equal.

kCmpLeU8 

Vector u8 compare lesser-or-equal.

kCmpLeI16 

Vector i16 compare lesser-or-equal.

kCmpLeU16 

Vector u16 compare lesser-or-equal.

kCmpLeI32 

Vector i32 compare lesser-or-equal.

kCmpLeU32 

Vector u32 compare lesser-or-equal.

kCmpLeI64 

Vector i64 compare lesser-or-equal.

kCmpLeU64 

Vector u64 compare lesser-or-equal.

kAndF32 

Vector f32 bitwise AND - dst = src1 & src2.

kAndF64 

Vector f64 bitwise AND - dst = src1 & src2.

kOrF32 

Vector f32 bitwise OR - dst = src1 | src2.

kOrF64 

Vector f64 bitwise OR - dst = src1 | src2.

kXorF32 

Vector f32 bitwise XOR - dst = src1 ^ src2.

kXorF64 

Vector f64 bitwise XOR - dst = src1 ^ src2.

kAndnF32 

Vector f32 bitwise ANDN - dst = ~src1 & src2.

kAndnF64 

Vector f64 bitwise ANDN - dst = ~src1 & src2.

kBicF32 

Vector f32 bitwise BIC - dst = src1 & ~src2.

kBicF64 

Vector f64 bitwise BIC - dst = src1 & ~src2.

kAddF32S 

Scalar f32 add.

kAddF64S 

Scalar f64 add.

kAddF32 

Vector f32 add.

kAddF64 

Vector f64 add.

kSubF32S 

Scalar f32 sub.

kSubF64S 

Scalar f64 sub.

kSubF32 

Vector f32 sub.

kSubF64 

Vector f64 sub.

kMulF32S 

Scalar f32 mul.

kMulF64S 

Scalar f64 mul.

kMulF32 

Vector f32 mul.

kMulF64 

Vector f64 mul.

kDivF32S 

Scalar f32 div.

kDivF64S 

Scalar f64 div.

kDivF32 

Vector f32 div.

kDivF64 

Vector f64 div.

kModF32S 

Scalar f32 modulo.

kModF64S 

Scalar f64 modulo.

kModF32 

Vector f32 modulo.

kModF64 

Vector f64 modulo.

kMinF32S 

Scalar f32 minimum.

kMinF64S 

Scalar f64 minimum.

kMinF32 

Vector f32 minimum.

kMinF64 

Vector f64 minimum.

kMaxF32S 

Scalar f32 maximum.

kMaxF64S 

Scalar f64 maximum.

kMaxF32 

Vector f32 maximum.

kMaxF64 

Vector f64 maximum.

kCmpEqF32S 

Scalar f32 compare equal (ordered).

kCmpEqF64S 

Scalar f64 compare equal (ordered).

kCmpEqF32 

Vector f32 compare equal (ordered).

kCmpEqF64 

Vector f64 compare equal (ordered).

kCmpNeF32S 

Scalar f32 compare not-equal (ordered)

kCmpNeF64S 

Scalar f64 compare not-equal (ordered)

kCmpNeF32 

Vector f32 compare not-equal (ordered)

kCmpNeF64 

Vector f64 compare not-equal (ordered)

kCmpGtF32S 

Scalar f32 compare greater-than (ordered)

kCmpGtF64S 

Scalar f64 compare greater-than (ordered)

kCmpGtF32 

Vector f32 compare greater-than (ordered)

kCmpGtF64 

Vector f64 compare greater-than (ordered)

kCmpGeF32S 

Scalar f32 compare greater-or-equal (ordered)

kCmpGeF64S 

Scalar f64 compare greater-or-equal (ordered)

kCmpGeF32 

Vector f32 compare greater-or-equal (ordered)

kCmpGeF64 

Vector f64 compare greater-or-equal (ordered)

kCmpLtF32S 

Scalar f32 compare lesser-than (ordered)

kCmpLtF64S 

Scalar f64 compare lesser-than (ordered)

kCmpLtF32 

Vector f32 compare lesser-than (ordered)

kCmpLtF64 

Vector f64 compare lesser-than (ordered)

kCmpLeF32S 

Scalar f32 compare lesser-or-equal (ordered)

kCmpLeF64S 

Scalar f64 compare lesser-or-equal (ordered)

kCmpLeF32 

Vector f32 compare lesser-or-equal (ordered)

kCmpLeF64 

Vector f64 compare lesser-or-equal (ordered)

kCmpOrdF32S 

Scalar f32 compare ordered.

kCmpOrdF64S 

Scalar f64 compare ordered.

kCmpOrdF32 

Vector f32 compare ordered.

kCmpOrdF64 

Vector f64 compare ordered.

kCmpUnordF32S 

Scalar f32 compare unordered.

kCmpUnordF64S 

Scalar f64 compare unordered.

kCmpUnordF32 

Vector f32 compare unordered.

kCmpUnordF64 

Vector f64 compare unordered.

kHAddF64 

Vector f64 horizontal-add.

kCombineLoHiU64 

Combine low and high u64 lanes.

kCombineLoHiF64 

Combine low and high f64 lanes.

kCombineHiLoU64 

Combine low and high u64 lanes.

kCombineHiLoF64 

Combine low and high f64 lanes.

kInterleaveLoU8 

Interleave low u8 lanes.

kInterleaveHiU8 

Interleave high u8 lanes.

kInterleaveLoU16 

Interleave low u16 lanes.

kInterleaveHiU16 

Interleave high u16 lanes.

kInterleaveLoU32 

Interleave low u32 lanes.

kInterleaveHiU32 

Interleave high u32 lanes.

kInterleaveLoU64 

Interleave low u64 lanes.

kInterleaveHiU64 

Interleave high u64 lanes.

kInterleaveLoF32 

Interleave low f32 lanes.

kInterleaveHiF32 

Interleave high f32 lanes.

kInterleaveLoF64 

Interleave low f64 lanes.

kInterleaveHiF64 

Interleave high f64 lanes.

kPacksI16_I8 

Pack i16 to i8 with saturation.

kPacksI16_U8 

Pack i16 to u8 with saturation.

kPacksI32_I16 

Pack i32 to i16 with saturation.

kPacksI32_U16 

Pack i32 to u16 with saturation.

kSwizzlev_U8 

Swizzle 16xu8 elements in each 128-bit lane.

ujit::UniOpVVVI : uint32_tenum class[¶]

Instruction with [vec, vec, vec, imm] operands.

Describes vector arithmetic that has one destination, two sources, and immediate.

Note

For convenience, the third operand can be register, memory, or immediate value.

ConstantDescription
kAlignr_U128 

Align-right 8-bit elements in 128-bit.

kInterleaveShuffleU32x4 

Interleaved u32x4 shuffle.

kInterleaveShuffleU64x2 

Interleaved u64x2 shuffle.

kInterleaveShuffleF32x4 

Interleaved f32x4 shuffle.

kInterleaveShuffleF64x2 

Interleaved f64x2 shuffle.

kInsertV128_U32 

Insert a 128-bit lane (u32) into 256-bit or 512-bit vector.

kInsertV128_F32 

Insert a 128-bit lane (f32) into 256-bit or 512-bit vector.

kInsertV128_U64 

Insert a 128-bit lane (u64) into 256-bit or 512-bit vector.

kInsertV128_F64 

Insert a 128-bit lane (f64) into 256-bit or 512-bit vector.

kInsertV256_U32 

Insert a 256-bit lane (u32) into 512-bit vector.

kInsertV256_F32 

Insert a 256-bit lane (f32) into 512-bit vector.

kInsertV256_U64 

Insert a 256-bit lane (u64) into 512-bit vector.

kInsertV256_F64 

Insert a 256-bit lane (f64) into 512-bit vector.

ujit::UniOpVVVV : uint32_tenum class[¶]

Instruction with [vec, vec, vec, vec] operands.

Describes vector arithmetic that has one destination and three sources.

Note

For convenience, the fourth operand can be register, memory, or immediate value.

Remarks

For FMA functionality, check also FMAddOpBehavior.

ConstantDescription
kMAddU16 

Vector u16 multiply-add.

kMAddU32 

Vector u32 multiply-add.

kMAddF32S 

Scalar f32 multiply-add (FMA if available, or separate MUL+ADD if not).

kMAddF64S 

Scalar f64 multiply-add (FMA if available, or separate MUL+ADD if not).

kMAddF32 

Vector f32 multiply-add (FMA if available, or separate MUL+ADD if not).

kMAddF64 

Vector f64 multiply-add (FMA if available, or separate MUL+ADD if not).

kMSubF32S 

Scalar f32 multiply-sub (FMA if available, or separate MUL+ADD if not).

kMSubF64S 

Scalar f64 multiply-sub (FMA if available, or separate MUL+ADD if not).

kMSubF32 

Vector f32 multiply-sub (FMA if available, or separate MUL+ADD if not).

kMSubF64 

Vector f64 multiply-sub (FMA if available, or separate MUL+ADD if not).

kNMAddF32S 

Scalar f32 negated-multiply-add (FMA if available, or separate MUL+ADD if not)

kNMAddF64S 

Scalar f64 negated-multiply-add (FMA if available, or separate MUL+ADD if not)

kNMAddF32 

Vector f32 negated-multiply-add (FMA if available, or separate MUL+ADD if not).

kNMAddF64 

Vector f64 negated-multiply-add (FMA if available, or separate MUL+ADD if not).

kNMSubF32S 

Scalar f32 negated-multiply-sub (FMA if available, or separate MUL+ADD if not).

kNMSubF64S 

Scalar f64 negated-multiply-sub (FMA if available, or separate MUL+ADD if not).

kNMSubF32 

Vector f32 negated-multiply-sub (FMA if available, or separate MUL+ADD if not).

kNMSubF64 

Vector f64 negated-multiply-sub (FMA if available, or separate MUL+ADD if not).

Swizzle2 ujit::swizzle(
uint8_t b,
uint8_t a
)constexprstaticnoexcept[1/2][¶]

Constructs a backend-independent 2-element vector swizzle parameter.

Swizzle4 ujit::swizzle(
uint8_t d,
uint8_t c,
uint8_t b,
uint8_t a
)constexprstaticnoexcept[2/2][¶]

Constructs a backend-independent 4-element vector swizzle parameter.

uint8_t ujit::perm_2x128_imm(
Perm2x128 hi,
Perm2x128 lo
)constexprstaticnoexcept[¶]

Constructs a backend-independent permutation of 128-bit lanes.

Note

This is currently only used by AVX2 and AVX-512 backends.

UniCondition ujit::and_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a & b) becomes zero.

UniCondition ujit::and_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a & b) becomes zero.

UniCondition ujit::and_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a & b) becomes zero.

UniCondition ujit::and_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a & b) becomes non-zero.

UniCondition ujit::and_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a & b) becomes non-zero.

UniCondition ujit::and_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a & b) becomes non-zero.

UniCondition ujit::or_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a | b) becomes zero.

UniCondition ujit::or_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a | b) becomes zero.

UniCondition ujit::or_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a | b) becomes zero.

UniCondition ujit::or_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a | b) becomes non-zero.

UniCondition ujit::or_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a | b) becomes non-zero.

UniCondition ujit::or_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a | b) becomes non-zero.

UniCondition ujit::xor_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes zero.

UniCondition ujit::xor_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes zero.

UniCondition ujit::xor_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes zero.

UniCondition ujit::xor_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes non-zero.

UniCondition ujit::xor_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes non-zero.

UniCondition ujit::xor_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a ^ b) becomes non-zero.

UniCondition ujit::add_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) becomes zero.

UniCondition ujit::add_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) becomes zero.

UniCondition ujit::add_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) becomes zero.

UniCondition ujit::add_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) becomes non-zero.

UniCondition ujit::add_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) becomes non-zero.

UniCondition ujit::add_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) becomes non-zero.

UniCondition ujit::add_c(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) wraps (sets carry flag).

UniCondition ujit::add_c(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) wraps (sets carry flag).

UniCondition ujit::add_c(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) wraps (sets carry flag).

UniCondition ujit::add_nc(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) doesn't wrap (doesn't set carry flag).

UniCondition ujit::add_nc(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) doesn't wrap (doesn't set carry flag).

UniCondition ujit::add_nc(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) doesn't wrap (doesn't set carry flag).

UniCondition ujit::add_s(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit set.

UniCondition ujit::add_s(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit set.

UniCondition ujit::add_s(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit set.

UniCondition ujit::add_ns(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit unset.

UniCondition ujit::add_ns(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit unset.

UniCondition ujit::add_ns(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a + b) ends with the msb/sign bit unset.

UniCondition ujit::sub_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) becomes zero.

UniCondition ujit::sub_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) becomes zero.

UniCondition ujit::sub_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) becomes zero.

UniCondition ujit::sub_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) becomes non-zero.

UniCondition ujit::sub_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) becomes non-zero.

UniCondition ujit::sub_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) becomes non-zero.

UniCondition ujit::sub_c(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) wraps.

UniCondition ujit::sub_c(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) wraps.

UniCondition ujit::sub_c(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) wraps.

UniCondition ujit::sub_nc(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) doesn't wrap.

UniCondition ujit::sub_nc(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) doesn't wrap.

UniCondition ujit::sub_nc(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) doesn't wrap.

UniCondition ujit::sub_s(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit set.

UniCondition ujit::sub_s(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit set.

UniCondition ujit::sub_s(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit set.

UniCondition ujit::sub_ns(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit unset.

UniCondition ujit::sub_ns(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit unset.

UniCondition ujit::sub_ns(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a - b) ends with the msb/sign bit unset.

UniCondition ujit::shr_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a << b) becomes zero.

UniCondition ujit::shr_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a << b) becomes zero.

UniCondition ujit::shr_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a << b) becomes zero.

UniCondition ujit::shr_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a = (a << b) becomes non-zero.

UniCondition ujit::shr_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a = (a << b) becomes non-zero.

UniCondition ujit::shr_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a = (a << b) becomes non-zero.

UniCondition ujit::cmp_eq(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a == b).

UniCondition ujit::cmp_eq(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a == b).

UniCondition ujit::cmp_eq(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a == b).

UniCondition ujit::cmp_ne(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a != b).

UniCondition ujit::cmp_ne(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a != b).

UniCondition ujit::cmp_ne(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a != b).

UniCondition ujit::scmp_lt(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a < b (signed comparison).

UniCondition ujit::scmp_lt(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a < b (signed comparison).

UniCondition ujit::scmp_lt(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a < b (signed comparison).

UniCondition ujit::scmp_le(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a <= b (signed comparison).

UniCondition ujit::scmp_le(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a <= b (signed comparison).

UniCondition ujit::scmp_le(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a <= b (signed comparison).

UniCondition ujit::scmp_gt(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a > b (signed comparison).

UniCondition ujit::scmp_gt(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a > b (signed comparison).

UniCondition ujit::scmp_gt(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a > b (signed comparison).

UniCondition ujit::scmp_ge(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a >= b (signed comparison).

UniCondition ujit::scmp_ge(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a >= b (signed comparison).

UniCondition ujit::scmp_ge(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a >= b (signed comparison).

UniCondition ujit::ucmp_lt(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a < b (unsigned comparison).

UniCondition ujit::ucmp_lt(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a < b (unsigned comparison).

UniCondition ujit::ucmp_lt(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a < b (unsigned comparison).

UniCondition ujit::ucmp_le(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a <= b (unsigned comparison).

UniCondition ujit::ucmp_le(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a <= b (unsigned comparison).

UniCondition ujit::ucmp_le(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a <= b (unsigned comparison).

UniCondition ujit::ucmp_gt(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a > b (unsigned comparison).

UniCondition ujit::ucmp_gt(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a > b (unsigned comparison).

UniCondition ujit::ucmp_gt(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a > b (unsigned comparison).

UniCondition ujit::ucmp_ge(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a >= b (unsigned comparison).

UniCondition ujit::ucmp_ge(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a >= b (unsigned comparison).

UniCondition ujit::ucmp_ge(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a >= b (unsigned comparison).

UniCondition ujit::test_z(
const Gp& a
)staticnoexcept[1/4][¶]

Constructs a condition that would be true when a is zero.

UniCondition ujit::test_nz(
const Gp& a
)staticnoexcept[1/4][¶]

Constructs a condition that would be true when a is non-zero.

UniCondition ujit::test_z(
const Gp& a,
const Gp& b
)staticnoexcept[2/4][¶]

Constructs a condition that would be true when a & b is zero.

UniCondition ujit::test_z(
const Gp& a,
const Mem& b
)staticnoexcept[3/4][¶]

Constructs a condition that would be true when a & b is zero.

UniCondition ujit::test_z(
const Gp& a,
const Imm& b
)staticnoexcept[4/4][¶]

Constructs a condition that would be true when a & b is zero.

UniCondition ujit::test_nz(
const Gp& a,
const Gp& b
)staticnoexcept[2/4][¶]

Constructs a condition that would be true when a & b is non-zero.

UniCondition ujit::test_nz(
const Gp& a,
const Mem& b
)staticnoexcept[3/4][¶]

Constructs a condition that would be true when a & b is non-zero.

UniCondition ujit::test_nz(
const Gp& a,
const Imm& b
)staticnoexcept[4/4][¶]

Constructs a condition that would be true when a & b is non-zero.

UniCondition ujit::bt_z(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a bit in a at b is zero (((a >> b) & 1) == 0).

UniCondition ujit::bt_z(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a bit in a at b is zero (((a >> b) & 1) == 0).

UniCondition ujit::bt_z(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a bit in a at b is zero (((a >> b) & 1) == 0).

UniCondition ujit::bt_nz(
const Gp& a,
const Gp& b
)staticnoexcept[1/3][¶]

Constructs a condition that would be true when a bit in a at b is non-zero (((a >> b) & 1) == 1).

UniCondition ujit::bt_nz(
const Gp& a,
const Mem& b
)staticnoexcept[2/3][¶]

Constructs a condition that would be true when a bit in a at b is non-zero (((a >> b) & 1) == 1).

UniCondition ujit::bt_nz(
const Gp& a,
const Imm& b
)staticnoexcept[3/3][¶]

Constructs a condition that would be true when a bit in a at b is non-zero (((a >> b) & 1) == 1).