Documentation ¶
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 interface{}) 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.
func (*CallbackMap) GetToken ¶
func (cm *CallbackMap) GetToken(token unsafe.Pointer) (value interface{})
GetToken retrieves the value associated with a given token, removes it from the map, and returns it. Panics on an unknown token.
func (*CallbackMap) NewToken ¶
func (cm *CallbackMap) NewToken(value interface{}) (token unsafe.Pointer)
NewToken issues a new token that can be used for a callback.
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 interface{}) 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 ¶
- 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