zydis

package module
v0.0.0-...-63006ee Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 9, 2021 License: MIT Imports: 7 Imported by: 0

README

Zydis Bindings for Go

Zydis is a fast and lightweight x86/x86-64 disassembler library. This repo provides bindings to Go via cgo and is considered a "complete" wrapper of the Zydis API, ready for production use.

It was created because the pure-Go disassembler is signficantly lacking in AMD64 support. Decoding x86 is complex business, and it was more straightforward to make this port instead of digging deep into the pure-Go package.

This repository uses Git LFS to store a precompiled version of the Zydis library (see below), so please make sure you have it installed before getting this package.

Import

import "code.jpap.org/go-zydis"

Sample code

See the file cmd/demo.go.

Upgrading Zydis library

The Zydis library is packaged as a static syso object file so that this package is go gettable. Precompiled macOS (amd64, arm64), Linux (amd64, arm64), and Windows (amd64, 386) binaries are provided.

Use the Makefile in the lib/ folder to upgrade to a newer version, rebuild, or add support for another platform. The default Makefile target clones the Zydis repo and its submodule, performs the build, and creates the syso files for Go linkage under macOS with suitable cross-compilers installed.

License

MIT, see the LICENSE.md file.

Documentation

Index

Constants

View Source 
const (
	InstructionEncodingLegacy = iota
	InstructionEncoding3DNOW
	InstructionEncodingXOP
	InstructionEncodingVEX
	InstructionEncodingEVEX
	InstructionEncodingMVEX
)

InstructionEncoding enum values.

View Source 
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.

View Source 
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 

func IsFeatureEnabled(f Feature) (bool, error)

IsFeatureEnabled returns true when the given feature is included in the zydis library.

func Version 

func Version() (major, minor, patch, build int)

Version returns the zydis library version number.

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 ElementSize 

type ElementSize uint16

ElementSize is the sizde of an element.

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 Feature 

type Feature int

Feature is an enum of zydis library features. 

const (
	FeatureDecoder Feature = iota
	FeatureFormatter
	FeatureAVX512
	FeatureKNC
)

Feature enum values.

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 

type FormatterToken struct {
	TokenType
	Value string
}

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.

func (ISAExt) String 

func (i ISAExt) String() string

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.

func (ISASet) String 

func (i ISASet) String() string

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

func (Mnemonic) String 

func (i Mnemonic) String() string

type OpcodeMap 

type OpcodeMap int

OpcodeMap represents a processor's opcode map. 

const (
	OpcodeMapDefault OpcodeMap = iota
	OpcodeMap0F
	OpcodeMap0F38
	OpcodeMap0F3A
	OpcodeMap0F0F
	OpcodeMapXOP8
	OpcodeMapXOP9
	OpcodeMapXOPA
)

OpcodeMap values

type OperandAction 

type OperandAction int

OperandAction is a bitfield that represents an operand action.

type OperandActions 

type OperandActions uint8

OperandActions is a...?

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 Padding 

type Padding int

Padding is an enum of padding styles. 

const (
	// Disables padding.
	PaddingDisabled Padding = 0
	// Padds the value to the current stack-width for addresses, or to the
	// operand-width for immediate values (hexadecimal only).
	PAddingAuto Padding = -1
)

Padding 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.

func (Register) String 

func (i Register) String() string

type RegisterContext 

type RegisterContext map[Register]uint64

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

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.