asmjit::x86::InstDB Namespace Reference

Instruction database (X86).

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

x86::InstDB::Mode : uint32_tenum

Describes which mode is supported by an instruction or instruction signature.

ConstantDescription
kModeNone 

Invalid.

kModeX86 

X86 mode supported.

kModeX64 

X64 mode supported.

kModeAny 

Both X86 and X64 modes supported.

x86::InstDB::OpFlags : uint32_tenum

Operand flags (X86).

ConstantDescription
kOpNone 

No flags.

kOpGpbLo 

Operand can be low 8-bit GPB register.

kOpGpbHi 

Operand can be high 8-bit GPB register.

kOpGpw 

Operand can be 16-bit GPW register.

kOpGpd 

Operand can be 32-bit GPD register.

kOpGpq 

Operand can be 64-bit GPQ register.

kOpXmm 

Operand can be 128-bit XMM register.

kOpYmm 

Operand can be 256-bit YMM register.

kOpZmm 

Operand can be 512-bit ZMM register.

kOpMm 

Operand can be 64-bit MM register.

kOpKReg 

Operand can be 64-bit K register.

kOpSReg 

Operand can be SReg (segment register).

kOpCReg 

Operand can be CReg (control register).

kOpDReg 

Operand can be DReg (debug register).

kOpSt 

Operand can be 80-bit ST register (X87).

kOpBnd 

Operand can be 128-bit BND register.

kOpTmm 

Operand can be 0..8192-bit TMM register.

kOpAllRegs 

Combination of all possible registers.

kOpI4 

Operand can be unsigned 4-bit immediate.

kOpU4 

Operand can be unsigned 4-bit immediate.

kOpI8 

Operand can be signed 8-bit immediate.

kOpU8 

Operand can be unsigned 8-bit immediate.

kOpI16 

Operand can be signed 16-bit immediate.

kOpU16 

Operand can be unsigned 16-bit immediate.

kOpI32 

Operand can be signed 32-bit immediate.

kOpU32 

Operand can be unsigned 32-bit immediate.

kOpI64 

Operand can be signed 64-bit immediate.

kOpU64 

Operand can be unsigned 64-bit immediate.

kOpAllImm 

Operand can be any immediate.

kOpMem 

Operand can be a scalar memory pointer.

kOpVm 

Operand can be a vector memory pointer.

kOpRel8 

Operand can be relative 8-bit displacement.

kOpRel32 

Operand can be relative 32-bit displacement.

kOpImplicit 

Operand is implicit.

x86::InstDB::MemFlags : uint32_tenum

Memory operand flags (X86).

ConstantDescription
kMemOpAny 

Operand can be any scalar memory pointer.

kMemOpM8 

Operand can be an 8-bit memory pointer.

kMemOpM16 

Operand can be a 16-bit memory pointer.

kMemOpM32 

Operand can be a 32-bit memory pointer.

kMemOpM48 

Operand can be a 48-bit memory pointer (FAR pointers only).

kMemOpM64 

Operand can be a 64-bit memory pointer.

kMemOpM80 

Operand can be an 80-bit memory pointer.

kMemOpM128 

Operand can be a 128-bit memory pointer.

kMemOpM256 

Operand can be a 256-bit memory pointer.

kMemOpM512 

Operand can be a 512-bit memory pointer.

kMemOpM1024 

Operand can be a 1024-bit memory pointer.

kMemOpVm32x 

Operand can be a vm32x (vector) pointer.

kMemOpVm32y 

Operand can be a vm32y (vector) pointer.

kMemOpVm32z 

Operand can be a vm32z (vector) pointer.

kMemOpVm64x 

Operand can be a vm64x (vector) pointer.

kMemOpVm64y 

Operand can be a vm64y (vector) pointer.

kMemOpVm64z 

Operand can be a vm64z (vector) pointer.

kMemOpBaseOnly 

Only memory base is allowed (no index, no offset).

kMemOpDs 

Implicit memory operand's DS segment.

kMemOpEs 

Implicit memory operand's ES segment.

kMemOpMib 

Operand must be MIB (base+index) pointer.

kMemOpTMem 

Operand is a sib_mem (ADX memory operand).

x86::InstDB::Flags : uint32_tenum

Instruction flags (X86).

Details about instruction encoding, operation, features, and some limitations.

ConstantDescription
kFlagNone 

No flags.

kFlagFpu 

Instruction that accesses FPU registers.

kFlagMmx 

Instruction that accesses MMX registers (including 3DNOW and GEODE) and EMMS.

kFlagVec 

Instruction that accesses XMM registers (SSE, AVX, AVX512).

kFlagTsib 

Instruction uses TSIB (or SIB_MEM) encoding (MODRM followed by SIB).

kFlagRep 

Instruction can be prefixed with using the REP(REPE) or REPNE prefix.

kFlagRepIgnored 

Instruction ignores REP|REPNE prefixes, but they are accepted.

kFlagLock 

Instruction can be prefixed with using the LOCK prefix.

kFlagXAcquire 

Instruction can be prefixed with using the XACQUIRE prefix.

kFlagXRelease 

Instruction can be prefixed with using the XRELEASE prefix.

kFlagMib 

Instruction uses MIB (BNDLDX|BNDSTX) to encode two registers.

kFlagVsib 

Instruction uses VSIB instead of legacy SIB.

kFlagVex 

Instruction can be encoded by VEX|XOP (AVX|AVX2|BMI|XOP|...).

kFlagEvex 

Instruction can be encoded by EVEX (AVX512).

kFlagFpuM16 

FPU instruction can address word_ptr (shared with M80).

kFlagFpuM32 

FPU instruction can address dword_ptr.

kFlagFpuM64 

FPU instruction can address qword_ptr.

kFlagFpuM80 

FPU instruction can address tword_ptr (shared with M16).

kFlagAvx512_ 

Internally used in tables, has no meaning.

kFlagAvx512K 

Supports masking {k1..k7}.

kFlagAvx512Z 

Supports zeroing {z}, must be used together with kAvx512k.

kFlagAvx512ER 

Supports 'embedded-rounding' {er} with implicit {sae},.

kFlagAvx512SAE 

Supports 'suppress-all-exceptions' {sae}.

kFlagAvx512B32 

Supports 32-bit broadcast 'b32'.

kFlagAvx512B64 

Supports 64-bit broadcast 'b64'.

kFlagAvx512T4X 

Operates on a vector of consecutive registers (AVX512_4FMAPS and AVX512_4VNNIW).

x86::InstDB::SingleRegCase : uint32_tenum

ConstantDescription
kSingleRegNone 

No special handling.

kSingleRegRO 

Operands become read-only - REG & REG and similar.

kSingleRegWO 

Operands become write-only - REG ^ REG and similar.