Documentation ¶
Overview ¶
Zydis is a Go wrapper for the fast and lightweight Zydis x86/x86-64 disassembler library, found at http://zydis.re/. This package provides bindings via cgo and is considered a "complete" wrapper of the Zydis API, ready for production use.
It was created because the pure-Go disassembler, found at https://godoc.org/golang.org/x/arch/x86/x86asm, is significantly lacking in x86-64 support. Decoding x86* is complex business, and it was more straightforward to write these bindings instead of digging deep into the pure-Go package.
Requires Git-LFS ¶
**This package uses Git LFS found to store a precompiled version of the Zydis library (see below), so please make sure you have it installed before getting this package.** Learn about Git LFS at https://git-lfs.github.com/.
Sample Code ¶
See the file `cmd/demo.go`.
Upgrading the Zydis Library ¶
The Zydis library is packaged as a static syso object file so that this package is go gettable. Precompiled macOS (amd64, arm64), Linux (amd64, arm64), and Windows (amd64, 386) binaries are provided.
Use the Makefile in the `lib/` folder to upgrade to a newer version, rebuild, or add support for another platform. The default Makefile target clones the Zydis repo and its submodule, performs the build, and creates the syso files for Go linkage under macOS with suitable cross-compilers installed.
Index ¶
- Constants
- func IsFeatureEnabled(f Feature) (bool, error)
- func Version() (major, minor, patch, build int)
- type AddressWidth
- type BranchType
- type BroadcastMode
- type CPUFlagAction
- type CallbackMap
- type ConversionMode
- type DecodedInstruction
- type DecodedOperand
- type Decoder
- type DecoderMode
- type Decorator
- type ElementSize
- type ElementType
- type ExceptionClass
- type Feature
- type Formatter
- func (fmtr *Formatter) FormatInstruction(instr *DecodedInstruction, runtimeAddress uint64) (string, error)
- func (fmtr *Formatter) FormatOperand(instr *DecodedInstruction, operand *DecodedOperand, runtimeAddress uint64) (string, error)
- func (fmtr *Formatter) SetHookDecorator(_type FormatterFunction, callback FormatterDecoratorFunc) error
- func (fmtr *Formatter) SetHookRegister(_type FormatterFunction, callback FormatterRegisterFunc) error
- func (fmtr *Formatter) SetHookX(_type FormatterFunction, callback FormatterXFunc) error
- func (fmtr *Formatter) SetProperty(property FormatterProperty, value any) error
- func (fmtr *Formatter) TokenizeInstruction(instr *DecodedInstruction, runtimeAddress uint64) (string, []FormatterToken, error)
- func (fmtr *Formatter) TokenizeOperand(instr *DecodedInstruction, operand *DecodedOperand, runtimeAddress uint64) (string, []FormatterToken, error)
- type FormatterBuffer
- type FormatterContext
- type FormatterDecoratorFunc
- type FormatterFunction
- type FormatterProperty
- type FormatterRegisterFunc
- type FormatterStyle
- type FormatterToken
- type FormatterXFunc
- type ISAExt
- type ISASet
- type InstructionAttributes
- type InstructionCategory
- type InstructionEncoding
- type InstructionSegment
- type MachineMode
- type MaskMode
- type MemoryOperandType
- type Mnemonic
- type OpcodeMap
- type OperandAction
- type OperandActions
- type OperandEncoding
- type OperandType
- type OperandVisibility
- type Padding
- type PrefixType
- type Register
- type RegisterContext
- type RoundingMode
- type Segment
- type Signedness
- type SwizzleMode
- type TokenType
Constants ¶
const ( InstructionEncodingLegacy = iota InstructionEncoding3DNOW InstructionEncodingXOP InstructionEncodingVEX InstructionEncodingEVEX InstructionEncodingMVEX )
InstructionEncoding enum values.
const ( // The operand is read by the instruction. OperandActionRead OperandAction = 1 << iota // The operand is written by the instruction (must write). OperandActionWrite // The operand is conditionally read by the instruction. OperandActionCondRead // The operand is conditionally written by the instruction (may write). OperandActionCondWrite // The operand is read (must read) and written by the instruction (must // write). OperandActionReadWrite = OperandActionRead | OperandActionWrite // The operand is conditionally read (may read) and conditionally written // by the instruction (may write). OperandActionCondReadCondWrite = OperandActionCondRead | OperandActionCondWrite // The operand is read (must read) and conditionally written by the // instruction (may write). OperandActionReadCondWrite = OperandActionRead | OperandActionCondWrite // The operand is written (must write) and conditionally read by // the instruction (may read). OperandActionCondReadWrite = OperandActionCondRead | OperandActionWrite // Mask combining all reading access flags. OperandActionMaskRead = OperandActionRead | OperandActionCondRead // Mask combining all writing access flags. OperandActionMaskWrite = OperandActionWrite | OperandActionCondWrite )
OperandAction bitfield values.
const RuntimeAddressNone = int64(-1)
RuntimeAddressNone should be used as value for runtimeAddress in ZydisFormatterFormatInstruction/ZydisFormatterFormatInstructionEx or ZydisFormatterFormatOperand/ZydisFormatterFormatOperandEx to print relative values for all addresses.
Variables ¶
This section is empty.
Functions ¶
func IsFeatureEnabled ¶
IsFeatureEnabled returns true when the given feature is included in the zydis library.
Types ¶
type AddressWidth ¶
type AddressWidth int
AddressWidth is an enum of processor address widths.
const ( AddressWidth16 AddressWidth = iota AddressWidth32 AddressWidth64 )
AddressWidth enum values.
type BranchType ¶
type BranchType int
BranchType is an enum of instruction branch types.
const ( // The instruction is not a branch instruction. BranchTypeNone BranchType = iota // The instruction is a short (8-bit) branch instruction. BranchTypeShort // The instruction is a near (16-bit or 32-bit) branch instruction. BranchTypeNear // The instruction is a far (intersegment) branch instruction. BranchTypeFar )
BranchType enum values.
type BroadcastMode ¶
type BroadcastMode int
BroadcastMode is an enum of AVX broadcast modes.
const ( BroadcastModeInvalid BroadcastMode = iota BroadcastMode1To2 BroadcastMode1To4 BroadcastMode1to8 BroadcastMode1to16 BroadcastMode1to32 BroadcastMode1to64 BroadcastMode2to4 BroadcastMode2to8 BroadcastMode2to16 BroadcastMode4to8 BroadcastMode4to16 BroadcastMode8to16 )
BroadcastMode enum values.
type CPUFlagAction ¶
type CPUFlagAction int
CPUFlagAction is an enum of CPU action flags.
const ( // The CPU flag is not touched by the instruction. CPUFlagActionNone CPUFlagAction = iota // The CPU flag is tested (read). CPUFlagActionTested // The CPU flag is tested and modified aferwards (read-write). CPUFlagActionTestedModified // The CPU flag is modified (write). CPUFlagActionModified // The CPU flag is set to 0 (write). CPUFlagActionSet0 // The CPU flag is set to 1 (write). CPUFlagActionSet1 // The CPU flag is undefined (write). CPUFlagActionUndefined )
CPUFlagAction enum values.
type CallbackMap ¶
type CallbackMap struct {
// contains filtered or unexported fields
}
CallbackMap manages callback tokens in a threadsafe way.
type ConversionMode ¶
type ConversionMode int
ConversionMode is an enum of KNC conversion modes.
const ( ConversionModeInvalid ConversionMode = iota ConversionModeFloat16 ConversionModeSInt8 ConversionModeUInt8 ConversionModeSInt16 ConversionModeUInt16 )
ConversionMode enum values.
type DecodedInstruction ¶
type DecodedInstruction struct { // The machine mode used to decode this instruction. MachineMode MachineMode // The instruction-mnemonic. Mnemonic Mnemonic // The length of the decoded instruction. Length uint8 // The instruction-encoding. Encoding InstructionEncoding // Opcode-map. OpcodeMap OpcodeMap // Instruction opcode. Opcode uint8 // Stack width. StackWidth uint8 // Effective operand width. OperandWidth uint8 // Effective address width. AddressWidth uint8 // Detailed info for all instruction operands. // // Explicit operands are guaranteed to be in the front and ordered as they are printed // by the formatter in Intel mode. No assumptions can be made about the order of hidden // operands, except that they always located behind the explicit operands. Operands []DecodedOperand // Instruction attributes. Attributes InstructionAttributes // Information about accessed CPU flags. AccessedFlags []struct { Action CPUFlagAction } // Extended info for `AVX` instructions. AVX struct { // The `AVX` vector-length. VectorLength uint16 // Info about the embedded writemask-register (`AVX-512` and `KNC` only). Mask struct { // The masking mode. Mode MaskMode // The mask register. Reg Register } // Contains info about the `AVX` broadcast. Broadcast struct { // Signals if the broadcast is a static broadcast. IsStatic bool // The `AVX` broadcast-mode. Mode BroadcastMode } // Contains info about the `AVX` rounding. Rounding struct { // The `AVX` rounding-mode. Mode RoundingMode } // Contains info about the `AVX` register-swizzle (`KNC` only). Swizzle struct { // The `AVX` register-swizzle mode. Mode SwizzleMode } // Contains info about the `AVX` data-conversion (`KNC` only). Conversion struct { // The `AVX` data-conversion mode. Mode ConversionMode } // Signals if the `SAE` (suppress-all-exceptions) functionality is // enabled for the instruction. HasSAE bool // Signals if the instruction has a memory-eviction-hint (`KNC` only). HasEvictionHint bool } // Meta info. Meta struct { // The instruction category. Category InstructionCategory // The ISA-set. ISASet ISASet // The ISA-set extension. ISAExt ISAExt // The branch type. BranchType BranchType // The exception class. ExceptionClass ExceptionClass } // Detailed info about different instruction-parts like `ModRM`, `SIB` or // encoding-prefixes. Raw struct { // Detailed info about the legacy prefixes (including `REX`). Prefixes []struct { // The prefix type. Type PrefixType // The prefix byte. Value uint8 } // Detailed info about the `REX` prefix. REX struct { // 64-bit operand-size promotion. W uint8 // Extension of the `ModRM.reg` field. R uint8 // Extension of the `SIB.index` field. X uint8 // Extension of the `ModRM.rm`, `SIB.base`, or `opcode.reg` field. B uint8 // The offset of the effective `REX` byte, relative to the beginning of the // instruction, in bytes. // // This offset always points to the "effective" `REX` prefix (the one // closest to the instruction opcode), if multiple `REX` prefixes are // present. // // Note that the `REX` byte can be the first byte of the instruction, // which would lead to an offset of `0`. Please refer to the instruction // attributes to check for the presence of the `REX` prefix. Offset uint8 } // Detailed info about the `XOP` prefix. XOP struct { // Extension of the `ModRM.reg` field (inverted). R uint8 // Extension of the `SIB.index` field (inverted). X uint8 // Extension of the `ModRM.rm`, `SIB.base`, or `opcode.reg` field (inverted). B uint8 // Opcode-map specifier. MMMMM uint8 // 64-bit operand-size promotion or opcode-extension. W uint8 // `NDS`/`NDD` (non-destructive-source/destination) register specifier // (inverted). VVVV uint8 // Vector-length specifier. L uint8 // Compressed legacy prefix. PP uint8 // The offset of the first xop byte, relative to the beginning of the // instruction, in bytes. Offset uint8 } // Detailed info about the `VEX` prefix. VEX struct { // Extension of the `ModRM.reg` field (inverted). R uint8 // Extension of the `SIB.index` field (inverted). X uint8 // Extension of the `ModRM.rm`, `SIB.base`, or `opcode.reg` field // (inverted). B uint8 // Opcode-map specifier. MMMMM uint8 // 64-bit operand-size promotion or opcode-extension. W uint8 // `NDS`/`NDD` (non-destructive-source/destination) register specifier // (inverted). VVVV uint8 // Vector-length specifier. L uint8 // Compressed legacy prefix. PP uint8 // The offset of the first `VEX` byte, relative to the beginning of the // instruction, in bytes. Offset uint8 // The size of the `VEX` prefix, in bytes. Size uint8 } // Detailed info about the `EVEX` prefix. EVEX struct { // Extension of the `ModRM.reg` field (inverted). R uint8 // Extension of the `SIB.index/vidx` field (inverted). X uint8 // Extension of the `ModRM.rm` or `SIB.base` field (inverted). B uint8 // High-16 register specifier modifier (inverted). R2 uint8 // Opcode-map specifier. MM uint8 // 64-bit operand-size promotion or opcode-extension. W uint8 // `NDS`/`NDD` (non-destructive-source/destination) register specifier // (inverted). VVVV uint8 // Compressed legacy prefix. PP uint8 // Zeroing/Merging. Z uint8 // Vector-length specifier or rounding-control (most significant bit). L2 uint8 // Vector-length specifier or rounding-control (least significant bit). L uint8 // Broadcast/RC/SAE context. BLower uint8 // High-16 `NDS`/`VIDX` register specifier. V2 uint8 // Embedded opmask register specifier. AAA uint8 // The offset of the first evex byte, relative to the beginning of the // instruction, in bytes. Offset uint8 } // Detailed info about the `MVEX` prefix. MVEX struct { // Extension of the `ModRM.reg` field (inverted). R uint8 // Extension of the `SIB.index/vidx` field (inverted). X uint8 // Extension of the `ModRM.rm` or `SIB.base` field (inverted). B uint8 // High-16 register specifier modifier (inverted). R2 uint8 // Opcode-map specifier. MMMM uint8 // 64-bit operand-size promotion or opcode-extension. W uint8 // `NDS`/`NDD` (non-destructive-source/destination) register specifier // (inverted). VVVV uint8 // Compressed legacy prefix. PP uint8 // Non-temporal/eviction hint. E uint8 // Swizzle/broadcast/up-convert/down-convert/static-rounding controls. SSS uint8 // High-16 `NDS`/`VIDX` register specifier. V2 uint8 // Embedded opmask register specifier. KKK uint8 // The offset of the first mvex byte, relative to the beginning of the // instruction, in bytes. Offset uint8 } // Detailed info about the `ModRM` byte. ModRM struct { // The addressing mode. Mod uint8 // Register specifier or opcode-extension. Reg uint8 // Register specifier or opcode-extension. Rm uint8 // The offset of the `ModRM` byte, relative to the beginning of the // instruction, in bytes. Offset uint8 } // Detailed info about the `SIB` byte. SIB struct { // The scale factor. Scale uint8 // The index-register specifier. Index uint8 // The base-register specifier. Base uint8 // The offset of the `SIB` byte, relative to the beginning of the instruction, // in bytes. Offset uint8 } // Detailed info about displacement-bytes. Disp struct { // The displacement value Value int64 // The physical displacement size, in bits. Size uint8 // The offset of the displacement data, relative to the beginning of the // instruction, in bytes. Offset uint8 } // Detailed info about immediate-bytes. Imm [2]struct { // Signals, if the immediate value is signed. IsSigned bool // Signals, if the immediate value contains a relative offset. You can use // `ZydisCalcAbsoluteAddress` to determine the absolute address value. IsRelative bool // The immediate value. Value struct { Unsigned uint64 Signed int64 } // The physical immediate size, in bits. Size uint8 // The offset of the immediate data, relative to the beginning of the // instruction, in bytes. Offset uint8 } } // contains filtered or unexported fields }
DecodedInstruction represents a processor instruction.
func (*DecodedInstruction) AccessedFlagsByAction ¶
func (di *DecodedInstruction) AccessedFlagsByAction(action CPUFlagAction) (uint32, error)
AccessedFlagsByAction returns a bitfield for the current instruction that has the n-th bit set, corresponding to n == CPUFlagAction, for CPU-flags that match the given action.
func (*DecodedInstruction) AccessedFlagsRead ¶
func (di *DecodedInstruction) AccessedFlagsRead() (uint32, error)
AccessedFlagsRead returns a bitfield for the current instruction that has the n-th bit set, corresponding to n == CPUFlagAction, for CPU-flags that are read (tested).
func (*DecodedInstruction) AccessedFlagsWritten ¶
func (di *DecodedInstruction) AccessedFlagsWritten() (uint32, error)
AccessedFlagsWritten returns a bitfield for the current instruction that has the n-th bit set, corresponding to n == CPUFlagAction, for CPU-flags that are written (modified, undefined).
func (*DecodedInstruction) Segments ¶
func (di *DecodedInstruction) Segments() ([]Segment, error)
Segments returns offsets and sizes of all logical instruction segments (e.g. `OPCODE`, `MODRM`, ...).
type DecodedOperand ¶
type DecodedOperand struct { // Operand-ID. ID uint8 // Type of the operand. Type OperandType // Visibility of the operand. Visibility OperandVisibility // Operand actions. Actions OperandActions // Operand encoding. Encoding OperandEncoding // Logical size of the operand (in bits). Size uint16 // Element type. ElementType // Element size. ElementSize // Number of elements. ElementCount uint16 // Extended info for register operands. Reg struct { Value Register } // Extended info for memory operands. Mem struct { // Type of the memory operand. Type MemoryOperandType // Segment register. Segment Register // Base register. Base Register // Index register. Index Register // Scale factor. Scale uint8 // Extended info for memory-operands with displacement. Disp struct { // Signals if the displacement value is used. HasDisplacement bool // The displacement value. Value int64 } } // Extended info for pointer-operands. Ptr struct { Segment uint16 Offset uint32 } // Extended info for immediate-operands. Imm struct { // Signals if the immediate value is signed. IsSigned bool // Signals if the immediate value contains a relative offset. // You can use `ZydisCalcAbsoluteAddress` to determine the absolute // address value. IsRelative bool // The immediate value. Value struct { Unsigned uint64 Signed int64 } } // contains filtered or unexported fields }
DecodedOperand is an operand in a DecodedInstruction.
func (*DecodedOperand) AbsoluteAddress ¶
func (do *DecodedOperand) AbsoluteAddress(runtimeAddress uint64) (uint64, error)
AbsoluteAddress returns the absolute address value for the given instruction operand.
You should use this function in the following cases: - `IMM` operands with relative address (e.g. `JMP`, `CALL`, ...) - `MEM` operands with `RIP`/`EIP`-relative address (e.g. `MOV RAX, [RIP+0x12345678]`) - `MEM` operands with absolute address (e.g. `MOV RAX, [0x12345678]`)
- The displacement needs to get truncated and zero extended
func (*DecodedOperand) AbsoluteAddressWithContext ¶
func (do *DecodedOperand) AbsoluteAddressWithContext(runtimeAddress uint64, context RegisterContext) (uint64, error)
AbsoluteAddressWithContext is like AbsoluteAddress, but takes some register context values, to allow calculation of addresses depending on runtime register values.
Note that `IP/EIP/RIP` from the register-context will be ignored in favor of the passed runtime-address.
type Decoder ¶
type Decoder struct {
// contains filtered or unexported fields
}
Decoder performs decoding of instruction bytes to a machine interpretable struct.
func NewDecoder ¶
func NewDecoder(mm MachineMode, aw AddressWidth) *Decoder
NewDecoder returns a new instruction decoder.
func (*Decoder) Decode ¶
func (d *Decoder) Decode(buffer []byte) (*DecodedInstruction, error)
Decode decodes the instruction in the given input buffer.
func (*Decoder) EnableMode ¶
func (d *Decoder) EnableMode(m DecoderMode, en bool) error
EnableMode enables/disables the given decoder mode.
type DecoderMode ¶
type DecoderMode int
DecoderMode is an enum of decoder modes.
const ( // Enables minimal instruction decoding without semantic analysis. // // This mode provides access to the mnemonic, the instruction-length, the // effective operand-size, the effective address-width, some attributes // (e.g. `ZYDIS_ATTRIB_IS_RELATIVE`) and all of the information in the // `raw` field of the `ZydisDecodedInstruction` struct. // // Operands, most attributes and other specific information (like `AVX` // info) are not accessible in this mode. // // This mode is NOT enabled by default. DecoderModeMinimal DecoderMode = iota // Enables the `AMD`-branch mode. // // Intel ignores the operand-size override-prefix (`0x66`) for all branches with 32-bit // immediates and forces the operand-size of the instruction to 64-bit in 64-bit mode. // In `AMD`-branch mode `0x66` is not ignored and changes the operand-size and the size of the // immediate to 16-bit. // // This mode is NOT enabled by default. DecoderModeAMDBranches // Enables `KNC` compatibility-mode. // // `KNC` and `KNL+` chips are sharing opcodes and encodings for some mask-related instructions. // Enable this mode to use the old `KNC` specifications (different mnemonics, operands, ..). // // This mode is NOT enabled by default. DecoderModeKNC // Enables the `MPX` mode. // // The `MPX` isa-extension reuses (overrides) some of the widenop instruction opcodes. // // This mode is enabled by default. DecoderModeMPX // Enables the `CET` mode. // // The `CET` isa-extension reuses (overrides) some of the widenop instruction opcodes. // // This mode is enabled by default. DecoderModeCET // Enables the `LZCNT` mode. // // The `LZCNT` isa-extension reuses (overrides) some of the widenop instruction opcodes. // // This mode is enabled by default. DecoderModeLZCNT // Enables the `TZCNT` mode. // // The `TZCNT` isa-extension reuses (overrides) some of the widenop instruction opcodes. // // This mode is enabled by default. DecoderModeTZCNT // Enables the `WBNOINVD` mode. // // The `WBINVD` instruction is interpreted as `WBNOINVD` on ICL chips, if a `F3` prefix is // used. // // This mode is disabled by default. DecoderModeWBNOINVD // Enables the `CLDEMOTE` mode. // // The `CLDEMOTE` isa-extension reuses (overrides) some of the widenop instruction opcodes. // // This mode is enabled by default. DecoderModeCLDEMOTE )
DecoderMode enum values.
type Decorator ¶
type Decorator int
Decorator is an enum that describes a decorator.
const ( DecoratorInvalid Decorator = iota // The embedded-mask decorator. DecoratorMask // The broadcast decorator. DecoratorBroadcast // The rounding-control decorator. DecoratorRoundingControl // The suppress-all-exceptions decorator. DecoratorSuppressAllExceptions // The register-swizzle decorator. DecoratorSwizzle // The conversion decorator. DecoratorConversion // The eviction-hint decorator. DecoratorEvictionHint )
Decorator enum values
type ElementType ¶
type ElementType int
ElementType is an enum of processor element types.
const ( ElementTypeInvalid ElementType = iota ElementTypeStruct // Struct ElementTypeUInt // Unsigned integer ElementTypeInt // Signed integer ElementTypeFloat16 // 16-bit floating point (`half`) ElementTypeFloat32 // 32-bit floating point (`single`) ElementTypeFloat64 // 64-bit floating point (`double`) ElementTypeFloat80 // 80-bit floating point (`extended`) ElementTypeLongBCD // Binary coded decimal ElementTypeCC // A condition code )
ElementType enum values
type ExceptionClass ¶
type ExceptionClass int
ExceptionClass is an enum of exception classes.
const ( ExceptionClassNone ExceptionClass = iota ExceptionClassSSE1 // SSE1 ExceptionClassSSE2 // SSE2 ExceptionClassSSE3 // SSE3 ExceptionClassSSE4 // SSE4 ExceptionClassSSE5 // SSE5 ExceptionClassSSE7 // SSE7 ExceptionClassAVX1 // AVX1 ExceptionClassAVX2 // AVX2 ExceptionClassAVX3 // AVX3 ExceptionClassAVX4 // AVX4 ExceptionClassAVX5 // AVX5 ExceptionClassAVX6 // AVX6 ExceptionClassAVX7 // AVX7 ExceptionClassAVX8 // AVX8 ExceptionClassAVX11 // AVX11 ExceptionClassAVX12 // AVX12 ExceptionClassE1 // E1 ExceptionClassE1NF // E1NF ExceptionClassE2 // E2 ExceptionClassE2NF // E2NF ExceptionClassE3 // E3 ExceptionClassE3NF // E3NF ExceptionClassE4 // E4 ExceptionClassE4NF // E4NF ExceptionClassE5 // E5 ExceptionClassE5NF // E5NF ExceptionClassE6 // E6 ExceptionClassE6NF // E6NF ExceptionClassE7NM // E7NM ExceptionClassE7NM128 // E7NM128 ExceptionClassE9NF // E9NF ExceptionClassE10 // E10 ExceptionClassE10NF // E10NF ExceptionClassE11 // E11 ExceptionClassE11NF // E11NF ExceptionClassE12 // E12 ExceptionClassE12NP // E12NP ExceptionClassK20 // K20 ExceptionClassK21 // K21 ExceptionClassAMXE1 // AMXE1 ExceptionClassAMXE2 // AMXE2 ExceptionClassAMXE3 // AMXE3 ExceptionClassAMXE4 // AMXE4 ExceptionClassAMXE5 // AMXE5 ExceptionClassAMXE6 // AMXE6 )
ExceptionClass enum values.
func (ExceptionClass) String ¶
func (i ExceptionClass) String() string
type Formatter ¶
type Formatter struct {
// contains filtered or unexported fields
}
Formatter translates decoded instructions into human-readable text.
func NewFormatter ¶
func NewFormatter(style FormatterStyle) (*Formatter, error)
NewFormatter returns a new Formatter.
func (*Formatter) FormatInstruction ¶
func (fmtr *Formatter) FormatInstruction(instr *DecodedInstruction, runtimeAddress uint64) (string, error)
FormatInstruction formats the given instruction and writes it into the output buffer. Pass RuntimeAddressNone as the runtimeAddress to print relative addresses.
func (*Formatter) FormatOperand ¶
func (fmtr *Formatter) FormatOperand(instr *DecodedInstruction, operand *DecodedOperand, runtimeAddress uint64) (string, error)
FormatOperand formats the given operand and writes it into the output buffer.
func (*Formatter) SetHookDecorator ¶
func (fmtr *Formatter) SetHookDecorator(_type FormatterFunction, callback FormatterDecoratorFunc) error
SetHookDecorator configures a FormatterDecoratorFunc callback function for an associated formatter function type.
func (*Formatter) SetHookRegister ¶
func (fmtr *Formatter) SetHookRegister(_type FormatterFunction, callback FormatterRegisterFunc) error
SetHookRegister configures a FormatterRegisterFunc callback function for an associated formatter function type.
func (*Formatter) SetHookX ¶
func (fmtr *Formatter) SetHookX(_type FormatterFunction, callback FormatterXFunc) error
SetHookX configures a FormatterXFunc callback function for an associated formatter function type.
func (*Formatter) SetProperty ¶
func (fmtr *Formatter) SetProperty(property FormatterProperty, value any) error
SetProperty changes the value of the specified formatter property.
func (*Formatter) TokenizeInstruction ¶
func (fmtr *Formatter) TokenizeInstruction(instr *DecodedInstruction, runtimeAddress uint64) (string, []FormatterToken, error)
TokenizeInstruction tokenizes the given instruction and writes it into the output buffer.
func (*Formatter) TokenizeOperand ¶
func (fmtr *Formatter) TokenizeOperand(instr *DecodedInstruction, operand *DecodedOperand, runtimeAddress uint64) (string, []FormatterToken, error)
TokenizeOperand tokenizes the given operand and writes it into the output buffer.
type FormatterBuffer ¶
type FormatterBuffer struct { // The buffer contains a token stream (true), or a simple string (false). IsTokenList bool Value string }
FormatterBuffer represents a formatter buffer.
type FormatterContext ¶
type FormatterContext struct { // A pointer to the `ZydisDecodedInstruction` struct. Instruction *DecodedInstruction // A pointer to the `ZydisDecodedOperand` struct. Operand *DecodedOperand // The runtime address of the instruction. RuntimeAddress uint64 }
FormatterContext is the context used with a FormatterFunc.
type FormatterDecoratorFunc ¶
type FormatterDecoratorFunc func(fmtr *Formatter, fbuf *FormatterBuffer, context FormatterContext, decorator Decorator) error
FormatterDecoratorFunc is a callback used with keys:
- FormatterFunctionPrintDecorator
type FormatterFunction ¶
type FormatterFunction int
FormatterFunction is an enum of formatter function types.
const ( // FormatterFunctionPreInstruction is invoked before the formatter formats an instruction. FormatterFunctionPreInstruction FormatterFunction = iota // FormatterFunc value // FormatterFunctionPostInstruction is invoked after the formatter formatted an instruction. FormatterFunctionPostInstruction // FormatterFunc value // This function refers to the main formatting function. // // Replacing this function allows for complete custom formatting, but // indirectly disables all other hooks except for // FormatterFunctionPreInstruction and FormatterFunctionPostInstruction. FormatterFunctionFormatInstruction // FormatterFunc value // This function is invoked before the formatter formats an operand. FormatterFunctionFormatPreOperand // FormatterFunc value // This function is invoked after the formatter formatted an operand. FormatterFunctionFormatPostOperand // FormatterFunc value // This function is invoked to format a register operand. FormatterFunctionFormatFormatOperandRegister // FormatterFunc value // This function is invoked to format a memory operand. // // Replacing this function might indirectly disable some specific calls to the // FormatterFunctionPrintTypecast, FormatterFunctionPrintSegment, // FormatterFunctionPrintAddressAbsolute and // FormatterFunctionPrintAddressDisplacement functions. FormatterFunctionFormatFormatOperandMemory // FormatterFunc value // This function is invoked to format a pointer operand. FormatterFunctionFormatFormatOperandPointer // FormatterFunc value // This function is invoked to format an immediate operand. // // Replacing this function might indirectly disable some specific calls to the // FormatterFunctionPrintAddressAbsolute, FormatterFunctionPrintAddressRelative and // FormatterFunctionPrintAddressImmediate functions. FormatterFunctionFormatFormatOperandImmediate // FormatterFunc value // This function is invoked to print the instruction mnemonic. FormatterFunctionPrintMnemonic // FormatterFunc value // This function is invoked to print a register. FormatterFunctionPrintRegister // FormatterRegisterFunc value // This function is invoked to print absolute addresses. // // Conditionally invoked, if a runtime-address different to RuntimeAddressNone // was passed: // * IMM operands with relative address (e.g. JMP, CALL, ...) // * MEM operands with EIP/RIP-relative address (e.g. MOV RAX, [RIP+0x12345678]) // Always invoked for: // * MEM operands with absolute address (e.g. MOV RAX, [0x12345678]) FormatterFunctionPrintAddressAbsolute // FormatterFunc value // This function is invoked to print relative addresses. // // Conditionally invoked, if RuntimeAddressNone was passed as runtime-address: // * IMM operands with relative address (e.g. JMP, CALL, ...) FormatterFunctionPrintAddressRelative // FormatterFunc value // This function is invoked to print a memory displacement value. // // If the memory displacement contains an address and a runtime-address // different to RuntimeAddressNone was passed, // FormatterFunctionPrintAddressAbsolute is called instead. FormatterFunctionPrintAddressDisplacement // FormatterFunc value // This function is invoked to print an immediate value. // // If the immediate contains an address and a runtime-address different to // RuntimeAddressNone was passed, FormatterFunctionPrintAddressAbsolute is // called instead. // // If the immediate contains an address and RuntimeAddressNone was passed as // runtime-address, FormatterFunctionPrintAddressRelative is called instead. FormatterFunctionPrintAddressImmediate // FormatterFunc value // This function is invoked to print the size of a memory operand (Intel only). FormatterFunctionPrintTypecast // FormatterFunc value // This function is invoked to print the segment-register of a memory operand. FormatterFunctionPrintSegment // FormatterFunc value // This function is invoked to print the instruction prefixes. FormatterFunctionPrintPrefixes // FormatterFunc value // This function is invoked after formatting an operand to print a EVEX/MVEX decorator. FormatterFunctionPrintDecorator // FormatterDecoratorFunc value )
FormatterFunction enum values.
type FormatterProperty ¶
type FormatterProperty int
FormatterProperty is an enum of formatter property keys.
const ( // FormatterPropertyForceSize controls the printing of effective operand-size // suffixes (AT&T) or operand-sizes of memory operands (Intel). // // Pass true as value to force the formatter to always print the size, // or false to only print it if needed. FormatterPropertyForceSize FormatterProperty = iota // FormatterPropertyForceSegment controls the printing of segment prefixes. // // Pass true as value to force the formatter to always print the segment // register of memory-operands or false to omit implicit DS/SS segments. FormatterPropertyForceSegment // FormatterPropertyForceRelativeBranches controls the printing of branch // addresses. // // Pass true as value to force the formatter to always print relative branch // addresses or false to use absolute addresses, if a runtimeAddress // different to RuntimeAddressNone was passed. FormatterPropertyForceRelativeBranches // FormatterPropertyForceRelativeRIPRel controls the printing of EIP/RIP- // relative addresses. // // Pass true as value to force the formatter to always print relative // addresses for EIP/RIP-relative operands or false to use absolute // addresses, if a runtimeAddress different to RuntimeAddressNone was passed. FormatterPropertyForceRelativeRIPRel // FormatterPropertyPrintBranchSize controls the printing of branch- // instructions sizes. // // Pass true as value to print the size (short, near) of branch // instructions or false to hide it. // // Note that the far/l modifier is always printed. FormatterPropertyPrintBranchSize // FormatterPropertyDetailedPrefixes controls the printing of instruction // prefixes. // // Pass true as value to print all instruction-prefixes (even ignored or // duplicate ones) or false to only print prefixes that are effectively // used by the instruction. FormatterPropertyDetailedPrefixes // FormatterPropertyAddrBase controls the base of address values. FormatterPropertyAddrBase // FormatterPropertyAddrSignedness controls the signedness of relative // addresses. Absolute addresses are always unsigned. FormatterPropertyAddrSignedness // FormatterPropertyAddrPaddingAbsolute controls the padding of absolute // address values. // // Pass PaddingDisabled to disable padding, PaddingAuto to padd all addresses // to the current stack width (hexadecimal only), or any other integer value // for custom padding. FormatterPropertyAddrPaddingAbsolute // FormatterPropertyAddrPaddingRelative controls the padding of relative // address values. // // Pass PaddingDisabled to disable padding, PaddingAuto to padd all addresses // to the current stack width (hexadecimal only), or any other integer value // for custom padding. FormatterPropertyAddrPaddingRelative // FormatterPropertyDispBase controls the base of displacement values. FormatterPropertyDispBase // FormatterPropertyDispSignedness controls the signedness of displacement // values. FormatterPropertyDispSignedness // FormatterPropertyDispPadding controls the padding of displacement values. // // Pass PaddingDisabled to disable padding, or any other integer value for // custom padding. FormatterPropertyDispPadding // FormatterPropertyImmBase controls the base of immediate values. FormatterPropertyImmBase // FormatterPropertyImmSignedness controls the signedness of immediate values. // // Pass SignednessAuto to automatically choose the most suitable mode based // on the operands DecodedOperand.Imm.IsSigned attribute. FormatterPropertyImmSignedness // FormatterPropertyImmPadding controls the padding of immediate values. // // Pass PaddingDisabled to disable padding, PaddingAuto to padd all // immediates to the operand-width (hexadecimal only), or any other integer // value for custom padding. FormatterPropertyImmPadding // FormatterPropertyUppercasePrefixes controls the letter-case for prefixes. // // Pass true as value to format in uppercase or false to format in lowercase. FormatterPropertyUppercasePrefixes // FormatterPropertyUppercaseMnemonic controls the letter-case for // the mnemonic. // // Pass true as value to format in uppercase or false to format in lowercase. FormatterPropertyUppercaseMnemonic // FormatterPropertyUppercaseRegisters controls the letter-case for registers. // // Pass true as value to format in uppercase or false to format in lowercase. FormatterPropertyUppercaseRegisters // FormatterPropertyUppercaseTypecasts controls the letter-case for typecasts. // // Pass true as value to format in uppercase or false to format in lowercase. FormatterPropertyUppercaseTypecasts // FormatterPropertyUppercaseDecorators controls the letter-case for // decorators. // // Pass true as value to format in uppercase or false to format in lowercase. FormatterPropertyUppercaseDecorators // FormatterPropertyDecPrefix controls the prefix for decimal values. // // Pass a string with a maximum length of 10 characters to set a custom // prefix, or the empty string to disable it. FormatterPropertyDecPrefix // FormatterPropertyDecSuffix controls the suffix for decimal values. // // Pass a string with a maximum length of 10 characters to set a custom // suffix, or the empty string to disable it. FormatterPropertyDecSuffix // FormatterPropertyHexUppercase controls the letter-case of hexadecimal // values. // // Pass true as value to format in uppercase and false to format in lowercase. FormatterPropertyHexUppercase // default true // FormatterPropertyHexPrefix controls the prefix for hexadecimal values. // // Pass a string with a maximum length of 10 characters to set a custom // prefix, or the empty string to disable it. FormatterPropertyHexPrefix // FormatterPropertyHexSuffix controls the suffix for hexadecimal values. // // Pass a string with a maximum length of 10 characters to set a custom // suffix, or the empty string to disable it. FormatterPropertyHexSuffix )
type FormatterRegisterFunc ¶
type FormatterRegisterFunc func(fmtr *Formatter, fbuf *FormatterBuffer, context FormatterContext, reg Register) error
FormatterRegisterFunc is a callback used with keys:
- FormatterFunctionPrintRegister
type FormatterStyle ¶
type FormatterStyle int
FormatterStyle is an enum that determines the formatting style.
const ( // Generates AT&T-style disassembly. FormatterStyleATT FormatterStyle = iota // Generates Intel-style disassembly. FormatterStyleIntel // Generates MASM-style disassembly that is directly accepted as input // for the MASM assembler. FormatterStyleIntelMASM )
FormatterStyle enum values.
type FormatterToken ¶
FormatterToken is a formatting token.
type FormatterXFunc ¶
type FormatterXFunc func(fmtr *Formatter, fbuf *FormatterBuffer, context FormatterContext) (skipOperand bool, err error)
FormatterXFunc is a callback used with keys:
- FormatterFunctionPreInstruction
- FormatterFunctionPostInstruction
- FormatterFunctionFormatInstruction
- FormatterFunctionFormatPreOperand †
- FormatterFunctionFormatPostOperand †
- FormatterFunctionFormatFormatOperandRegister †
- FormatterFunctionFormatFormatOperandMemory †
- FormatterFunctionFormatFormatOperandPointer †
- FormatterFunctionFormatFormatOperandImmediate †
- FormatterFunctionPrintMnemonic
- FormatterFunctionPrintAddressAbsolute
- FormatterFunctionPrintAddressRelative
- FormatterFunctionPrintAddressDisplacement
- FormatterFunctionPrintAddressImmediate
- FormatterFunctionPrintTypecast
- FormatterFunctionPrintSegment
- FormatterFunctionPrintPrefixes
For keys marked with †, returning true will instruct the formatter to omit the whole operand.
type ISAExt ¶
type ISAExt int
ISAExt is an enum of Instruction Set Architecture Extensions.
const ( ISAExtInvalid ISAExt = iota // INVALID IsaExtADOX_ADCX // ADOX_ADCX IsaExtAES // AES IsaExtAMD3DNOW // AMD3DNOW IsaExtAMD3DNOW_PREFETCH // AMD3DNOW_PREFETCH IsaExtAMD_INVLPGB // AMD_INVLPGB IsaExtAMX_BF16 // AMX_BF16 IsaExtAMX_INT8 // AMX_INT8 IsaExtAMX_TILE // AMX_TILE IsaExtAVX // AVX IsaExtAVX2 // AVX2 IsaExtAVX2GATHER // AVX2GATHER IsaExtAVX512EVEX // AVX512EVEX IsaExtAVX512VEX // AVX512VEX IsaExtAVXAES // AVXAES IsaExtBASE // BASE IsaExtBMI1 // BMI1 IsaExtBMI2 // BMI2 IsaExtCET // CET IsaExtCLDEMOTE // CLDEMOTE IsaExtCLFLUSHOPT // CLFLUSHOPT IsaExtCLFSH // CLFSH IsaExtCLWB // CLWB IsaExtCLZERO // CLZERO IsaExtENQCMD // ENQCMD IsaExtF16C // F16C IsaExtFMA // FMA IsaExtFMA4 // FMA4 IsaExtGFNI // GFNI IsaExtINVPCID // INVPCID IsaExtKNC // KNC IsaExtKNCE // KNCE IsaExtKNCV // KNCV IsaExtLONGMODE // LONGMODE IsaExtLZCNT // LZCNT IsaExtMCOMMIT // MCOMMIT IsaExtMMX // MMX IsaExtMONITOR // MONITOR IsaExtMONITORX // MONITORX IsaExtMOVBE // MOVBE IsaExtMOVDIR // MOVDIR IsaExtMPX // MPX IsaExtPADLOCK // PADLOCK IsaExtPAUSE // PAUSE IsaExtPCLMULQDQ // PCLMULQDQ IsaExtPCONFIG // PCONFIG IsaExtPKU // PKU IsaExtPREFETCHWT1 // PREFETCHWT1 IsaExtPT // PT IsaExtRDPID // RDPID IsaExtRDPRU // RDPRU IsaExtRDRAND // RDRAND IsaExtRDSEED // RDSEED IsaExtRDTSCP // RDTSCP IsaExtRDWRFSGS // RDWRFSGS IsaExtRTM // RTM IsaExtSERIALIZE // SERIALIZE IsaExtSGX // SGX IsaExtSGX_ENCLV // SGX_ENCLV IsaExtSHA // SHA IsaExtSMAP // SMAP IsaExtSMX // SMX IsaExtSNP // SNP IsaExtSSE // SSE IsaExtSSE2 // SSE2 IsaExtSSE3 // SSE3 IsaExtSSE4 // SSE4 IsaExtSSE4A // SSE4A IsaExtSSSE3 // SSSE3 IsaExtSVM // SVM IsaExtTBM // TBM IsaExtTSX_LDTRK // TSX_LDTRK IsaExtVAES // VAES IsaExtVMFUNC // VMFUNC IsaExtVPCLMULQDQ // VPCLMULQDQ IsaExtVTX // VTX IsaExtWAITPKG // WAITPKG IsaExtX87 // X87 IsaExtXOP // XOP IsaExtXSAVE // XSAVE IsaExtXSAVEC // XSAVEC IsaExtXSAVEOPT // XSAVEOPT IsaExtXSAVES // XSAVES )
IsaExt enum values.
type ISASet ¶
type ISASet int
ISASet is an enum of Instruction Set Architectures.
const ( ISASetInvalid ISASet = iota // INVALID ISASetADOX_ADCX // ADOX_ADCX ISASetAES // AES ISASetAMD // AMD ISASetAMD3DNOW // AMD3DNOW ISASetAMX_BF16 // AMX_BF16 ISASetAMX_INT8 // AMX_INT8 ISASetAMX_TILE // AMX_TILE ISASetAVX // AVX ISASetAVX2 // AVX2 ISASetAVX2GATHER // AVX2GATHER ISASetAVX512BW_128 // AVX512BW_128 ISASetAVX512BW_128N // AVX512BW_128N ISASetAVX512BW_256 // AVX512BW_256 ISASetAVX512BW_512 // AVX512BW_512 ISASetAVX512BW_KOP // AVX512BW_KOP ISASetAVX512CD_128 // AVX512CD_128 ISASetAVX512CD_256 // AVX512CD_256 ISASetAVX512CD_512 // AVX512CD_512 ISASetAVX512DQ_128 // AVX512DQ_128 ISASetAVX512DQ_128N // AVX512DQ_128N ISASetAVX512DQ_256 // AVX512DQ_256 ISASetAVX512DQ_512 // AVX512DQ_512 ISASetAVX512DQ_KOP // AVX512DQ_KOP ISASetAVX512DQ_SCALAR // AVX512DQ_SCALAR ISASetAVX512ER_512 // AVX512ER_512 ISASetAVX512ER_SCALAR // AVX512ER_SCALAR ISASetAVX512F_128 // AVX512F_128 ISASetAVX512F_128N // AVX512F_128N ISASetAVX512F_256 // AVX512F_256 ISASetAVX512F_512 // AVX512F_512 ISASetAVX512F_KOP // AVX512F_KOP ISASetAVX512F_SCALAR // AVX512F_SCALAR ISASetAVX512PF_512 // AVX512PF_512 ISASetAVX512_4FMAPS_512 // AVX512_4FMAPS_512 ISASetAVX512_4FMAPS_SCALAR // AVX512_4FMAPS_SCALAR ISASetAVX512_4VNNIW_512 // AVX512_4VNNIW_512 ISASetAVX512_BF16_128 // AVX512_BF16_128 ISASetAVX512_BF16_256 // AVX512_BF16_256 ISASetAVX512_BF16_512 // AVX512_BF16_512 ISASetAVX512_BITALG_128 // AVX512_BITALG_128 ISASetAVX512_BITALG_256 // AVX512_BITALG_256 ISASetAVX512_BITALG_512 // AVX512_BITALG_512 ISASetAVX512_GFNI_128 // AVX512_GFNI_128 ISASetAVX512_GFNI_256 // AVX512_GFNI_256 ISASetAVX512_GFNI_512 // AVX512_GFNI_512 ISASetAVX512_IFMA_128 // AVX512_IFMA_128 ISASetAVX512_IFMA_256 // AVX512_IFMA_256 ISASetAVX512_IFMA_512 // AVX512_IFMA_512 ISASetAVX512_VAES_128 // AVX512_VAES_128 ISASetAVX512_VAES_256 // AVX512_VAES_256 ISASetAVX512_VAES_512 // AVX512_VAES_512 ISASetAVX512_VBMI2_128 // AVX512_VBMI2_128 ISASetAVX512_VBMI2_256 // AVX512_VBMI2_256 ISASetAVX512_VBMI2_512 // AVX512_VBMI2_512 ISASetAVX512_VBMI_128 // AVX512_VBMI_128 ISASetAVX512_VBMI_256 // AVX512_VBMI_256 ISASetAVX512_VBMI_512 // AVX512_VBMI_512 ISASetAVX512_VNNI_128 // AVX512_VNNI_128 ISASetAVX512_VNNI_256 // AVX512_VNNI_256 ISASetAVX512_VNNI_512 // AVX512_VNNI_512 ISASetAVX512_VP2INTERSECT_128 // AVX512_VP2INTERSECT_128 ISASetAVX512_VP2INTERSECT_256 // AVX512_VP2INTERSECT_256 ISASetAVX512_VP2INTERSECT_512 // AVX512_VP2INTERSECT_512 ISASetAVX512_VPCLMULQDQ_128 // AVX512_VPCLMULQDQ_128 ISASetAVX512_VPCLMULQDQ_256 // AVX512_VPCLMULQDQ_256 ISASetAVX512_VPCLMULQDQ_512 // AVX512_VPCLMULQDQ_512 ISASetAVX512_VPOPCNTDQ_128 // AVX512_VPOPCNTDQ_128 ISASetAVX512_VPOPCNTDQ_256 // AVX512_VPOPCNTDQ_256 ISASetAVX512_VPOPCNTDQ_512 // AVX512_VPOPCNTDQ_512 ISASetAVXAES // AVXAES ISASetAVX_GFNI // AVX_GFNI ISASetBMI1 // BMI1 ISASetBMI2 // BMI2 ISASetCET // CET ISASetCLDEMOTE // CLDEMOTE ISASetCLFLUSHOPT // CLFLUSHOPT ISASetCLFSH // CLFSH ISASetCLWB // CLWB ISASetCLZERO // CLZERO ISASetCMOV // CMOV ISASetCMPXCHG16B // CMPXCHG16B ISASetENQCMD // ENQCMD ISASetF16C // F16C ISASetFAT_NOP // FAT_NOP ISASetFCMOV // FCMOV ISASetFMA // FMA ISASetFMA4 // FMA4 ISASetFXSAVE // FXSAVE ISASetFXSAVE64 // FXSAVE64 ISASetGFNI // GFNI ISASetI186 // I186 ISASetI286PROTECTED // I286PROTECTED ISASetI286REAL // I286REAL ISASetI386 // I386 ISASetI486 // I486 ISASetI486REAL // I486REAL ISASetI86 // I86 ISASetINVPCID // INVPCID ISASetKNCE // KNCE ISASetKNCJKBR // KNCJKBR ISASetKNCSTREAM // KNCSTREAM ISASetKNCV // KNCV ISASetKNC_MISC // KNC_MISC ISASetKNC_PF_HINT // KNC_PF_HINT ISASetLAHF // LAHF ISASetLONGMODE // LONGMODE ISASetLZCNT // LZCNT ISASetMCOMMIT // MCOMMIT ISASetMONITOR // MONITOR ISASetMONITORX // MONITORX ISASetMOVBE // MOVBE ISASetMOVDIR // MOVDIR ISASetMPX // MPX ISASetPADLOCK_ACE // PADLOCK_ACE ISASetPADLOCK_PHE // PADLOCK_PHE ISASetPADLOCK_PMM // PADLOCK_PMM ISASetPADLOCK_RNG // PADLOCK_RNG ISASetPAUSE // PAUSE ISASetPCLMULQDQ // PCLMULQDQ ISASetPCONFIG // PCONFIG ISASetPENTIUMMMX // PENTIUMMMX ISASetPENTIUMREAL // PENTIUMREAL ISASetPKU // PKU ISASetPOPCNT // POPCNT ISASetPPRO // PPRO ISASetPREFETCHWT1 // PREFETCHWT1 ISASetPREFETCH_NOP // PREFETCH_NOP ISASetPT // PT ISASetRDPID // RDPID ISASetRDPMC // RDPMC ISASetRDPRU // RDPRU ISASetRDRAND // RDRAND ISASetRDSEED // RDSEED ISASetRDTSCP // RDTSCP ISASetRDWRFSGS // RDWRFSGS ISASetRTM // RTM ISASetSERIALIZE // SERIALIZE ISASetSGX // SGX ISASetSGX_ENCLV // SGX_ENCLV ISASetSHA // SHA ISASetSMAP // SMAP ISASetSMX // SMX ISASetSSE // SSE ISASetSSE2 // SSE2 ISASetSSE2MMX // SSE2MMX ISASetSSE3 // SSE3 ISASetSSE3X87 // SSE3X87 ISASetSSE4 // SSE4 ISASetSSE42 // SSE42 ISASetSSE4A // SSE4A ISASetSSEMXCSR // SSEMXCSR ISASetSSE_PREFETCH // SSE_PREFETCH ISASetSSSE3 // SSSE3 ISASetSSSE3MMX // SSSE3MMX ISASetSVM // SVM ISASetTBM // TBM ISASetTSX_LDTRK // TSX_LDTRK ISASetVAES // VAES ISASetVMFUNC // VMFUNC ISASetVPCLMULQDQ // VPCLMULQDQ ISASetVTX // VTX ISASetWAITPKG // WAITPKG ISASetX87 // X87 ISASetXOP // XOP ISASetXSAVE // XSAVE ISASetXSAVEC // XSAVEC ISASetXSAVEOPT // XSAVEOPT ISASetXSAVES // XSAVES )
ISASet enum values.
type InstructionAttributes ¶
type InstructionAttributes uint64
InstructionAttributes is a bitfield of instruction attributes.
const ( // The instruction has the `ModRM` byte. InstructionAttributesHasModRM InstructionAttributes = 1 << iota // The instruction has the `SIB` byte. InstructionAttributesHasSIB // The instruction has the `REX` prefix. InstructionAttributesHasREX // The instruction has the `XOP` prefix. InstructionAttributesHasXOP // The instruction has the `VEX` prefix. InstructionAttributesHasVEX // The instruction has the `EVEX` prefix. InstructionAttributesHasEVEX // The instruction has the `MVEX` prefix. InstructionAttributesHasMVEX // The instruction has one or more operands with position-relative offsets. InstructionAttributesIsRelative // The instruction is privileged. InstructionAttributesIsPrivileged // The instruction accepts the `LOCK` prefix (`0xF0`). InstructionAttributesAcceptsLock // The instruction accepts the `REP` prefix (`0xF3`). InstructionAttributesAcceptsREP // The instruction accepts the `REPE`/`REPZ` prefix (`0xF3`). InstructionAttributesAcceptsREPE // The instruction accepts the `REPE`/`REPZ` prefix (`0xF3`). InstructionAttributesAcceptsREPZ InstructionAttributes = 1 << (iota - 1) // The instruction accepts the `REPNE`/`REPNZ` prefix (`0xF2`). InstructionAttributesAcceptsREPNE // The instruction accepts the `REPNE`/`REPNZ` prefix (`0xF2`). InstructionAttributesAcceptsREPNZ InstructionAttributes = 1 << (iota - 1) // The instruction accepts the `BND` prefix (`0xF2`). InstructionAttributesAcceptsBND // The instruction accepts the `XACQUIRE` prefix (`0xF2`). InstructionAttributesAcceptsXAcquire // The instruction accepts the `XRELEASE` prefix (`0xF3`). InstructionAttributesAcceptsXRelease // The instruction accepts the `XACQUIRE`/`XRELEASE` prefixes (`0xF2`, `0xF3`) // without the `LOCK` prefix (`0x0F`). InstructionAttributesAcceptsHLEWithoutLock // The instruction accepts branch hints (0x2E, 0x3E). InstructionAttributesAcceptsBranchHints // The instruction accepts segment prefixes (`0x2E`, `0x36`, `0x3E`, `0x26`, // `0x64`, `0x65`). InstructionAttributesAcceptsSegment // The instruction has the `LOCK` prefix (`0xF0`). InstructionAttributesHasLock // The instruction has the `REP` prefix (`0xF3`). InstructionAttributesHasREP // The instruction has the `REPE`/`REPZ` prefix (`0xF3`). InstructionAttributesHasREPE // The instruction has the `REPE`/`REPZ` prefix (`0xF3`). InstructionAttributesHasREPZ // The instruction has the `REPNE`/`REPNZ` prefix (`0xF2`). InstructionAttributesHasREPNZ // The instruction has the `BND` prefix (`0xF2`). InstructionAttributesHasBND // The instruction has the `XACQUIRE` prefix (`0xF2`). InstructionAttributesHasXAcquire // The instruction has the `XRELEASE` prefix (`0xF3`). InstructionAttributesHasXRelease // The instruction has the branch-not-taken hint (`0x2E`). InstructionAttributesHasBranchNotTaken // The instruction has the branch-taken hint (`0x3E`). InstructionAttributesHasBranchTaken // The instruction has the `CS` segment modifier (`0x2E`). InstructionAttributesHasSegmentCS // The instruction has the `SS` segment modifier (`0x36`). InstructionAttributesHasSegmentSS // The instruction has the `DS` segment modifier (`0x3E`). InstructionAttributesHasSegmentDS // The instruction has the `ES` segment modifier (`0x26`). InstructionAttributesHasSegmentES // The instruction has the `FS` segment modifier (`0x64`). InstructionAttributesHasSegmentFS // The instruction has the `GS` segment modifier (`0x65`). InstructionAttributesHasSegmentGS // The instruction has the operand-size override prefix (`0x66`). InstructionAttributesHasOperandSize // The instruction has the address-size override prefix (`0x67`). InstructionAttributesHasAddressSize // The instruction may conditionally read the general CPU state. InstructionAttributesCPUFlagAccess // The instruction may conditionally write the general CPU state. InstructionAttributesCPUStateCR // The instruction may conditionally read the FPU state (X87, MMX). InstructionAttributesCPUStateCW // The instruction may conditionally write the FPU state (X87, MMX). InstructionAttributesFPUStateCR // The instruction may conditionally read the XMM state (AVX, AVX2, AVX-512). InstructionAttributesXMMStateCR // The instruction may conditionally write the XMM state (AVX, AVX2, AVX-512). InstructionAttributesXMMStateCW // The instruction has a segment modifier. InstructionAttributesHasSegment InstructionAttributes = InstructionAttributesHasSegmentCS | InstructionAttributesHasSegmentSS | InstructionAttributesHasSegmentDS | InstructionAttributesHasSegmentES | InstructionAttributesHasSegmentFS | InstructionAttributesHasSegmentGS )
InstructionAttributes bitfield values
type InstructionCategory ¶
type InstructionCategory int
InstructionCategory is an enum of instruction categories.
const ( InstructionCategoryInvalid InstructionCategory = iota // INVALID InstructionCategoryADOX_ADCX // ADOX_ADCX InstructionCategoryAES // AES InstructionCategoryAMD3DNOW // AMD3DNOW InstructionCategoryAMX_TILE // AMX_TILE InstructionCategoryAVX // AVX InstructionCategoryAVX2 // AVX2 InstructionCategoryAVX2GATHER // AVX2GATHER InstructionCategoryAVX512 // AVX512 InstructionCategoryAVX512_4FMAPS // AVX512_4FMAPS InstructionCategoryAVX512_4VNNIW // AVX512_4VNNIW InstructionCategoryAVX512_BITALG // AVX512_BITALG InstructionCategoryAVX512_VBMI // AVX512_VBMI InstructionCategoryAVX512_VP2INTERSECT // AVX512_VP2INTERSECT InstructionCategoryBINARY // BINARY InstructionCategoryBITBYTE // BITBYTE InstructionCategoryBLEND // BLEND InstructionCategoryBMI1 // BMI1 InstructionCategoryBMI2 // BMI2 InstructionCategoryBROADCAST // BROADCAST InstructionCategoryCALL // CALL InstructionCategoryCET // CET InstructionCategoryCLDEMOTE // CLDEMOTE InstructionCategoryCLFLUSHOPT // CLFLUSHOPT InstructionCategoryCLWB // CLWB InstructionCategoryCLZERO // CLZERO InstructionCategoryCMOV // CMOV InstructionCategoryCOMPRESS // COMPRESS InstructionCategoryCOND_BR // COND_BR InstructionCategoryCONFLICT // CONFLICT InstructionCategoryCONVERT // CONVERT InstructionCategoryDATAXFER // DATAXFER InstructionCategoryDECIMAL // DECIMAL InstructionCategoryENQCMD // ENQCMD InstructionCategoryEXPAND // EXPAND InstructionCategoryFCMOV // FCMOV InstructionCategoryFLAGOP // FLAGOP InstructionCategoryFMA4 // FMA4 InstructionCategoryGATHER // GATHER InstructionCategoryGFNI // GFNI InstructionCategoryIFMA // IFMA InstructionCategoryINTERRUPT // INTERRUPT InstructionCategoryIO // IO InstructionCategoryIOSTRINGOP // IOSTRINGOP InstructionCategoryKMASK // KMASK InstructionCategoryKNC // KNC InstructionCategoryKNCMASK // KNCMASK InstructionCategoryKNCSCALAR // KNCSCALAR InstructionCategoryLOGICAL // LOGICAL InstructionCategoryLOGICAL_FP // LOGICAL_FP InstructionCategoryLZCNT // LZCNT InstructionCategoryMISC // MISC InstructionCategoryMMX // MMX InstructionCategoryMOVDIR // MOVDIR InstructionCategoryMPX // MPX InstructionCategoryNOP // NOP InstructionCategoryPADLOCK // PADLOCK InstructionCategoryPCLMULQDQ // PCLMULQDQ InstructionCategoryPCONFIG // PCONFIG InstructionCategoryPKU // PKU InstructionCategoryPOP // POP InstructionCategoryPREFETCH // PREFETCH InstructionCategoryPREFETCHWT1 // PREFETCHWT1 InstructionCategoryPT // PT InstructionCategoryPUSH // PUSH InstructionCategoryRDPID // RDPID InstructionCategoryRDPRU // RDPRU InstructionCategoryRDRAND // RDRAND InstructionCategoryRDSEED // RDSEED InstructionCategoryRDWRFSGS // RDWRFSGS InstructionCategoryRET // RET InstructionCategoryROTATE // ROTATE InstructionCategorySCATTER // SCATTER InstructionCategorySEGOP // SEGOP InstructionCategorySEMAPHORE // SEMAPHORE InstructionCategorySERIALIZE // SERIALIZE InstructionCategorySETCC // SETCC InstructionCategorySGX // SGX InstructionCategorySHA // SHA InstructionCategorySHIFT // SHIFT InstructionCategorySMAP // SMAP InstructionCategorySSE // SSE InstructionCategorySTRINGOP // STRINGOP InstructionCategorySTTNI // STTNI InstructionCategorySYSCALL // SYSCALL InstructionCategorySYSRET // SYSRET InstructionCategorySYSTEM // SYSTEM InstructionCategoryTBM // TBM InstructionCategoryTSX_LDTRK // TSX_LDTRK InstructionCategoryUFMA // UFMA InstructionCategoryUNCOND_BR // UNCOND_BR InstructionCategoryVAES // VAES InstructionCategoryVBMI2 // VBMI2 InstructionCategoryVFMA // VFMA InstructionCategoryVPCLMULQDQ // VPCLMULQDQ InstructionCategoryVTX // VTX InstructionCategoryWAITPKG // WAITPKG InstructionCategoryWIDENOP // WIDENOP InstructionCategoryX87_ALU // X87_ALU InstructionCategoryXOP // XOP InstructionCategoryXSAVE // XSAVE InstructionCategoryXSAVEOPT // XSAVEOPT )
InstructionCategory enum values
func (InstructionCategory) String ¶
func (i InstructionCategory) String() string
type InstructionEncoding ¶
type InstructionEncoding int
InstructionEncoding is an enum of instruction encodings.
type InstructionSegment ¶
type InstructionSegment int
InstructionSegment is an enum of instruction segments.
const ( InstructionSegmentNone InstructionSegment = iota // The legacy prefixes (including ignored `REX` prefixes). InstructionSegmentPrefixes // The effective `REX` prefix byte. InstructionSegmentREX // The `XOP` prefix bytes. InstructionSegmentXOP // The `VEX` prefix bytes. InstructionSegmentVEX // The `EVEX` prefix bytes. InstructionSegmentEVEX // The `MVEX` prefix bytes. InstructionSegmentMVEX // The opcode bytes. InstructionSegmentOpCode // The `ModRM` byte. InstructionSegmentModRM // The `SIB` byte. InstructionSegmentSIB // The displacement bytes. InstructionSegmentDisplacement // The immediate bytes. InstructionSegmentImmediate )
InstructionSegment enum values.
type MachineMode ¶
type MachineMode int
MachineMode is an enum of processor modes.
const ( MachineMode64 MachineMode = iota // 64 bit mode MachineModeCompat32 // 32 bit protected mode MachineModeCompat16 // 16 bit protected mode MachineModeLegacy32 // 32 bit protected mode MachineModeLegacy16 // 16 bit protected mode MachineModeReal16 // 16 bit real mode )
MachineMode enum values.
type MaskMode ¶
type MaskMode int
MaskMode is an enum of AVX mask modes.
const ( MaskModeInvalid MaskMode = iota // Masking is disabled for the current instruction (`K0` register is used). MaskModeDisabled // The embedded mask register is used as a merge-mask. MaskModeMerging // The embedded mask register is used as a zero-mask. MaskModeZeroing // The embedded mask register is used as a control-mask (element selector). MaskModeControl // The embedded mask register is used as a zeroing control-mask (element selector). MaskModeControlZeroing )
MaskMode enum values.
type MemoryOperandType ¶
type MemoryOperandType int
MemoryOperandType is an enum of memory operand types.
const ( MemoryOperandTypeInvalid MemoryOperandType = iota // Normal memory operand MemoryOperandTypeMemory // The memory operand is only used for address-generation. // No real memory-access is caused. MemoryOperandTypeAddressGeneration // A memory operand using `SIB` addressing form, where the index register // is not used in address calculation and scale is ignored. // No real memory-access is caused. MemoryOperandTypeMIB )
MemoryOperandType enum values.
type Mnemonic ¶
type Mnemonic int
Mnemonic is an enum of instruction mnemonics.
const ( MnemonicINVALID Mnemonic = iota // invalid MnemonicAAA // aaa MnemonicAAD // aad MnemonicAAM // aam MnemonicAAS // aas MnemonicADC // adc MnemonicADCX // adcx MnemonicADD // add MnemonicADDPD // addpd MnemonicADDPS // addps MnemonicADDSD // addsd MnemonicADDSS // addss MnemonicADDSUBPD // addsubpd MnemonicADDSUBPS // addsubps MnemonicADOX // adox MnemonicAESDEC // aesdec MnemonicAESDECLAST // aesdeclast MnemonicAESENC // aesenc MnemonicAESENCLAST // aesenclast MnemonicAESIMC // aesimc MnemonicAESKEYGENASSIST // aeskeygenassist MnemonicAND // and MnemonicANDN // andn MnemonicANDNPD // andnpd MnemonicANDNPS // andnps MnemonicANDPD // andpd MnemonicANDPS // andps MnemonicARPL // arpl MnemonicBEXTR // bextr MnemonicBLCFILL // blcfill MnemonicBLCI // blci MnemonicBLCIC // blcic MnemonicBLCMSK // blcmsk MnemonicBLCS // blcs MnemonicBLENDPD // blendpd MnemonicBLENDPS // blendps MnemonicBLENDVPD // blendvpd MnemonicBLENDVPS // blendvps MnemonicBLSFILL // blsfill MnemonicBLSI // blsi MnemonicBLSIC // blsic MnemonicBLSMSK // blsmsk MnemonicBLSR // blsr MnemonicBNDCL // bndcl MnemonicBNDCN // bndcn MnemonicBNDCU // bndcu MnemonicBNDLDX // bndldx MnemonicBNDMK // bndmk MnemonicBNDMOV // bndmov MnemonicBNDSTX // bndstx MnemonicBOUND // bound MnemonicBSF // bsf MnemonicBSR // bsr MnemonicBSWAP // bswap MnemonicBT // bt MnemonicBTC // btc MnemonicBTR // btr MnemonicBTS // bts MnemonicBZHI // bzhi MnemonicCALL // call MnemonicCBW // cbw MnemonicCDQ // cdq MnemonicCDQE // cdqe MnemonicCLAC // clac MnemonicCLC // clc MnemonicCLD // cld MnemonicCLDEMOTE // cldemote MnemonicCLEVICT0 // clevict0 MnemonicCLEVICT1 // clevict1 MnemonicCLFLUSH // clflush MnemonicCLFLUSHOPT // clflushopt MnemonicCLGI // clgi MnemonicCLI // cli MnemonicCLRSSBSY // clrssbsy MnemonicCLTS // clts MnemonicCLWB // clwb MnemonicCLZERO // clzero MnemonicCMC // cmc MnemonicCMOVB // cmovb MnemonicCMOVBE // cmovbe MnemonicCMOVL // cmovl MnemonicCMOVLE // cmovle MnemonicCMOVNB // cmovnb MnemonicCMOVNBE // cmovnbe MnemonicCMOVNL // cmovnl MnemonicCMOVNLE // cmovnle MnemonicCMOVNO // cmovno MnemonicCMOVNP // cmovnp MnemonicCMOVNS // cmovns MnemonicCMOVNZ // cmovnz MnemonicCMOVO // cmovo MnemonicCMOVP // cmovp MnemonicCMOVS // cmovs MnemonicCMOVZ // cmovz MnemonicCMP // cmp MnemonicCMPPD // cmppd MnemonicCMPPS // cmpps MnemonicCMPSB // cmpsb MnemonicCMPSD // cmpsd MnemonicCMPSQ // cmpsq MnemonicCMPSS // cmpss MnemonicCMPSW // cmpsw MnemonicCMPXCHG // cmpxchg MnemonicCMPXCHG16B // cmpxchg16b MnemonicCMPXCHG8B // cmpxchg8b MnemonicCOMISD // comisd MnemonicCOMISS // comiss MnemonicCPUID // cpuid MnemonicCQO // cqo MnemonicCRC32 // crc32 MnemonicCVTDQ2PD // cvtdq2pd MnemonicCVTDQ2PS // cvtdq2ps MnemonicCVTPD2DQ // cvtpd2dq MnemonicCVTPD2PI // cvtpd2pi MnemonicCVTPD2PS // cvtpd2ps MnemonicCVTPI2PD // cvtpi2pd MnemonicCVTPI2PS // cvtpi2ps MnemonicCVTPS2DQ // cvtps2dq MnemonicCVTPS2PD // cvtps2pd MnemonicCVTPS2PI // cvtps2pi MnemonicCVTSD2SI // cvtsd2si MnemonicCVTSD2SS // cvtsd2ss MnemonicCVTSI2SD // cvtsi2sd MnemonicCVTSI2SS // cvtsi2ss MnemonicCVTSS2SD // cvtss2sd MnemonicCVTSS2SI // cvtss2si MnemonicCVTTPD2DQ // cvttpd2dq MnemonicCVTTPD2PI // cvttpd2pi MnemonicCVTTPS2DQ // cvttps2dq MnemonicCVTTPS2PI // cvttps2pi MnemonicCVTTSD2SI // cvttsd2si MnemonicCVTTSS2SI // cvttss2si MnemonicCWD // cwd MnemonicCWDE // cwde MnemonicDAA // daa MnemonicDAS // das MnemonicDEC // dec MnemonicDELAY // delay MnemonicDIV // div MnemonicDIVPD // divpd MnemonicDIVPS // divps MnemonicDIVSD // divsd MnemonicDIVSS // divss MnemonicDPPD // dppd MnemonicDPPS // dpps MnemonicEMMS // emms MnemonicENCLS // encls MnemonicENCLU // enclu MnemonicENCLV // enclv MnemonicENDBR32 // endbr32 MnemonicENDBR64 // endbr64 MnemonicENQCMD // enqcmd MnemonicENQCMDS // enqcmds MnemonicENTER // enter MnemonicEXTRACTPS // extractps MnemonicEXTRQ // extrq MnemonicF2XM1 // f2xm1 MnemonicFABS // fabs MnemonicFADD // fadd MnemonicFADDP // faddp MnemonicFBLD // fbld MnemonicFBSTP // fbstp MnemonicFCHS // fchs MnemonicFCMOVB // fcmovb MnemonicFCMOVBE // fcmovbe MnemonicFCMOVE // fcmove MnemonicFCMOVNB // fcmovnb MnemonicFCMOVNBE // fcmovnbe MnemonicFCMOVNE // fcmovne MnemonicFCMOVNU // fcmovnu MnemonicFCMOVU // fcmovu MnemonicFCOM // fcom MnemonicFCOMI // fcomi MnemonicFCOMIP // fcomip MnemonicFCOMP // fcomp MnemonicFCOMPP // fcompp MnemonicFCOS // fcos MnemonicFDECSTP // fdecstp MnemonicFDISI8087NOP // fdisi8087nop MnemonicFDIV // fdiv MnemonicFDIVP // fdivp MnemonicFDIVR // fdivr MnemonicFDIVRP // fdivrp MnemonicFEMMS // femms MnemonicFENI8087NOP // feni8087nop MnemonicFFREE // ffree MnemonicFFREEP // ffreep MnemonicFIADD // fiadd MnemonicFICOM // ficom MnemonicFICOMP // ficomp MnemonicFIDIV // fidiv MnemonicFIDIVR // fidivr MnemonicFILD // fild MnemonicFIMUL // fimul MnemonicFINCSTP // fincstp MnemonicFIST // fist MnemonicFISTP // fistp MnemonicFISTTP // fisttp MnemonicFISUB // fisub MnemonicFISUBR // fisubr MnemonicFLD // fld MnemonicFLD1 // fld1 MnemonicFLDCW // fldcw MnemonicFLDENV // fldenv MnemonicFLDL2E // fldl2e MnemonicFLDL2T // fldl2t MnemonicFLDLG2 // fldlg2 MnemonicFLDLN2 // fldln2 MnemonicFLDPI // fldpi MnemonicFLDZ // fldz MnemonicFMUL // fmul MnemonicFMULP // fmulp MnemonicFNCLEX // fnclex MnemonicFNINIT // fninit MnemonicFNOP // fnop MnemonicFNSAVE // fnsave MnemonicFNSTCW // fnstcw MnemonicFNSTENV // fnstenv MnemonicFNSTSW // fnstsw MnemonicFPATAN // fpatan MnemonicFPREM // fprem MnemonicFPREM1 // fprem1 MnemonicFPTAN // fptan MnemonicFRNDINT // frndint MnemonicFRSTOR // frstor MnemonicFSCALE // fscale MnemonicFSETPM287NOP // fsetpm287nop MnemonicFSIN // fsin MnemonicFSINCOS // fsincos MnemonicFSQRT // fsqrt MnemonicFST // fst MnemonicFSTP // fstp MnemonicFSTPNCE // fstpnce MnemonicFSUB // fsub MnemonicFSUBP // fsubp MnemonicFSUBR // fsubr MnemonicFSUBRP // fsubrp MnemonicFTST // ftst MnemonicFUCOM // fucom MnemonicFUCOMI // fucomi MnemonicFUCOMIP // fucomip MnemonicFUCOMP // fucomp MnemonicFUCOMPP // fucompp MnemonicFWAIT // fwait MnemonicFXAM // fxam MnemonicFXCH // fxch MnemonicFXRSTOR // fxrstor MnemonicFXRSTOR64 // fxrstor64 MnemonicFXSAVE // fxsave MnemonicFXSAVE64 // fxsave64 MnemonicFXTRACT // fxtract MnemonicFYL2X // fyl2x MnemonicFYL2XP1 // fyl2xp1 MnemonicGETSEC // getsec MnemonicGF2P8AFFINEINVQB // gf2p8affineinvqb MnemonicGF2P8AFFINEQB // gf2p8affineqb MnemonicGF2P8MULB // gf2p8mulb MnemonicHADDPD // haddpd MnemonicHADDPS // haddps MnemonicHLT // hlt MnemonicHSUBPD // hsubpd MnemonicHSUBPS // hsubps MnemonicIDIV // idiv MnemonicIMUL // imul MnemonicIN // in MnemonicINC // inc MnemonicINCSSPD // incsspd MnemonicINCSSPQ // incsspq MnemonicINSB // insb MnemonicINSD // insd MnemonicINSERTPS // insertps MnemonicINSERTQ // insertq MnemonicINSW // insw MnemonicINT // int MnemonicINT1 // int1 MnemonicINT3 // int3 MnemonicINTO // into MnemonicINVD // invd MnemonicINVEPT // invept MnemonicINVLPG // invlpg MnemonicINVLPGA // invlpga MnemonicINVLPGB // invlpgb MnemonicINVPCID // invpcid MnemonicINVVPID // invvpid MnemonicIRET // iret MnemonicIRETD // iretd MnemonicIRETQ // iretq MnemonicJB // jb MnemonicJBE // jbe MnemonicJCXZ // jcxz MnemonicJECXZ // jecxz MnemonicJKNZD // jknzd MnemonicJKZD // jkzd MnemonicJL // jl MnemonicJLE // jle MnemonicJMP // jmp MnemonicJNB // jnb MnemonicJNBE // jnbe MnemonicJNL // jnl MnemonicJNLE // jnle MnemonicJNO // jno MnemonicJNP // jnp MnemonicJNS // jns MnemonicJNZ // jnz MnemonicJO // jo MnemonicJP // jp MnemonicJRCXZ // jrcxz MnemonicJS // js MnemonicJZ // jz MnemonicKADDB // kaddb MnemonicKADDD // kaddd MnemonicKADDQ // kaddq MnemonicKADDW // kaddw MnemonicKAND // kand MnemonicKANDB // kandb MnemonicKANDD // kandd MnemonicKANDN // kandn MnemonicKANDNB // kandnb MnemonicKANDND // kandnd MnemonicKANDNQ // kandnq MnemonicKANDNR // kandnr MnemonicKANDNW // kandnw MnemonicKANDQ // kandq MnemonicKANDW // kandw MnemonicKCONCATH // kconcath MnemonicKCONCATL // kconcatl MnemonicKEXTRACT // kextract MnemonicKMERGE2L1H // kmerge2l1h MnemonicKMERGE2L1L // kmerge2l1l MnemonicKMOV // kmov MnemonicKMOVB // kmovb MnemonicKMOVD // kmovd MnemonicKMOVQ // kmovq MnemonicKMOVW // kmovw MnemonicKNOT // knot MnemonicKNOTB // knotb MnemonicKNOTD // knotd MnemonicKNOTQ // knotq MnemonicKNOTW // knotw MnemonicKOR // kor MnemonicKORB // korb MnemonicKORD // kord MnemonicKORQ // korq MnemonicKORTEST // kortest MnemonicKORTESTB // kortestb MnemonicKORTESTD // kortestd MnemonicKORTESTQ // kortestq MnemonicKORTESTW // kortestw MnemonicKORW // korw MnemonicKSHIFTLB // kshiftlb MnemonicKSHIFTLD // kshiftld MnemonicKSHIFTLQ // kshiftlq MnemonicKSHIFTLW // kshiftlw MnemonicKSHIFTRB // kshiftrb MnemonicKSHIFTRD // kshiftrd MnemonicKSHIFTRQ // kshiftrq MnemonicKSHIFTRW // kshiftrw MnemonicKTESTB // ktestb MnemonicKTESTD // ktestd MnemonicKTESTQ // ktestq MnemonicKTESTW // ktestw MnemonicKUNPCKBW // kunpckbw MnemonicKUNPCKDQ // kunpckdq MnemonicKUNPCKWD // kunpckwd MnemonicKXNOR // kxnor MnemonicKXNORB // kxnorb MnemonicKXNORD // kxnord MnemonicKXNORQ // kxnorq MnemonicKXNORW // kxnorw MnemonicKXOR // kxor MnemonicKXORB // kxorb MnemonicKXORD // kxord MnemonicKXORQ // kxorq MnemonicKXORW // kxorw MnemonicLAHF // lahf MnemonicLAR // lar MnemonicLDDQU // lddqu MnemonicLDMXCSR // ldmxcsr MnemonicLDS // lds MnemonicLDTILECFG // ldtilecfg MnemonicLEA // lea MnemonicLEAVE // leave MnemonicLES // les MnemonicLFENCE // lfence MnemonicLFS // lfs MnemonicLGDT // lgdt MnemonicLGS // lgs MnemonicLIDT // lidt MnemonicLLDT // lldt MnemonicLLWPCB // llwpcb MnemonicLMSW // lmsw MnemonicLODSB // lodsb MnemonicLODSD // lodsd MnemonicLODSQ // lodsq MnemonicLODSW // lodsw MnemonicLOOP // loop MnemonicLOOPE // loope MnemonicLOOPNE // loopne MnemonicLSL // lsl MnemonicLSS // lss MnemonicLTR // ltr MnemonicLWPINS // lwpins MnemonicLWPVAL // lwpval MnemonicLZCNT // lzcnt MnemonicMASKMOVDQU // maskmovdqu MnemonicMASKMOVQ // maskmovq MnemonicMAXPD // maxpd MnemonicMAXPS // maxps MnemonicMAXSD // maxsd MnemonicMAXSS // maxss MnemonicMCOMMIT // mcommit MnemonicMFENCE // mfence MnemonicMINPD // minpd MnemonicMINPS // minps MnemonicMINSD // minsd MnemonicMINSS // minss MnemonicMONITOR // monitor MnemonicMONITORX // monitorx MnemonicMONTMUL // montmul MnemonicMOV // mov MnemonicMOVAPD // movapd MnemonicMOVAPS // movaps MnemonicMOVBE // movbe MnemonicMOVD // movd MnemonicMOVDDUP // movddup MnemonicMOVDIR64B // movdir64b MnemonicMOVDIRI // movdiri MnemonicMOVDQ2Q // movdq2q MnemonicMOVDQA // movdqa MnemonicMOVDQU // movdqu MnemonicMOVHLPS // movhlps MnemonicMOVHPD // movhpd MnemonicMOVHPS // movhps MnemonicMOVLHPS // movlhps MnemonicMOVLPD // movlpd MnemonicMOVLPS // movlps MnemonicMOVMSKPD // movmskpd MnemonicMOVMSKPS // movmskps MnemonicMOVNTDQ // movntdq MnemonicMOVNTDQA // movntdqa MnemonicMOVNTI // movnti MnemonicMOVNTPD // movntpd MnemonicMOVNTPS // movntps MnemonicMOVNTQ // movntq MnemonicMOVNTSD // movntsd MnemonicMOVNTSS // movntss MnemonicMOVQ // movq MnemonicMOVQ2DQ // movq2dq MnemonicMOVSB // movsb MnemonicMOVSD // movsd MnemonicMOVSHDUP // movshdup MnemonicMOVSLDUP // movsldup MnemonicMOVSQ // movsq MnemonicMOVSS // movss MnemonicMOVSW // movsw MnemonicMOVSX // movsx MnemonicMOVSXD // movsxd MnemonicMOVUPD // movupd MnemonicMOVUPS // movups MnemonicMOVZX // movzx MnemonicMPSADBW // mpsadbw MnemonicMUL // mul MnemonicMULPD // mulpd MnemonicMULPS // mulps MnemonicMULSD // mulsd MnemonicMULSS // mulss MnemonicMULX // mulx MnemonicMWAIT // mwait MnemonicMWAITX // mwaitx MnemonicNEG // neg MnemonicNOP // nop MnemonicNOT // not MnemonicOR // or MnemonicORPD // orpd MnemonicORPS // orps MnemonicOUT // out MnemonicOUTSB // outsb MnemonicOUTSD // outsd MnemonicOUTSW // outsw MnemonicPABSB // pabsb MnemonicPABSD // pabsd MnemonicPABSW // pabsw MnemonicPACKSSDW // packssdw MnemonicPACKSSWB // packsswb MnemonicPACKUSDW // packusdw MnemonicPACKUSWB // packuswb MnemonicPADDB // paddb MnemonicPADDD // paddd MnemonicPADDQ // paddq MnemonicPADDSB // paddsb MnemonicPADDSW // paddsw MnemonicPADDUSB // paddusb MnemonicPADDUSW // paddusw MnemonicPADDW // paddw MnemonicPALIGNR // palignr MnemonicPAND // pand MnemonicPANDN // pandn MnemonicPAUSE // pause MnemonicPAVGB // pavgb MnemonicPAVGUSB // pavgusb MnemonicPAVGW // pavgw MnemonicPBLENDVB // pblendvb MnemonicPBLENDW // pblendw MnemonicPCLMULQDQ // pclmulqdq MnemonicPCMPEQB // pcmpeqb MnemonicPCMPEQD // pcmpeqd MnemonicPCMPEQQ // pcmpeqq MnemonicPCMPEQW // pcmpeqw MnemonicPCMPESTRI // pcmpestri MnemonicPCMPESTRM // pcmpestrm MnemonicPCMPGTB // pcmpgtb MnemonicPCMPGTD // pcmpgtd MnemonicPCMPGTQ // pcmpgtq MnemonicPCMPGTW // pcmpgtw MnemonicPCMPISTRI // pcmpistri MnemonicPCMPISTRM // pcmpistrm MnemonicPCONFIG // pconfig MnemonicPDEP // pdep MnemonicPEXT // pext MnemonicPEXTRB // pextrb MnemonicPEXTRD // pextrd MnemonicPEXTRQ // pextrq MnemonicPEXTRW // pextrw MnemonicPF2ID // pf2id MnemonicPF2IW // pf2iw MnemonicPFACC // pfacc MnemonicPFADD // pfadd MnemonicPFCMPEQ // pfcmpeq MnemonicPFCMPGE // pfcmpge MnemonicPFCMPGT // pfcmpgt MnemonicPFCPIT1 // pfcpit1 MnemonicPFMAX // pfmax MnemonicPFMIN // pfmin MnemonicPFMUL // pfmul MnemonicPFNACC // pfnacc MnemonicPFPNACC // pfpnacc MnemonicPFRCP // pfrcp MnemonicPFRCPIT2 // pfrcpit2 MnemonicPFRSQIT1 // pfrsqit1 MnemonicPFSQRT // pfsqrt MnemonicPFSUB // pfsub MnemonicPFSUBR // pfsubr MnemonicPHADDD // phaddd MnemonicPHADDSW // phaddsw MnemonicPHADDW // phaddw MnemonicPHMINPOSUW // phminposuw MnemonicPHSUBD // phsubd MnemonicPHSUBSW // phsubsw MnemonicPHSUBW // phsubw MnemonicPI2FD // pi2fd MnemonicPI2FW // pi2fw MnemonicPINSRB // pinsrb MnemonicPINSRD // pinsrd MnemonicPINSRQ // pinsrq MnemonicPINSRW // pinsrw MnemonicPMADDUBSW // pmaddubsw MnemonicPMADDWD // pmaddwd MnemonicPMAXSB // pmaxsb MnemonicPMAXSD // pmaxsd MnemonicPMAXSW // pmaxsw MnemonicPMAXUB // pmaxub MnemonicPMAXUD // pmaxud MnemonicPMAXUW // pmaxuw MnemonicPMINSB // pminsb MnemonicPMINSD // pminsd MnemonicPMINSW // pminsw MnemonicPMINUB // pminub MnemonicPMINUD // pminud MnemonicPMINUW // pminuw MnemonicPMOVMSKB // pmovmskb MnemonicPMOVSXBD // pmovsxbd MnemonicPMOVSXBQ // pmovsxbq MnemonicPMOVSXBW // pmovsxbw MnemonicPMOVSXDQ // pmovsxdq MnemonicPMOVSXWD // pmovsxwd MnemonicPMOVSXWQ // pmovsxwq MnemonicPMOVZXBD // pmovzxbd MnemonicPMOVZXBQ // pmovzxbq MnemonicPMOVZXBW // pmovzxbw MnemonicPMOVZXDQ // pmovzxdq MnemonicPMOVZXWD // pmovzxwd MnemonicPMOVZXWQ // pmovzxwq MnemonicPMULDQ // pmuldq MnemonicPMULHRSW // pmulhrsw MnemonicPMULHRW // pmulhrw MnemonicPMULHUW // pmulhuw MnemonicPMULHW // pmulhw MnemonicPMULLD // pmulld MnemonicPMULLW // pmullw MnemonicPMULUDQ // pmuludq MnemonicPOP // pop MnemonicPOPA // popa MnemonicPOPAD // popad MnemonicPOPCNT // popcnt MnemonicPOPF // popf MnemonicPOPFD // popfd MnemonicPOPFQ // popfq MnemonicPOR // por MnemonicPREFETCH // prefetch MnemonicPREFETCHNTA // prefetchnta MnemonicPREFETCHT0 // prefetcht0 MnemonicPREFETCHT1 // prefetcht1 MnemonicPREFETCHT2 // prefetcht2 MnemonicPREFETCHW // prefetchw MnemonicPREFETCHWT1 // prefetchwt1 MnemonicPSADBW // psadbw MnemonicPSHUFB // pshufb MnemonicPSHUFD // pshufd MnemonicPSHUFHW // pshufhw MnemonicPSHUFLW // pshuflw MnemonicPSHUFW // pshufw MnemonicPSIGNB // psignb MnemonicPSIGND // psignd MnemonicPSIGNW // psignw MnemonicPSLLD // pslld MnemonicPSLLDQ // pslldq MnemonicPSLLQ // psllq MnemonicPSLLW // psllw MnemonicPSMASH // psmash MnemonicPSRAD // psrad MnemonicPSRAW // psraw MnemonicPSRLD // psrld MnemonicPSRLDQ // psrldq MnemonicPSRLQ // psrlq MnemonicPSRLW // psrlw MnemonicPSUBB // psubb MnemonicPSUBD // psubd MnemonicPSUBQ // psubq MnemonicPSUBSB // psubsb MnemonicPSUBSW // psubsw MnemonicPSUBUSB // psubusb MnemonicPSUBUSW // psubusw MnemonicPSUBW // psubw MnemonicPSWAPD // pswapd MnemonicPTEST // ptest MnemonicPTWRITE // ptwrite MnemonicPUNPCKHBW // punpckhbw MnemonicPUNPCKHDQ // punpckhdq MnemonicPUNPCKHQDQ // punpckhqdq MnemonicPUNPCKHWD // punpckhwd MnemonicPUNPCKLBW // punpcklbw MnemonicPUNPCKLDQ // punpckldq MnemonicPUNPCKLQDQ // punpcklqdq MnemonicPUNPCKLWD // punpcklwd MnemonicPUSH // push MnemonicPUSHA // pusha MnemonicPUSHAD // pushad MnemonicPUSHF // pushf MnemonicPUSHFD // pushfd MnemonicPUSHFQ // pushfq MnemonicPVALIDATE // pvalidate MnemonicPXOR // pxor MnemonicRCL // rcl MnemonicRCPPS // rcpps MnemonicRCPSS // rcpss MnemonicRCR // rcr MnemonicRDFSBASE // rdfsbase MnemonicRDGSBASE // rdgsbase MnemonicRDMSR // rdmsr MnemonicRDPID // rdpid MnemonicRDPKRU // rdpkru MnemonicRDPMC // rdpmc MnemonicRDPRU // rdpru MnemonicRDRAND // rdrand MnemonicRDSEED // rdseed MnemonicRDSSPD // rdsspd MnemonicRDSSPQ // rdsspq MnemonicRDTSC // rdtsc MnemonicRDTSCP // rdtscp MnemonicRET // ret MnemonicRMPADJUST // rmpadjust MnemonicRMPUPDATE // rmpupdate MnemonicROL // rol MnemonicROR // ror MnemonicRORX // rorx MnemonicROUNDPD // roundpd MnemonicROUNDPS // roundps MnemonicROUNDSD // roundsd MnemonicROUNDSS // roundss MnemonicRSM // rsm MnemonicRSQRTPS // rsqrtps MnemonicRSQRTSS // rsqrtss MnemonicRSTORSSP // rstorssp MnemonicSAHF // sahf MnemonicSALC // salc MnemonicSAR // sar MnemonicSARX // sarx MnemonicSAVEPREVSSP // saveprevssp MnemonicSBB // sbb MnemonicSCASB // scasb MnemonicSCASD // scasd MnemonicSCASQ // scasq MnemonicSCASW // scasw MnemonicSERIALIZE // serialize MnemonicSETB // setb MnemonicSETBE // setbe MnemonicSETL // setl MnemonicSETLE // setle MnemonicSETNB // setnb MnemonicSETNBE // setnbe MnemonicSETNL // setnl MnemonicSETNLE // setnle MnemonicSETNO // setno MnemonicSETNP // setnp MnemonicSETNS // setns MnemonicSETNZ // setnz MnemonicSETO // seto MnemonicSETP // setp MnemonicSETS // sets MnemonicSETSSBSY // setssbsy MnemonicSETZ // setz MnemonicSFENCE // sfence MnemonicSGDT // sgdt MnemonicSHA1MSG1 // sha1msg1 MnemonicSHA1MSG2 // sha1msg2 MnemonicSHA1NEXTE // sha1nexte MnemonicSHA1RNDS4 // sha1rnds4 MnemonicSHA256MSG1 // sha256msg1 MnemonicSHA256MSG2 // sha256msg2 MnemonicSHA256RNDS2 // sha256rnds2 MnemonicSHL // shl MnemonicSHLD // shld MnemonicSHLX // shlx MnemonicSHR // shr MnemonicSHRD // shrd MnemonicSHRX // shrx MnemonicSHUFPD // shufpd MnemonicSHUFPS // shufps MnemonicSIDT // sidt MnemonicSKINIT // skinit MnemonicSLDT // sldt MnemonicSLWPCB // slwpcb MnemonicSMSW // smsw MnemonicSPFLT // spflt MnemonicSQRTPD // sqrtpd MnemonicSQRTPS // sqrtps MnemonicSQRTSD // sqrtsd MnemonicSQRTSS // sqrtss MnemonicSTAC // stac MnemonicSTC // stc MnemonicSTD // std MnemonicSTGI // stgi MnemonicSTI // sti MnemonicSTMXCSR // stmxcsr MnemonicSTOSB // stosb MnemonicSTOSD // stosd MnemonicSTOSQ // stosq MnemonicSTOSW // stosw MnemonicSTR // str MnemonicSTTILECFG // sttilecfg MnemonicSUB // sub MnemonicSUBPD // subpd MnemonicSUBPS // subps MnemonicSUBSD // subsd MnemonicSUBSS // subss MnemonicSWAPGS // swapgs MnemonicSYSCALL // syscall MnemonicSYSENTER // sysenter MnemonicSYSEXIT // sysexit MnemonicSYSRET // sysret MnemonicT1MSKC // t1mskc MnemonicTDPBF16PS // tdpbf16ps MnemonicTDPBSSD // tdpbssd MnemonicTDPBSUD // tdpbsud MnemonicTDPBUSD // tdpbusd MnemonicTDPBUUD // tdpbuud MnemonicTEST // test MnemonicTILELOADD // tileloadd MnemonicTILELOADDT1 // tileloaddt1 MnemonicTILERELEASE // tilerelease MnemonicTILESTORED // tilestored MnemonicTILEZERO // tilezero MnemonicTLBSYNC // tlbsync MnemonicTPAUSE // tpause MnemonicTZCNT // tzcnt MnemonicTZCNTI // tzcnti MnemonicTZMSK // tzmsk MnemonicUCOMISD // ucomisd MnemonicUCOMISS // ucomiss MnemonicUD0 // ud0 MnemonicUD1 // ud1 MnemonicUD2 // ud2 MnemonicUMONITOR // umonitor MnemonicUMWAIT // umwait MnemonicUNPCKHPD // unpckhpd MnemonicUNPCKHPS // unpckhps MnemonicUNPCKLPD // unpcklpd MnemonicUNPCKLPS // unpcklps MnemonicV4FMADDPS // v4fmaddps MnemonicV4FMADDSS // v4fmaddss MnemonicV4FNMADDPS // v4fnmaddps MnemonicV4FNMADDSS // v4fnmaddss MnemonicVADDNPD // vaddnpd MnemonicVADDNPS // vaddnps MnemonicVADDPD // vaddpd MnemonicVADDPS // vaddps MnemonicVADDSD // vaddsd MnemonicVADDSETSPS // vaddsetsps MnemonicVADDSS // vaddss MnemonicVADDSUBPD // vaddsubpd MnemonicVADDSUBPS // vaddsubps MnemonicVAESDEC // vaesdec MnemonicVAESDECLAST // vaesdeclast MnemonicVAESENC // vaesenc MnemonicVAESENCLAST // vaesenclast MnemonicVAESIMC // vaesimc MnemonicVAESKEYGENASSIST // vaeskeygenassist MnemonicVALIGND // valignd MnemonicVALIGNQ // valignq MnemonicVANDNPD // vandnpd MnemonicVANDNPS // vandnps MnemonicVANDPD // vandpd MnemonicVANDPS // vandps MnemonicVBLENDMPD // vblendmpd MnemonicVBLENDMPS // vblendmps MnemonicVBLENDPD // vblendpd MnemonicVBLENDPS // vblendps MnemonicVBLENDVPD // vblendvpd MnemonicVBLENDVPS // vblendvps MnemonicVBROADCASTF128 // vbroadcastf128 MnemonicVBROADCASTF32X2 // vbroadcastf32x2 MnemonicVBROADCASTF32X4 // vbroadcastf32x4 MnemonicVBROADCASTF32X8 // vbroadcastf32x8 MnemonicVBROADCASTF64X2 // vbroadcastf64x2 MnemonicVBROADCASTF64X4 // vbroadcastf64x4 MnemonicVBROADCASTI128 // vbroadcasti128 MnemonicVBROADCASTI32X2 // vbroadcasti32x2 MnemonicVBROADCASTI32X4 // vbroadcasti32x4 MnemonicVBROADCASTI32X8 // vbroadcasti32x8 MnemonicVBROADCASTI64X2 // vbroadcasti64x2 MnemonicVBROADCASTI64X4 // vbroadcasti64x4 MnemonicVBROADCASTSD // vbroadcastsd MnemonicVBROADCASTSS // vbroadcastss MnemonicVCMPPD // vcmppd MnemonicVCMPPS // vcmpps MnemonicVCMPSD // vcmpsd MnemonicVCMPSS // vcmpss MnemonicVCOMISD // vcomisd MnemonicVCOMISS // vcomiss MnemonicVCOMPRESSPD // vcompresspd MnemonicVCOMPRESSPS // vcompressps MnemonicVCVTDQ2PD // vcvtdq2pd MnemonicVCVTDQ2PS // vcvtdq2ps MnemonicVCVTFXPNTDQ2PS // vcvtfxpntdq2ps MnemonicVCVTFXPNTPD2DQ // vcvtfxpntpd2dq MnemonicVCVTFXPNTPD2UDQ // vcvtfxpntpd2udq MnemonicVCVTFXPNTPS2DQ // vcvtfxpntps2dq MnemonicVCVTFXPNTPS2UDQ // vcvtfxpntps2udq MnemonicVCVTFXPNTUDQ2PS // vcvtfxpntudq2ps MnemonicVCVTNE2PS2BF16 // vcvtne2ps2bf16 MnemonicVCVTNEPS2BF16 // vcvtneps2bf16 MnemonicVCVTPD2DQ // vcvtpd2dq MnemonicVCVTPD2PS // vcvtpd2ps MnemonicVCVTPD2QQ // vcvtpd2qq MnemonicVCVTPD2UDQ // vcvtpd2udq MnemonicVCVTPD2UQQ // vcvtpd2uqq MnemonicVCVTPH2PS // vcvtph2ps MnemonicVCVTPS2DQ // vcvtps2dq MnemonicVCVTPS2PD // vcvtps2pd MnemonicVCVTPS2PH // vcvtps2ph MnemonicVCVTPS2QQ // vcvtps2qq MnemonicVCVTPS2UDQ // vcvtps2udq MnemonicVCVTPS2UQQ // vcvtps2uqq MnemonicVCVTQQ2PD // vcvtqq2pd MnemonicVCVTQQ2PS // vcvtqq2ps MnemonicVCVTSD2SI // vcvtsd2si MnemonicVCVTSD2SS // vcvtsd2ss MnemonicVCVTSD2USI // vcvtsd2usi MnemonicVCVTSI2SD // vcvtsi2sd MnemonicVCVTSI2SS // vcvtsi2ss MnemonicVCVTSS2SD // vcvtss2sd MnemonicVCVTSS2SI // vcvtss2si MnemonicVCVTSS2USI // vcvtss2usi MnemonicVCVTTPD2DQ // vcvttpd2dq MnemonicVCVTTPD2QQ // vcvttpd2qq MnemonicVCVTTPD2UDQ // vcvttpd2udq MnemonicVCVTTPD2UQQ // vcvttpd2uqq MnemonicVCVTTPS2DQ // vcvttps2dq MnemonicVCVTTPS2QQ // vcvttps2qq MnemonicVCVTTPS2UDQ // vcvttps2udq MnemonicVCVTTPS2UQQ // vcvttps2uqq MnemonicVCVTTSD2SI // vcvttsd2si MnemonicVCVTTSD2USI // vcvttsd2usi MnemonicVCVTTSS2SI // vcvttss2si MnemonicVCVTTSS2USI // vcvttss2usi MnemonicVCVTUDQ2PD // vcvtudq2pd MnemonicVCVTUDQ2PS // vcvtudq2ps MnemonicVCVTUQQ2PD // vcvtuqq2pd MnemonicVCVTUQQ2PS // vcvtuqq2ps MnemonicVCVTUSI2SD // vcvtusi2sd MnemonicVCVTUSI2SS // vcvtusi2ss MnemonicVDBPSADBW // vdbpsadbw MnemonicVDIVPD // vdivpd MnemonicVDIVPS // vdivps MnemonicVDIVSD // vdivsd MnemonicVDIVSS // vdivss MnemonicVDPBF16PS // vdpbf16ps MnemonicVDPPD // vdppd MnemonicVDPPS // vdpps MnemonicVERR // verr MnemonicVERW // verw MnemonicVEXP223PS // vexp223ps MnemonicVEXP2PD // vexp2pd MnemonicVEXP2PS // vexp2ps MnemonicVEXPANDPD // vexpandpd MnemonicVEXPANDPS // vexpandps MnemonicVEXTRACTF128 // vextractf128 MnemonicVEXTRACTF32X4 // vextractf32x4 MnemonicVEXTRACTF32X8 // vextractf32x8 MnemonicVEXTRACTF64X2 // vextractf64x2 MnemonicVEXTRACTF64X4 // vextractf64x4 MnemonicVEXTRACTI128 // vextracti128 MnemonicVEXTRACTI32X4 // vextracti32x4 MnemonicVEXTRACTI32X8 // vextracti32x8 MnemonicVEXTRACTI64X2 // vextracti64x2 MnemonicVEXTRACTI64X4 // vextracti64x4 MnemonicVEXTRACTPS // vextractps MnemonicVFIXUPIMMPD // vfixupimmpd MnemonicVFIXUPIMMPS // vfixupimmps MnemonicVFIXUPIMMSD // vfixupimmsd MnemonicVFIXUPIMMSS // vfixupimmss MnemonicVFIXUPNANPD // vfixupnanpd MnemonicVFIXUPNANPS // vfixupnanps MnemonicVFMADD132PD // vfmadd132pd MnemonicVFMADD132PS // vfmadd132ps MnemonicVFMADD132SD // vfmadd132sd MnemonicVFMADD132SS // vfmadd132ss MnemonicVFMADD213PD // vfmadd213pd MnemonicVFMADD213PS // vfmadd213ps MnemonicVFMADD213SD // vfmadd213sd MnemonicVFMADD213SS // vfmadd213ss MnemonicVFMADD231PD // vfmadd231pd MnemonicVFMADD231PS // vfmadd231ps MnemonicVFMADD231SD // vfmadd231sd MnemonicVFMADD231SS // vfmadd231ss MnemonicVFMADD233PS // vfmadd233ps MnemonicVFMADDPD // vfmaddpd MnemonicVFMADDPS // vfmaddps MnemonicVFMADDSD // vfmaddsd MnemonicVFMADDSS // vfmaddss MnemonicVFMADDSUB132PD // vfmaddsub132pd MnemonicVFMADDSUB132PS // vfmaddsub132ps MnemonicVFMADDSUB213PD // vfmaddsub213pd MnemonicVFMADDSUB213PS // vfmaddsub213ps MnemonicVFMADDSUB231PD // vfmaddsub231pd MnemonicVFMADDSUB231PS // vfmaddsub231ps MnemonicVFMADDSUBPD // vfmaddsubpd MnemonicVFMADDSUBPS // vfmaddsubps MnemonicVFMSUB132PD // vfmsub132pd MnemonicVFMSUB132PS // vfmsub132ps MnemonicVFMSUB132SD // vfmsub132sd MnemonicVFMSUB132SS // vfmsub132ss MnemonicVFMSUB213PD // vfmsub213pd MnemonicVFMSUB213PS // vfmsub213ps MnemonicVFMSUB213SD // vfmsub213sd MnemonicVFMSUB213SS // vfmsub213ss MnemonicVFMSUB231PD // vfmsub231pd MnemonicVFMSUB231PS // vfmsub231ps MnemonicVFMSUB231SD // vfmsub231sd MnemonicVFMSUB231SS // vfmsub231ss MnemonicVFMSUBADD132PD // vfmsubadd132pd MnemonicVFMSUBADD132PS // vfmsubadd132ps MnemonicVFMSUBADD213PD // vfmsubadd213pd MnemonicVFMSUBADD213PS // vfmsubadd213ps MnemonicVFMSUBADD231PD // vfmsubadd231pd MnemonicVFMSUBADD231PS // vfmsubadd231ps MnemonicVFMSUBADDPD // vfmsubaddpd MnemonicVFMSUBADDPS // vfmsubaddps MnemonicVFMSUBPD // vfmsubpd MnemonicVFMSUBPS // vfmsubps MnemonicVFMSUBSD // vfmsubsd MnemonicVFMSUBSS // vfmsubss MnemonicVFNMADD132PD // vfnmadd132pd MnemonicVFNMADD132PS // vfnmadd132ps MnemonicVFNMADD132SD // vfnmadd132sd MnemonicVFNMADD132SS // vfnmadd132ss MnemonicVFNMADD213PD // vfnmadd213pd MnemonicVFNMADD213PS // vfnmadd213ps MnemonicVFNMADD213SD // vfnmadd213sd MnemonicVFNMADD213SS // vfnmadd213ss MnemonicVFNMADD231PD // vfnmadd231pd MnemonicVFNMADD231PS // vfnmadd231ps MnemonicVFNMADD231SD // vfnmadd231sd MnemonicVFNMADD231SS // vfnmadd231ss MnemonicVFNMADDPD // vfnmaddpd MnemonicVFNMADDPS // vfnmaddps MnemonicVFNMADDSD // vfnmaddsd MnemonicVFNMADDSS // vfnmaddss MnemonicVFNMSUB132PD // vfnmsub132pd MnemonicVFNMSUB132PS // vfnmsub132ps MnemonicVFNMSUB132SD // vfnmsub132sd MnemonicVFNMSUB132SS // vfnmsub132ss MnemonicVFNMSUB213PD // vfnmsub213pd MnemonicVFNMSUB213PS // vfnmsub213ps MnemonicVFNMSUB213SD // vfnmsub213sd MnemonicVFNMSUB213SS // vfnmsub213ss MnemonicVFNMSUB231PD // vfnmsub231pd MnemonicVFNMSUB231PS // vfnmsub231ps MnemonicVFNMSUB231SD // vfnmsub231sd MnemonicVFNMSUB231SS // vfnmsub231ss MnemonicVFNMSUBPD // vfnmsubpd MnemonicVFNMSUBPS // vfnmsubps MnemonicVFNMSUBSD // vfnmsubsd MnemonicVFNMSUBSS // vfnmsubss MnemonicVFPCLASSPD // vfpclasspd MnemonicVFPCLASSPS // vfpclassps MnemonicVFPCLASSSD // vfpclasssd MnemonicVFPCLASSSS // vfpclassss MnemonicVFRCZPD // vfrczpd MnemonicVFRCZPS // vfrczps MnemonicVFRCZSD // vfrczsd MnemonicVFRCZSS // vfrczss MnemonicVGATHERDPD // vgatherdpd MnemonicVGATHERDPS // vgatherdps MnemonicVGATHERPF0DPD // vgatherpf0dpd MnemonicVGATHERPF0DPS // vgatherpf0dps MnemonicVGATHERPF0HINTDPD // vgatherpf0hintdpd MnemonicVGATHERPF0HINTDPS // vgatherpf0hintdps MnemonicVGATHERPF0QPD // vgatherpf0qpd MnemonicVGATHERPF0QPS // vgatherpf0qps MnemonicVGATHERPF1DPD // vgatherpf1dpd MnemonicVGATHERPF1DPS // vgatherpf1dps MnemonicVGATHERPF1QPD // vgatherpf1qpd MnemonicVGATHERPF1QPS // vgatherpf1qps MnemonicVGATHERQPD // vgatherqpd MnemonicVGATHERQPS // vgatherqps MnemonicVGETEXPPD // vgetexppd MnemonicVGETEXPPS // vgetexpps MnemonicVGETEXPSD // vgetexpsd MnemonicVGETEXPSS // vgetexpss MnemonicVGETMANTPD // vgetmantpd MnemonicVGETMANTPS // vgetmantps MnemonicVGETMANTSD // vgetmantsd MnemonicVGETMANTSS // vgetmantss MnemonicVGF2P8AFFINEINVQB // vgf2p8affineinvqb MnemonicVGF2P8AFFINEQB // vgf2p8affineqb MnemonicVGF2P8MULB // vgf2p8mulb MnemonicVGMAXABSPS // vgmaxabsps MnemonicVGMAXPD // vgmaxpd MnemonicVGMAXPS // vgmaxps MnemonicVGMINPD // vgminpd MnemonicVGMINPS // vgminps MnemonicVHADDPD // vhaddpd MnemonicVHADDPS // vhaddps MnemonicVHSUBPD // vhsubpd MnemonicVHSUBPS // vhsubps MnemonicVINSERTF128 // vinsertf128 MnemonicVINSERTF32X4 // vinsertf32x4 MnemonicVINSERTF32X8 // vinsertf32x8 MnemonicVINSERTF64X2 // vinsertf64x2 MnemonicVINSERTF64X4 // vinsertf64x4 MnemonicVINSERTI128 // vinserti128 MnemonicVINSERTI32X4 // vinserti32x4 MnemonicVINSERTI32X8 // vinserti32x8 MnemonicVINSERTI64X2 // vinserti64x2 MnemonicVINSERTI64X4 // vinserti64x4 MnemonicVINSERTPS // vinsertps MnemonicVLDDQU // vlddqu MnemonicVLDMXCSR // vldmxcsr MnemonicVLOADUNPACKHD // vloadunpackhd MnemonicVLOADUNPACKHPD // vloadunpackhpd MnemonicVLOADUNPACKHPS // vloadunpackhps MnemonicVLOADUNPACKHQ // vloadunpackhq MnemonicVLOADUNPACKLD // vloadunpackld MnemonicVLOADUNPACKLPD // vloadunpacklpd MnemonicVLOADUNPACKLPS // vloadunpacklps MnemonicVLOADUNPACKLQ // vloadunpacklq MnemonicVLOG2PS // vlog2ps MnemonicVMASKMOVDQU // vmaskmovdqu MnemonicVMASKMOVPD // vmaskmovpd MnemonicVMASKMOVPS // vmaskmovps MnemonicVMAXPD // vmaxpd MnemonicVMAXPS // vmaxps MnemonicVMAXSD // vmaxsd MnemonicVMAXSS // vmaxss MnemonicVMCALL // vmcall MnemonicVMCLEAR // vmclear MnemonicVMFUNC // vmfunc MnemonicVMINPD // vminpd MnemonicVMINPS // vminps MnemonicVMINSD // vminsd MnemonicVMINSS // vminss MnemonicVMLAUNCH // vmlaunch MnemonicVMLOAD // vmload MnemonicVMMCALL // vmmcall MnemonicVMOVAPD // vmovapd MnemonicVMOVAPS // vmovaps MnemonicVMOVD // vmovd MnemonicVMOVDDUP // vmovddup MnemonicVMOVDQA // vmovdqa MnemonicVMOVDQA32 // vmovdqa32 MnemonicVMOVDQA64 // vmovdqa64 MnemonicVMOVDQU // vmovdqu MnemonicVMOVDQU16 // vmovdqu16 MnemonicVMOVDQU32 // vmovdqu32 MnemonicVMOVDQU64 // vmovdqu64 MnemonicVMOVDQU8 // vmovdqu8 MnemonicVMOVHLPS // vmovhlps MnemonicVMOVHPD // vmovhpd MnemonicVMOVHPS // vmovhps MnemonicVMOVLHPS // vmovlhps MnemonicVMOVLPD // vmovlpd MnemonicVMOVLPS // vmovlps MnemonicVMOVMSKPD // vmovmskpd MnemonicVMOVMSKPS // vmovmskps MnemonicVMOVNRAPD // vmovnrapd MnemonicVMOVNRAPS // vmovnraps MnemonicVMOVNRNGOAPD // vmovnrngoapd MnemonicVMOVNRNGOAPS // vmovnrngoaps MnemonicVMOVNTDQ // vmovntdq MnemonicVMOVNTDQA // vmovntdqa MnemonicVMOVNTPD // vmovntpd MnemonicVMOVNTPS // vmovntps MnemonicVMOVQ // vmovq MnemonicVMOVSD // vmovsd MnemonicVMOVSHDUP // vmovshdup MnemonicVMOVSLDUP // vmovsldup MnemonicVMOVSS // vmovss MnemonicVMOVUPD // vmovupd MnemonicVMOVUPS // vmovups MnemonicVMPSADBW // vmpsadbw MnemonicVMPTRLD // vmptrld MnemonicVMPTRST // vmptrst MnemonicVMREAD // vmread MnemonicVMRESUME // vmresume MnemonicVMRUN // vmrun MnemonicVMSAVE // vmsave MnemonicVMULPD // vmulpd MnemonicVMULPS // vmulps MnemonicVMULSD // vmulsd MnemonicVMULSS // vmulss MnemonicVMWRITE // vmwrite MnemonicVMXOFF // vmxoff MnemonicVMXON // vmxon MnemonicVORPD // vorpd MnemonicVORPS // vorps MnemonicVP2INTERSECTD // vp2intersectd MnemonicVP2INTERSECTQ // vp2intersectq MnemonicVP4DPWSSD // vp4dpwssd MnemonicVP4DPWSSDS // vp4dpwssds MnemonicVPABSB // vpabsb MnemonicVPABSD // vpabsd MnemonicVPABSQ // vpabsq MnemonicVPABSW // vpabsw MnemonicVPACKSSDW // vpackssdw MnemonicVPACKSSWB // vpacksswb MnemonicVPACKSTOREHD // vpackstorehd MnemonicVPACKSTOREHPD // vpackstorehpd MnemonicVPACKSTOREHPS // vpackstorehps MnemonicVPACKSTOREHQ // vpackstorehq MnemonicVPACKSTORELD // vpackstoreld MnemonicVPACKSTORELPD // vpackstorelpd MnemonicVPACKSTORELPS // vpackstorelps MnemonicVPACKSTORELQ // vpackstorelq MnemonicVPACKUSDW // vpackusdw MnemonicVPACKUSWB // vpackuswb MnemonicVPADCD // vpadcd MnemonicVPADDB // vpaddb MnemonicVPADDD // vpaddd MnemonicVPADDQ // vpaddq MnemonicVPADDSB // vpaddsb MnemonicVPADDSETCD // vpaddsetcd MnemonicVPADDSETSD // vpaddsetsd MnemonicVPADDSW // vpaddsw MnemonicVPADDUSB // vpaddusb MnemonicVPADDUSW // vpaddusw MnemonicVPADDW // vpaddw MnemonicVPALIGNR // vpalignr MnemonicVPAND // vpand MnemonicVPANDD // vpandd MnemonicVPANDN // vpandn MnemonicVPANDND // vpandnd MnemonicVPANDNQ // vpandnq MnemonicVPANDQ // vpandq MnemonicVPAVGB // vpavgb MnemonicVPAVGW // vpavgw MnemonicVPBLENDD // vpblendd MnemonicVPBLENDMB // vpblendmb MnemonicVPBLENDMD // vpblendmd MnemonicVPBLENDMQ // vpblendmq MnemonicVPBLENDMW // vpblendmw MnemonicVPBLENDVB // vpblendvb MnemonicVPBLENDW // vpblendw MnemonicVPBROADCASTB // vpbroadcastb MnemonicVPBROADCASTD // vpbroadcastd MnemonicVPBROADCASTMB2Q // vpbroadcastmb2q MnemonicVPBROADCASTMW2D // vpbroadcastmw2d MnemonicVPBROADCASTQ // vpbroadcastq MnemonicVPBROADCASTW // vpbroadcastw MnemonicVPCLMULQDQ // vpclmulqdq MnemonicVPCMOV // vpcmov MnemonicVPCMPB // vpcmpb MnemonicVPCMPD // vpcmpd MnemonicVPCMPEQB // vpcmpeqb MnemonicVPCMPEQD // vpcmpeqd MnemonicVPCMPEQQ // vpcmpeqq MnemonicVPCMPEQW // vpcmpeqw MnemonicVPCMPESTRI // vpcmpestri MnemonicVPCMPESTRM // vpcmpestrm MnemonicVPCMPGTB // vpcmpgtb MnemonicVPCMPGTD // vpcmpgtd MnemonicVPCMPGTQ // vpcmpgtq MnemonicVPCMPGTW // vpcmpgtw MnemonicVPCMPISTRI // vpcmpistri MnemonicVPCMPISTRM // vpcmpistrm MnemonicVPCMPLTD // vpcmpltd MnemonicVPCMPQ // vpcmpq MnemonicVPCMPUB // vpcmpub MnemonicVPCMPUD // vpcmpud MnemonicVPCMPUQ // vpcmpuq MnemonicVPCMPUW // vpcmpuw MnemonicVPCMPW // vpcmpw MnemonicVPCOMB // vpcomb MnemonicVPCOMD // vpcomd MnemonicVPCOMPRESSB // vpcompressb MnemonicVPCOMPRESSD // vpcompressd MnemonicVPCOMPRESSQ // vpcompressq MnemonicVPCOMPRESSW // vpcompressw MnemonicVPCOMQ // vpcomq MnemonicVPCOMUB // vpcomub MnemonicVPCOMUD // vpcomud MnemonicVPCOMUQ // vpcomuq MnemonicVPCOMUW // vpcomuw MnemonicVPCOMW // vpcomw MnemonicVPCONFLICTD // vpconflictd MnemonicVPCONFLICTQ // vpconflictq MnemonicVPDPBUSD // vpdpbusd MnemonicVPDPBUSDS // vpdpbusds MnemonicVPDPWSSD // vpdpwssd MnemonicVPDPWSSDS // vpdpwssds MnemonicVPERM2F128 // vperm2f128 MnemonicVPERM2I128 // vperm2i128 MnemonicVPERMB // vpermb MnemonicVPERMD // vpermd MnemonicVPERMF32X4 // vpermf32x4 MnemonicVPERMI2B // vpermi2b MnemonicVPERMI2D // vpermi2d MnemonicVPERMI2PD // vpermi2pd MnemonicVPERMI2PS // vpermi2ps MnemonicVPERMI2Q // vpermi2q MnemonicVPERMI2W // vpermi2w MnemonicVPERMIL2PD // vpermil2pd MnemonicVPERMIL2PS // vpermil2ps MnemonicVPERMILPD // vpermilpd MnemonicVPERMILPS // vpermilps MnemonicVPERMPD // vpermpd MnemonicVPERMPS // vpermps MnemonicVPERMQ // vpermq MnemonicVPERMT2B // vpermt2b MnemonicVPERMT2D // vpermt2d MnemonicVPERMT2PD // vpermt2pd MnemonicVPERMT2PS // vpermt2ps MnemonicVPERMT2Q // vpermt2q MnemonicVPERMT2W // vpermt2w MnemonicVPERMW // vpermw MnemonicVPEXPANDB // vpexpandb MnemonicVPEXPANDD // vpexpandd MnemonicVPEXPANDQ // vpexpandq MnemonicVPEXPANDW // vpexpandw MnemonicVPEXTRB // vpextrb MnemonicVPEXTRD // vpextrd MnemonicVPEXTRQ // vpextrq MnemonicVPEXTRW // vpextrw MnemonicVPGATHERDD // vpgatherdd MnemonicVPGATHERDQ // vpgatherdq MnemonicVPGATHERQD // vpgatherqd MnemonicVPGATHERQQ // vpgatherqq MnemonicVPHADDBD // vphaddbd MnemonicVPHADDBQ // vphaddbq MnemonicVPHADDBW // vphaddbw MnemonicVPHADDD // vphaddd MnemonicVPHADDDQ // vphadddq MnemonicVPHADDSW // vphaddsw MnemonicVPHADDUBD // vphaddubd MnemonicVPHADDUBQ // vphaddubq MnemonicVPHADDUBW // vphaddubw MnemonicVPHADDUDQ // vphaddudq MnemonicVPHADDUWD // vphadduwd MnemonicVPHADDUWQ // vphadduwq MnemonicVPHADDW // vphaddw MnemonicVPHADDWD // vphaddwd MnemonicVPHADDWQ // vphaddwq MnemonicVPHMINPOSUW // vphminposuw MnemonicVPHSUBBW // vphsubbw MnemonicVPHSUBD // vphsubd MnemonicVPHSUBDQ // vphsubdq MnemonicVPHSUBSW // vphsubsw MnemonicVPHSUBW // vphsubw MnemonicVPHSUBWD // vphsubwd MnemonicVPINSRB // vpinsrb MnemonicVPINSRD // vpinsrd MnemonicVPINSRQ // vpinsrq MnemonicVPINSRW // vpinsrw MnemonicVPLZCNTD // vplzcntd MnemonicVPLZCNTQ // vplzcntq MnemonicVPMACSDD // vpmacsdd MnemonicVPMACSDQH // vpmacsdqh MnemonicVPMACSDQL // vpmacsdql MnemonicVPMACSSDD // vpmacssdd MnemonicVPMACSSDQH // vpmacssdqh MnemonicVPMACSSDQL // vpmacssdql MnemonicVPMACSSWD // vpmacsswd MnemonicVPMACSSWW // vpmacssww MnemonicVPMACSWD // vpmacswd MnemonicVPMACSWW // vpmacsww MnemonicVPMADCSSWD // vpmadcsswd MnemonicVPMADCSWD // vpmadcswd MnemonicVPMADD231D // vpmadd231d MnemonicVPMADD233D // vpmadd233d MnemonicVPMADD52HUQ // vpmadd52huq MnemonicVPMADD52LUQ // vpmadd52luq MnemonicVPMADDUBSW // vpmaddubsw MnemonicVPMADDWD // vpmaddwd MnemonicVPMASKMOVD // vpmaskmovd MnemonicVPMASKMOVQ // vpmaskmovq MnemonicVPMAXSB // vpmaxsb MnemonicVPMAXSD // vpmaxsd MnemonicVPMAXSQ // vpmaxsq MnemonicVPMAXSW // vpmaxsw MnemonicVPMAXUB // vpmaxub MnemonicVPMAXUD // vpmaxud MnemonicVPMAXUQ // vpmaxuq MnemonicVPMAXUW // vpmaxuw MnemonicVPMINSB // vpminsb MnemonicVPMINSD // vpminsd MnemonicVPMINSQ // vpminsq MnemonicVPMINSW // vpminsw MnemonicVPMINUB // vpminub MnemonicVPMINUD // vpminud MnemonicVPMINUQ // vpminuq MnemonicVPMINUW // vpminuw MnemonicVPMOVB2M // vpmovb2m MnemonicVPMOVD2M // vpmovd2m MnemonicVPMOVDB // vpmovdb MnemonicVPMOVDW // vpmovdw MnemonicVPMOVM2B // vpmovm2b MnemonicVPMOVM2D // vpmovm2d MnemonicVPMOVM2Q // vpmovm2q MnemonicVPMOVM2W // vpmovm2w MnemonicVPMOVMSKB // vpmovmskb MnemonicVPMOVQ2M // vpmovq2m MnemonicVPMOVQB // vpmovqb MnemonicVPMOVQD // vpmovqd MnemonicVPMOVQW // vpmovqw MnemonicVPMOVSDB // vpmovsdb MnemonicVPMOVSDW // vpmovsdw MnemonicVPMOVSQB // vpmovsqb MnemonicVPMOVSQD // vpmovsqd MnemonicVPMOVSQW // vpmovsqw MnemonicVPMOVSWB // vpmovswb MnemonicVPMOVSXBD // vpmovsxbd MnemonicVPMOVSXBQ // vpmovsxbq MnemonicVPMOVSXBW // vpmovsxbw MnemonicVPMOVSXDQ // vpmovsxdq MnemonicVPMOVSXWD // vpmovsxwd MnemonicVPMOVSXWQ // vpmovsxwq MnemonicVPMOVUSDB // vpmovusdb MnemonicVPMOVUSDW // vpmovusdw MnemonicVPMOVUSQB // vpmovusqb MnemonicVPMOVUSQD // vpmovusqd MnemonicVPMOVUSQW // vpmovusqw MnemonicVPMOVUSWB // vpmovuswb MnemonicVPMOVW2M // vpmovw2m MnemonicVPMOVWB // vpmovwb MnemonicVPMOVZXBD // vpmovzxbd MnemonicVPMOVZXBQ // vpmovzxbq MnemonicVPMOVZXBW // vpmovzxbw MnemonicVPMOVZXDQ // vpmovzxdq MnemonicVPMOVZXWD // vpmovzxwd MnemonicVPMOVZXWQ // vpmovzxwq MnemonicVPMULDQ // vpmuldq MnemonicVPMULHD // vpmulhd MnemonicVPMULHRSW // vpmulhrsw MnemonicVPMULHUD // vpmulhud MnemonicVPMULHUW // vpmulhuw MnemonicVPMULHW // vpmulhw MnemonicVPMULLD // vpmulld MnemonicVPMULLQ // vpmullq MnemonicVPMULLW // vpmullw MnemonicVPMULTISHIFTQB // vpmultishiftqb MnemonicVPMULUDQ // vpmuludq MnemonicVPOPCNTB // vpopcntb MnemonicVPOPCNTD // vpopcntd MnemonicVPOPCNTQ // vpopcntq MnemonicVPOPCNTW // vpopcntw MnemonicVPOR // vpor MnemonicVPORD // vpord MnemonicVPORQ // vporq MnemonicVPPERM // vpperm MnemonicVPREFETCH0 // vprefetch0 MnemonicVPREFETCH1 // vprefetch1 MnemonicVPREFETCH2 // vprefetch2 MnemonicVPREFETCHE0 // vprefetche0 MnemonicVPREFETCHE1 // vprefetche1 MnemonicVPREFETCHE2 // vprefetche2 MnemonicVPREFETCHENTA // vprefetchenta MnemonicVPREFETCHNTA // vprefetchnta MnemonicVPROLD // vprold MnemonicVPROLQ // vprolq MnemonicVPROLVD // vprolvd MnemonicVPROLVQ // vprolvq MnemonicVPRORD // vprord MnemonicVPRORQ // vprorq MnemonicVPRORVD // vprorvd MnemonicVPRORVQ // vprorvq MnemonicVPROTB // vprotb MnemonicVPROTD // vprotd MnemonicVPROTQ // vprotq MnemonicVPROTW // vprotw MnemonicVPSADBW // vpsadbw MnemonicVPSBBD // vpsbbd MnemonicVPSBBRD // vpsbbrd MnemonicVPSCATTERDD // vpscatterdd MnemonicVPSCATTERDQ // vpscatterdq MnemonicVPSCATTERQD // vpscatterqd MnemonicVPSCATTERQQ // vpscatterqq MnemonicVPSHAB // vpshab MnemonicVPSHAD // vpshad MnemonicVPSHAQ // vpshaq MnemonicVPSHAW // vpshaw MnemonicVPSHLB // vpshlb MnemonicVPSHLD // vpshld MnemonicVPSHLDD // vpshldd MnemonicVPSHLDQ // vpshldq MnemonicVPSHLDVD // vpshldvd MnemonicVPSHLDVQ // vpshldvq MnemonicVPSHLDVW // vpshldvw MnemonicVPSHLDW // vpshldw MnemonicVPSHLQ // vpshlq MnemonicVPSHLW // vpshlw MnemonicVPSHRDD // vpshrdd MnemonicVPSHRDQ // vpshrdq MnemonicVPSHRDVD // vpshrdvd MnemonicVPSHRDVQ // vpshrdvq MnemonicVPSHRDVW // vpshrdvw MnemonicVPSHRDW // vpshrdw MnemonicVPSHUFB // vpshufb MnemonicVPSHUFBITQMB // vpshufbitqmb MnemonicVPSHUFD // vpshufd MnemonicVPSHUFHW // vpshufhw MnemonicVPSHUFLW // vpshuflw MnemonicVPSIGNB // vpsignb MnemonicVPSIGND // vpsignd MnemonicVPSIGNW // vpsignw MnemonicVPSLLD // vpslld MnemonicVPSLLDQ // vpslldq MnemonicVPSLLQ // vpsllq MnemonicVPSLLVD // vpsllvd MnemonicVPSLLVQ // vpsllvq MnemonicVPSLLVW // vpsllvw MnemonicVPSLLW // vpsllw MnemonicVPSRAD // vpsrad MnemonicVPSRAQ // vpsraq MnemonicVPSRAVD // vpsravd MnemonicVPSRAVQ // vpsravq MnemonicVPSRAVW // vpsravw MnemonicVPSRAW // vpsraw MnemonicVPSRLD // vpsrld MnemonicVPSRLDQ // vpsrldq MnemonicVPSRLQ // vpsrlq MnemonicVPSRLVD // vpsrlvd MnemonicVPSRLVQ // vpsrlvq MnemonicVPSRLVW // vpsrlvw MnemonicVPSRLW // vpsrlw MnemonicVPSUBB // vpsubb MnemonicVPSUBD // vpsubd MnemonicVPSUBQ // vpsubq MnemonicVPSUBRD // vpsubrd MnemonicVPSUBRSETBD // vpsubrsetbd MnemonicVPSUBSB // vpsubsb MnemonicVPSUBSETBD // vpsubsetbd MnemonicVPSUBSW // vpsubsw MnemonicVPSUBUSB // vpsubusb MnemonicVPSUBUSW // vpsubusw MnemonicVPSUBW // vpsubw MnemonicVPTERNLOGD // vpternlogd MnemonicVPTERNLOGQ // vpternlogq MnemonicVPTEST // vptest MnemonicVPTESTMB // vptestmb MnemonicVPTESTMD // vptestmd MnemonicVPTESTMQ // vptestmq MnemonicVPTESTMW // vptestmw MnemonicVPTESTNMB // vptestnmb MnemonicVPTESTNMD // vptestnmd MnemonicVPTESTNMQ // vptestnmq MnemonicVPTESTNMW // vptestnmw MnemonicVPUNPCKHBW // vpunpckhbw MnemonicVPUNPCKHDQ // vpunpckhdq MnemonicVPUNPCKHQDQ // vpunpckhqdq MnemonicVPUNPCKHWD // vpunpckhwd MnemonicVPUNPCKLBW // vpunpcklbw MnemonicVPUNPCKLDQ // vpunpckldq MnemonicVPUNPCKLQDQ // vpunpcklqdq MnemonicVPUNPCKLWD // vpunpcklwd MnemonicVPXOR // vpxor MnemonicVPXORD // vpxord MnemonicVPXORQ // vpxorq MnemonicVRANGEPD // vrangepd MnemonicVRANGEPS // vrangeps MnemonicVRANGESD // vrangesd MnemonicVRANGESS // vrangess MnemonicVRCP14PD // vrcp14pd MnemonicVRCP14PS // vrcp14ps MnemonicVRCP14SD // vrcp14sd MnemonicVRCP14SS // vrcp14ss MnemonicVRCP23PS // vrcp23ps MnemonicVRCP28PD // vrcp28pd MnemonicVRCP28PS // vrcp28ps MnemonicVRCP28SD // vrcp28sd MnemonicVRCP28SS // vrcp28ss MnemonicVRCPPS // vrcpps MnemonicVRCPSS // vrcpss MnemonicVREDUCEPD // vreducepd MnemonicVREDUCEPS // vreduceps MnemonicVREDUCESD // vreducesd MnemonicVREDUCESS // vreducess MnemonicVRNDFXPNTPD // vrndfxpntpd MnemonicVRNDFXPNTPS // vrndfxpntps MnemonicVRNDSCALEPD // vrndscalepd MnemonicVRNDSCALEPS // vrndscaleps MnemonicVRNDSCALESD // vrndscalesd MnemonicVRNDSCALESS // vrndscaless MnemonicVROUNDPD // vroundpd MnemonicVROUNDPS // vroundps MnemonicVROUNDSD // vroundsd MnemonicVROUNDSS // vroundss MnemonicVRSQRT14PD // vrsqrt14pd MnemonicVRSQRT14PS // vrsqrt14ps MnemonicVRSQRT14SD // vrsqrt14sd MnemonicVRSQRT14SS // vrsqrt14ss MnemonicVRSQRT23PS // vrsqrt23ps MnemonicVRSQRT28PD // vrsqrt28pd MnemonicVRSQRT28PS // vrsqrt28ps MnemonicVRSQRT28SD // vrsqrt28sd MnemonicVRSQRT28SS // vrsqrt28ss MnemonicVRSQRTPS // vrsqrtps MnemonicVRSQRTSS // vrsqrtss MnemonicVSCALEFPD // vscalefpd MnemonicVSCALEFPS // vscalefps MnemonicVSCALEFSD // vscalefsd MnemonicVSCALEFSS // vscalefss MnemonicVSCALEPS // vscaleps MnemonicVSCATTERDPD // vscatterdpd MnemonicVSCATTERDPS // vscatterdps MnemonicVSCATTERPF0DPD // vscatterpf0dpd MnemonicVSCATTERPF0DPS // vscatterpf0dps MnemonicVSCATTERPF0HINTDPD // vscatterpf0hintdpd MnemonicVSCATTERPF0HINTDPS // vscatterpf0hintdps MnemonicVSCATTERPF0QPD // vscatterpf0qpd MnemonicVSCATTERPF0QPS // vscatterpf0qps MnemonicVSCATTERPF1DPD // vscatterpf1dpd MnemonicVSCATTERPF1DPS // vscatterpf1dps MnemonicVSCATTERPF1QPD // vscatterpf1qpd MnemonicVSCATTERPF1QPS // vscatterpf1qps MnemonicVSCATTERQPD // vscatterqpd MnemonicVSCATTERQPS // vscatterqps MnemonicVSHUFF32X4 // vshuff32x4 MnemonicVSHUFF64X2 // vshuff64x2 MnemonicVSHUFI32X4 // vshufi32x4 MnemonicVSHUFI64X2 // vshufi64x2 MnemonicVSHUFPD // vshufpd MnemonicVSHUFPS // vshufps MnemonicVSQRTPD // vsqrtpd MnemonicVSQRTPS // vsqrtps MnemonicVSQRTSD // vsqrtsd MnemonicVSQRTSS // vsqrtss MnemonicVSTMXCSR // vstmxcsr MnemonicVSUBPD // vsubpd MnemonicVSUBPS // vsubps MnemonicVSUBRPD // vsubrpd MnemonicVSUBRPS // vsubrps MnemonicVSUBSD // vsubsd MnemonicVSUBSS // vsubss MnemonicVTESTPD // vtestpd MnemonicVTESTPS // vtestps MnemonicVUCOMISD // vucomisd MnemonicVUCOMISS // vucomiss MnemonicVUNPCKHPD // vunpckhpd MnemonicVUNPCKHPS // vunpckhps MnemonicVUNPCKLPD // vunpcklpd MnemonicVUNPCKLPS // vunpcklps MnemonicVXORPD // vxorpd MnemonicVXORPS // vxorps MnemonicVZEROALL // vzeroall MnemonicVZEROUPPER // vzeroupper MnemonicWBINVD // wbinvd MnemonicWRFSBASE // wrfsbase MnemonicWRGSBASE // wrgsbase MnemonicWRMSR // wrmsr MnemonicWRPKRU // wrpkru MnemonicWRSSD // wrssd MnemonicWRSSQ // wrssq MnemonicWRUSSD // wrussd MnemonicWRUSSQ // wrussq MnemonicXABORT // xabort MnemonicXADD // xadd MnemonicXBEGIN // xbegin MnemonicXCHG // xchg MnemonicXCRYPTCBC // xcrypt_cbc MnemonicXCRYPTCFB // xcrypt_cfb MnemonicXCRYPTCTR // xcrypt_ctr MnemonicXCRYPTECB // xcrypt_ecb MnemonicXCRYPTOFB // xcrypt_ofb MnemonicXEND // xend MnemonicXGETBV // xgetbv MnemonicXLAT // xlat MnemonicXOR // xor MnemonicXORPD // xorpd MnemonicXORPS // xorps MnemonicXRESLDTRK // xresldtrk MnemonicXRSTOR // xrstor MnemonicXRSTOR64 // xrstor64 MnemonicXRSTORS // xrstors MnemonicXRSTORS64 // xrstors64 MnemonicXSAVE // xsave MnemonicXSAVE64 // xsave64 MnemonicXSAVEC // xsavec MnemonicXSAVEC64 // xsavec64 MnemonicXSAVEOPT // xsaveopt MnemonicXSAVEOPT64 // xsaveopt64 MnemonicXSAVES // xsaves MnemonicXSAVES64 // xsaves64 MnemonicXSETBV // xsetbv MnemonicXSHA1 // xsha1 MnemonicXSHA256 // xsha256 MnemonicXSTORE // xstore MnemonicXSUSLDTRK // xsusldtrk MnemonicXTEST // xtest )
Mnemonic values
type OperandAction ¶
type OperandAction int
OperandAction is a bitfield that represents an operand action.
type OperandEncoding ¶
type OperandEncoding int
OperandEncoding is an enum of the operand encoding.
const ( OperandEncodingNone OperandEncoding = iota OperandEncodingModRmReg OperandEncodingModRmRm OperandEncodingOpcode OperandEncodingNDSNDD OperandEncodingIS4 OperandEncodingMask OperandEncodingDisp8 OperandEncodingDisp16 OperandEncodingDisp32 OperandEncodingDisp64 OperandEncodingDisp16_32_64 OperandEncodingDisp32_32_64 OperandEncodingDisp16_32_32 OperandEncodingUImm8 OperandEncodingUImm16 OperandEncodingUImm32 OperandEncodingUImm64 OperandEncodingUImm16_32_64 OperandEncodingUImm32_32_64 OperandEncodingUImm16_32_32 OperandEncodingSImm8 OperandEncodingSImm16 OperandEncodingSImm32 OperandEncodingSImm64 OperandEncodingSImm16_32_64 OperandEncodingSImm32_32_64 OperandEncodingSImm16_32_32 OperandEncodingJImm8 OperandEncodingJImm16 OperandEncodingJImm32 OperandEncodingJImm64 OperandEncodingJImm16_32_64 OperandEncodingJImm32_32_64 OperandEncodingJImm16_32_32 )
OperandEncoding enum
type OperandType ¶
type OperandType int
OperandType is an enum of operand types.
const ( // The operand is not used. OperandTypeInvalid OperandType = iota // The operand is a register operand. OperandTypeRegister // The operand is a memory operand. OperandTypeMemory // The operand is a pointer operand with a segment:offset lvalue. OperandTypePointer // The operand is an immediate operand. OperandTypeImmediate )
OperandType enum values.
type OperandVisibility ¶
type OperandVisibility int
OperandVisibility is an enum of operand visibility types.
const ( OperandVisibilityInvalid OperandVisibility = iota // The operand is explicitly encoded in the instruction. OperandVisibilityExplicit // The operand is part of the opcode, but listed as an operand. OperandVisibilityImplicit // The operand is part of the opcode, and not typically listed as an operand. OperandVisibilityHidden )
OperandVisibility enum values.
type PrefixType ¶
type PrefixType int
PrefixType is an enum of prefix types.
const ( // The prefix is ignored by the instruction. // This applies to all prefixes that are not accepted by the instruction // in general or the ones that are overwritten by a prefix of the same // group closer to the instruction opcode. PrefixTypeIgnored PrefixType = iota // The prefix is effectively used by the instruction. PrefixTypeEffective // The prefix is used as a mandatory prefix, interpreted as an opcode // extension and has no further effect on the instruction. PrefixTypeMandatory )
PrefixType enum values.
type Register ¶
type Register int
Register is an enum of processor registers.
const ( RegisterNone Register = iota // None // General purpose registers 8-bit RegisterAL // AL RegisterCL // CL RegisterDL // DL RegisterBL // BL RegisterAH // AH RegisterCH // CH RegisterDH // DH RegisterBH // BH RegisterSPL // SPL RegisterBPL // BPL RegisterSIL // SIL RegisterDIL // DIL RegisterR8B // R8B RegisterR9B // R9B RegisterR10B // R10B RegisterR11B // R11B RegisterR12B // R12B RegisterR13B // R13B RegisterR14B // R14B RegisterR15B // R15B // General purpose registers 16-bit RegisterAX // AX RegisterCX // CX RegisterDX // DX RegisterBX // BX RegisterSP // SP RegisterBP // BP RegisterSI // SI RegisterDI // DI RegisterR8W // R8W RegisterR9W // R9W RegisterR10W // R10W RegisterR11W // R11W RegisterR12W // R12W RegisterR13W // R13W RegisterR14W // R14W RegisterR15W // R15W // General purpose registers 32-bit RegisterEAX // EAX RegisterECX // ECX RegisterEDX // EDX RegisterEBX // EBX RegisterESP // ESP RegisterEBP // EBP RegisterESI // ESI RegisterEDI // EDI RegisterR8D // R8D RegisterR9D // R9D RegisterR10D // R10D RegisterR11D // R11D RegisterR12D // R12D RegisterR13D // R13D RegisterR14D // R14D RegisterR15D // R15D // General purpose registers 64-bit RegisterRAX // RAX RegisterRCX // RCX RegisterRDX // RDX RegisterRBX // RBX RegisterRSP // RSP RegisterRBP // RBP RegisterRSI // RSI RegisterRDI // RDI RegisterR8 // R8 RegisterR9 // R9 RegisterR10 // R10 RegisterR11 // R11 RegisterR12 // R12 RegisterR13 // R13 RegisterR14 // R14 RegisterR15 // R15 // Floating point legacy registers RegisterST0 // ST0 RegisterST1 // ST1 RegisterST2 // ST2 RegisterST3 // ST3 RegisterST4 // ST4 RegisterST5 // ST5 RegisterST6 // ST6 RegisterST7 // ST7 RegisterX87Control // X87Control RegisterX87Status // X87Status RegisterX87Tag // X87Tag // Floating point multimedia registers RegisterMM0 // MM0 RegisterMM1 // MM1 RegisterMM2 // MM2 RegisterMM3 // MM3 RegisterMM4 // MM4 RegisterMM5 // MM5 RegisterMM6 // MM6 RegisterMM7 // MM7 // Floating point vector registers 128-bit RegisterXMM0 // XMM0 RegisterXMM1 // XMM1 RegisterXMM2 // XMM2 RegisterXMM3 // XMM3 RegisterXMM4 // XMM4 RegisterXMM5 // XMM5 RegisterXMM6 // XMM6 RegisterXMM7 // XMM7 RegisterXMM8 // XMM8 RegisterXMM9 // XMM9 RegisterXMM10 // XMM10 RegisterXMM11 // XMM11 RegisterXMM12 // XMM12 RegisterXMM13 // XMM13 RegisterXMM14 // XMM14 RegisterXMM15 // XMM15 RegisterXMM16 // XMM16 RegisterXMM17 // XMM17 RegisterXMM18 // XMM18 RegisterXMM19 // XMM19 RegisterXMM20 // XMM20 RegisterXMM21 // XMM21 RegisterXMM22 // XMM22 RegisterXMM23 // XMM23 RegisterXMM24 // XMM24 RegisterXMM25 // XMM25 RegisterXMM26 // XMM26 RegisterXMM27 // XMM27 RegisterXMM28 // XMM28 RegisterXMM29 // XMM29 RegisterXMM30 // XMM30 RegisterXMM31 // XMM31 // Floating point vector registers 256-bit RegisterYMM0 // YMM0 RegisterYMM1 // YMM1 RegisterYMM2 // YMM2 RegisterYMM3 // YMM3 RegisterYMM4 // YMM4 RegisterYMM5 // YMM5 RegisterYMM6 // YMM6 RegisterYMM7 // YMM7 RegisterYMM8 // YMM8 RegisterYMM9 // YMM9 RegisterYMM10 // YMM10 RegisterYMM11 // YMM11 RegisterYMM12 // YMM12 RegisterYMM13 // YMM13 RegisterYMM14 // YMM14 RegisterYMM15 // YMM15 RegisterYMM16 // YMM16 RegisterYMM17 // YMM17 RegisterYMM18 // YMM18 RegisterYMM19 // YMM19 RegisterYMM20 // YMM20 RegisterYMM21 // YMM21 RegisterYMM22 // YMM22 RegisterYMM23 // YMM23 RegisterYMM24 // YMM24 RegisterYMM25 // YMM25 RegisterYMM26 // YMM26 RegisterYMM27 // YMM27 RegisterYMM28 // YMM28 RegisterYMM29 // YMM29 RegisterYMM30 // YMM30 RegisterYMM31 // YMM31 // Floating point vector registers 512-bit RegisterZMM0 // ZMM0 RegisterZMM1 // ZMM1 RegisterZMM2 // ZMM2 RegisterZMM3 // ZMM3 RegisterZMM4 // ZMM4 RegisterZMM5 // ZMM5 RegisterZMM6 // ZMM6 RegisterZMM7 // ZMM7 RegisterZMM8 // ZMM8 RegisterZMM9 // ZMM9 RegisterZMM10 // ZMM10 RegisterZMM11 // ZMM11 RegisterZMM12 // ZMM12 RegisterZMM13 // ZMM13 RegisterZMM14 // ZMM14 RegisterZMM15 // ZMM15 RegisterZMM16 // ZMM16 RegisterZMM17 // ZMM17 RegisterZMM18 // ZMM18 RegisterZMM19 // ZMM19 RegisterZMM20 // ZMM20 RegisterZMM21 // ZMM21 RegisterZMM22 // ZMM22 RegisterZMM23 // ZMM23 RegisterZMM24 // ZMM24 RegisterZMM25 // ZMM25 RegisterZMM26 // ZMM26 RegisterZMM27 // ZMM27 RegisterZMM28 // ZMM28 RegisterZMM29 // ZMM29 RegisterZMM30 // ZMM30 RegisterZMM31 // ZMM31 // Matrix registers RegisterTMM0 // TMM0 RegisterTMM1 // TMM1 RegisterTMM2 // TMM2 RegisterTMM3 // TMM3 RegisterTMM4 // TMM4 RegisterTMM5 // TMM5 RegisterTMM6 // TMM6 RegisterTMM7 // TMM7 // Flags registers RegisterFlags // Flags RegisterEFlags // EFlags RegisterRFlags // RFlags // Instruction-pointer registers RegisterIP // IP RegisterEIP // EIP RegisterRIP // RIP // Segment registers RegisterES // ES RegisterCS // CS RegisterSS // SS RegisterDS // DS RegisterFS // FS RegisterGS // GS // Table registers RegisterGDTR // GDTR RegisterLDTR // LDTR RegisterIDTR // IDTR RegisterTR // TR // Test registers RegisterTR0 // TR0 RegisterTR1 // TR1 RegisterTR2 // TR2 RegisterTR3 // TR3 RegisterTR4 // TR4 RegisterTR5 // TR5 RegisterTR6 // TR6 RegisterTR7 // TR7 // Control registers RegisterCR0 // CR0 RegisterCR1 // CR1 RegisterCR2 // CR2 RegisterCR3 // CR3 RegisterCR4 // CR4 RegisterCR5 // CR5 RegisterCR6 // CR6 RegisterCR7 // CR7 RegisterCR8 // CR8 RegisterCR9 // CR9 RegisterCR10 // CR10 RegisterCR11 // CR11 RegisterCR12 // CR12 RegisterCR13 // CR13 RegisterCR14 // CR14 RegisterCR15 // CR15 // Debug registers RegisterDR0 // DR0 RegisterDR1 // DR1 RegisterDR2 // DR2 RegisterDR3 // DR3 RegisterDR4 // DR4 RegisterDR5 // DR5 RegisterDR6 // DR6 RegisterDR7 // DR7 RegisterDR8 // DR8 RegisterDR9 // DR9 RegisterDR10 // DR10 RegisterDR11 // DR11 RegisterDR12 // DR12 RegisterDR13 // DR13 RegisterDR14 // DR14 RegisterDR15 // DR15 // Mask registers RegisterK0 // K0 RegisterK1 // K1 RegisterK2 // K2 RegisterK3 // K3 RegisterK4 // K4 RegisterK5 // K5 RegisterK6 // K6 RegisterK7 // K7 // Bound registers RegisterBND0 // BND0 RegisterBND1 // BND1 RegisterBND2 // BND2 RegisterBND3 // BND3 RegisterBNDCfg // BNDCfg RegisterBNDStatus // BNDStatus // Uncategorized RegisterMXCSR // MXCSR RegisterPKRU // PKRU RegisterXCR0 // XCR0 )
Register enum values.
type RegisterContext ¶
RegisterContext is a mapping from register to its value
type RoundingMode ¶
type RoundingMode int
RoundingMode is an enum of AVX rounding modes.
const ( RoundingModeInvalid RoundingMode = iota // Round to nearest. RoundingModeRN // Round down. RoundingModeRD // Round up. RoundingModeRU // Round towards zero. RoundingModeRZ )
RoundingMode enum values.
type Segment ¶
type Segment struct { // The type of the segment. Type InstructionSegment // The offset of the segment relative to the start of the instruction, in bytes. Offset uint8 // The size of the segment, in bytes. Size uint8 }
Segment provides the logical breakdown of an instruction.
type Signedness ¶
type Signedness int
Signedness is an enum to control formatting of a value's sign.
const ( // SignednessAuto automatically chooses the most suitable mode based on // the operand's DecodedOperand.Imm.IsSigned attribute. SignednessAuto Signedness = iota // SignednessSigned forces signed values. SignednessSigned // SignednessUnsigned forces unsigned values. SignednessUnsigned )
Signedness enun values.
type SwizzleMode ¶
type SwizzleMode int
SwizzleMode is an enum of KNC swizzle modes.
const ( SwizzleModeInvalid SwizzleMode = iota SwizzleModeDCBA SwizzleModeCDAB SwizzleModeBADC SwizzleModeDACB SwizzleModeAAAA SwizzleModeBBBB SwizzleModeCCCC SwizzleModeDDDD )
SwizzleMode enum values.
type TokenType ¶
type TokenType uint8
TokenType is an enum of token types.
const ( TokenTypeInvalid TokenType = 0x00 // A whitespace character. TokenTypeWhitespace TokenType = 0x01 // A delimiter character (like ',', ':', '+', '-', '*'). TokenTypeDelimiter TokenType = 0x02 // An opening parenthesis character (like '(', '[', '{'). TokenTypeParenthesisOpen TokenType = 0x03 // A closing parenthesis character (like ')', ']', '}'). TokenTypeParenthesisClose TokenType = 0x04 // A prefix literal (like "LOCK", "REP"). TokenTypePrefix TokenType = 0x05 // A mnemonic literal (like "MOV", "VCMPPSD", "LCALL"). TokenTypeMnemonic TokenType = 0x06 // A register literal (like "RAX", "DS", "%ECX"). TokenTypeRegister TokenType = 0x07 // An absolute address literal (like 0x00400000). TokenTypeAddressAbsolute TokenType = 0x08 // A relative address literal (like -0x100). TokenTypeAddressRelative TokenType = 0x09 // A displacement literal (like 0xFFFFFFFF, -0x100, +0x1234). TokenTypeDisplacement TokenType = 0x0A // An immediate literal (like 0xC0, -0x1234, $0x0000). TokenTypeImmediate TokenType = 0x0B // A typecast literal (like DWORD PTR). TokenTypeTypecast TokenType = 0x0C // A decorator literal (like "Z", "1TO4"). TokenTypeDecorator TokenType = 0x0D // A symbol literal. TokenTypeSymbol TokenType = 0x0E // The base for user-defined token types. TokenTypeUser TokenType = 0x80 )
TokenType enum values.
Source Files ¶
- 00doc.go
- addresswidth.go
- callbackmap.go
- cpuflagaction.go
- decoder.go
- element.go
- exceptionclass_string.go
- features.go
- formatter+callbacks.go
- formatter.go
- instruction.go
- instructioncategory_string.go
- isaext.go
- isaext_string.go
- isaset.go
- isaset_string.go
- machinemode.go
- mnemonic.go
- mnemonic_string.go
- opcodemap.go
- operand.go
- register.go
- register_string.go