diff --git a/CMakeLists.txt b/CMakeLists.txt index e98aafc..06c4543 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,4 @@ cmake_minimum_required(VERSION 2.8.12) -cmake_policy(SET CMP0054 NEW) include(GenerateExportHeader) project(Zydis) @@ -84,6 +83,16 @@ generate_export_header( EXPORT_FILE_NAME "ZydisExportConfig.h") include_directories(${PROJECT_BINARY_DIR}) +if (FEATURE_IMPLICITLY_USED_REGISTERS) + target_compile_definitions(Zydis PRIVATE ZYDIS_ENABLE_FEATURE_IMPLICITLY_USED_REGISTERS) +endif () +if (FEATURE_AFFECTED_FLAGS) + target_compile_definitions(Zydis PRIVATE ZYDIS_ENABLE_FEATURE_AFFECTED_FLAGS) +endif () +if (FEATURE_CPUID) + target_compile_definitions(Zydis PRIVATE ZYDIS_ENABLE_FEATURE_CPUID) +endif () + # Examples if (BUILD_EXAMPLES) include_directories("include") diff --git a/assets/InstructionEditor/Forms/formCodeGenerator.pas b/assets/InstructionEditor/Forms/formCodeGenerator.pas index 5e483ae..bcf6ad8 100644 --- a/assets/InstructionEditor/Forms/formCodeGenerator.pas +++ b/assets/InstructionEditor/Forms/formCodeGenerator.pas @@ -64,8 +64,7 @@ begin Generator.OnWorkStart := GeneratorWorkStart; Generator.OnWork := GeneratorWork; Generator.OnWorkEnd := GeneratorWorkEnd; - Generator.GenerateCode( - FEditor, 'D:\Verteron Development\GitHub\zyan-disassembler-engine\', Statistics); + Generator.GenerateCode(FEditor, 'F:\Development\GitHub\zyan-disassembler-engine\', Statistics); // TODO: Display statistics finally Generator.Free; diff --git a/assets/InstructionEditor/Forms/formMain.dfm b/assets/InstructionEditor/Forms/formMain.dfm index 5788dc4..fc1d767 100644 --- a/assets/InstructionEditor/Forms/formMain.dfm +++ b/assets/InstructionEditor/Forms/formMain.dfm @@ -243,8 +243,6 @@ object frmMain: TfrmMain OnGetImageIndex = EditorTreeGetImageIndex OnKeyDown = EditorTreeKeyDown OnMouseUp = EditorTreeMouseUp - ExplicitLeft = 370 - ExplicitTop = 133 Columns = < item Position = 0 diff --git a/assets/InstructionEditor/Forms/formMain.pas b/assets/InstructionEditor/Forms/formMain.pas index 9ca3cec..afbd937 100644 --- a/assets/InstructionEditor/Forms/formMain.pas +++ b/assets/InstructionEditor/Forms/formMain.pas @@ -16,7 +16,9 @@ uses // definitions // http://www.delphipraxis.net/136601-virtual-treeview-multiselect-onchange-event-problem.html -// TODO: Update inspector after inspected object changed +// TODO: [ ] Update inspector after inspected object changed +// [ ] Create seperated class for persistent settings +// [ ] Seperate view from business logic type TfrmMain = class(TdxRibbonForm) @@ -803,7 +805,7 @@ procedure TfrmMain.EditorTreeGetImageIndex(Sender: TBaseVirtualTree; var NodeData: PEditorNodeData; begin - if (Column <> 0) or (Kind = ikOverlay) then + if (Column <> 0) or (not (Kind in [ikNormal, ikSelected])) then begin Exit; end; diff --git a/assets/InstructionEditor/Zydis.CodeGenerator.pas b/assets/InstructionEditor/Zydis.CodeGenerator.pas index 34477ff..5b33b86 100644 --- a/assets/InstructionEditor/Zydis.CodeGenerator.pas +++ b/assets/InstructionEditor/Zydis.CodeGenerator.pas @@ -154,7 +154,7 @@ const SIZEOF_OPERANDDEFINITION = 2; DIRECTORY_INCLUDE_INTERNAL = 'include\Zydis\Internal'; FILENAME_INSTRUCTIONFILTERS = 'InstructionFilters.inc'; - FILENAME_MNEMONICENUM = 'MnemonicEnum.inc'; + FILENAME_MNEMONICDEFINES = 'MnemonicDefines.inc'; FILENAME_MNEMONICSTRINGS = 'MnemonicStrings.inc'; FILENAME_INSTRUCTIONDEFINITIONS = 'InstructionDefinitions.inc'; FILENAME_OPERANDDEFINITIONS = 'OperandDefinitions.inc'; @@ -769,24 +769,18 @@ var begin List := TStringList.Create; try - WorkStart('Generating mnemonic enum', Low(MnemonicList), High(MnemonicList)); + WorkStart('Generating mnemonic defines', Low(MnemonicList), High(MnemonicList)); Buffer := TStringBuffer.Create; try for I := Low(MnemonicList) to High(MnemonicList) do begin - Buffer.Append( - Format(' /*%.4x*/ ZYDIS_MNEMONIC_%s', [I, AnsiUpperCase(MnemonicList[I])])); - if (I = High(MnemonicList)) then - begin - Buffer.AppendLn(''); - end else - begin - Buffer.AppendLn(','); - end; + Buffer.Append(Format('#define /*%.4x*/ ZYDIS_MNEMONIC_%s 0x%.4x', [ + I, AnsiUpperCase(MnemonicList[I]), I])); + Buffer.AppendLn(''); Work(I); end; List.Text := Buffer.Value; - List.SaveToFile(IncludeTrailingPathDelimiter(OutputDirectory) + FILENAME_MNEMONICENUM); + List.SaveToFile(IncludeTrailingPathDelimiter(OutputDirectory) + FILENAME_MNEMONICDEFINES); finally Buffer.Free; end; diff --git a/include/Zydis/Decoder.h b/include/Zydis/Decoder.h index 57c60bb..bf62161 100644 --- a/include/Zydis/Decoder.h +++ b/include/Zydis/Decoder.h @@ -47,12 +47,48 @@ extern "C" { typedef uint32_t ZydisDecoderFlags; /** - * @brief Values that represent zydis decoder-flags. + * @brief Set this flag if you do not want @c ZydisDecoderDecodeNextInstruction to fail with + * @c ZYDIS_STATUS_INVALID_INSTRUCTION, if an invalid instruction was found. + * + * If this flag is set, @c ZydisDecoderDecodeNextInstruction just skips one byte and + * returns @c ZYDIS_STATUS_SUCCESS. The returned @c ZydisInstructionInfo struct will + * have one of the @c ZYDIS_IFLAG_ERROR_MASK flags set. */ -enum ZydisDecoderFlag -{ - ZYDIS_DECODER_FLAG_SKIP_DATA = 0x00000001 -}; +#define ZYDIS_DECODER_FLAG_SKIP_DATA 0x00000001 +/** + * @brief Includes information about all registers implicitly used by the instruction. + * + * If the @c ZYDIS_FEATURE_IMPLICITLY_USED_REGISTERS feature is not available, + * @c ZydisDecoderDecodeNextInstruction will fail with + * @c ZYDIS_STATUS_INVALID_OPERATION. + */ +#define ZYDIS_DECODER_FLAG_REGISTER_USAGE_IMPLICIT 0x00000002 +/** + * @brief Includes information about all registers explicitly used by the instruction. + */ +#define ZYDIS_DECODER_FLAG_REGISTER_USAGE_EXPLICIT 0x00000004 +/** + * @brief Includes information about all registers indicrectly used by the instruction. + * + * For example: + * [1] If the instruction accesses the RAX register, it indirectly accesses the EAX/AX/AL/AH + * registers as well. + * [2] If the instruction accesses the AL register, it indirectly accesses the AX/EAX/RAX + * registers as well. + * + * This flag only works if either the @c ZYDIS_DECODER_FLAG_REGISTER_USAGE_IMPLICIT and/or the + * @c ZYDIS_DECODER_FLAG_REGISTER_USAGE_EXPLICIT flag is set. + */ +#define ZYDIS_DECODER_FLAG_REGISTER_USAGE_INDIRECT 0x00000008 +/** + * @brief Includes information about bits of the FLAGS/EFLAGS/RFLAGS register that are + * affected by the instruction. + */ +#define ZYDIS_DECODER_FLAG_AFFECTED_REGISTERS 0x00000010 +/** + * @brief Includes information about the CPUID feature flags of the the instruction. + */ +#define ZYDIS_DECODER_FLAG_CPUID 0x00000020 /* ---------------------------------------------------------------------------------------------- */ @@ -77,6 +113,15 @@ typedef struct ZydisInstructionDecoder_ * @brief The current instruction-pointer value. */ uint64_t instructionPointer; + /** + * @brief Internal field. @c TRUE, if the @c imm8 value is already initialized. + */ + bool imm8initialized; + /** + * @brief Internal field. We have to store a copy of the imm8 value for instructions that + * encode different operands in the lo and hi part of the immediate. + */ + uint8_t imm8; /** * @brief Internal buffer. */ diff --git a/include/Zydis/Formatter.h b/include/Zydis/Formatter.h index 314ba3b..e717629 100644 --- a/include/Zydis/Formatter.h +++ b/include/Zydis/Formatter.h @@ -66,17 +66,11 @@ enum ZydisFormatterStyles */ typedef uint8_t ZydisFormatterFlags; -/** - * @brief Values that represent formatter-flags. - */ -enum ZydisFormatterFlag -{ - ZYDIS_FORMATTER_FLAG_UPPERCASE = 0x01, - ZYDIS_FORMATTER_FLAG_TAB_AFTER_MNEMONIC = 0x02, - ZYDIS_FORMATTER_FLAG_NO_SPACE_BETWEEN_OPERANDS = 0x04, - ZYDIS_FORMATTER_FLAG_ALWAYS_DISPLAY_MEMORY_SIZE = 0x08, - ZYDIS_FORMATTER_FLAG_ALWAYS_DISPLAY_MEMORY_SEGMENT = 0x10 -}; +#define ZYDIS_FORMATTER_FLAG_UPPERCASE 0x01 +#define ZYDIS_FORMATTER_FLAG_TAB_AFTER_MNEMONIC 0x02 +#define ZYDIS_FORMATTER_FLAG_NO_SPACE_BETWEEN_OPERANDS 0x04 +#define ZYDIS_FORMATTER_FLAG_ALWAYS_DISPLAY_MEMORY_SIZE 0x08 +#define ZYDIS_FORMATTER_FLAG_ALWAYS_DISPLAY_MEMORY_SEGMENT 0x10 /** * @brief Defines the zydis address-format datatype. diff --git a/include/Zydis/InstructionDetails.h b/include/Zydis/InstructionDetails.h index e4ef4c3..6133176 100644 --- a/include/Zydis/InstructionDetails.h +++ b/include/Zydis/InstructionDetails.h @@ -44,6 +44,96 @@ extern "C" { /* Enums and types */ /* ---------------------------------------------------------------------------------------------- */ +/** + * @brief Defines the @c ZydisRegisterAccessFlags datatype. + */ +typedef uint8_t ZydisRegisterAccessFlags; + +/** + * @brief The instruction reads from this register. + */ +#define ZYDIS_REGISTER_ACCESS_READ 0x01 +/** + * @brief The instruction writes to this register. + */ +#define ZYDIS_REGISTER_ACCESS_WRITE 0x02 +/** + * @brief The instruction implicitly reads from this register. + */ +#define ZYDIS_REGISTER_ACCESS_IMPLICIT_READ 0x04 +/** + * @brief The instruction implicitly writes to this register. + */ +#define ZYDIS_REGISTER_ACCESS_IMPLICIT_WRITE 0x08 +/** + * @brief The instruction indirectly reads from this register. + * + * For example: + * [1] If the instruction accesses the RAX register, it indirectly accesses the + * EAX/AX/AL/AH registers as well. + * [2] If the instruction accesses the AL register, it indirectly accesses the + * AX/EAX/RAX registers as well. + */ +#define ZYDIS_REGISTER_ACCESS_INDIRECT_READ 0x10 +/** + * @brief The instruction indirectly writes to this register. + * + * For example: + * [1] If the instruction accesses the RAX register, it indirectly accesses the + * EAX/AX/AL/AH registers as well. + * [2] If the instruction accesses the AL register, it indirectly accesses the + * AX/EAX/RAX registers as well. + */ +#define ZYDIS_REGISTER_ACCESS_INDIRECT_WRITE 0x20 +/** + * @brief The instruction indirectly and implicitly reads from this register. + * + * For example: + * [1] If the instruction accesses the RAX register, it indirectly accesses the + * EAX/AX/AL/AH registers as well. + * [2] If the instruction accesses the AL register, it indirectly accesses the + * AX/EAX/RAX registers as well. + */ +#define ZYDIS_REGISTER_ACCESS_INDIRECT_IMPLICIT_READ 0x40 +/** + * @brief The instruction indirectly and implicitly writes to this register. + * + * For example: + * [1] If the instruction accesses the RAX register, it indirectly accesses the + * EAX/AX/AL/AH registers as well. + * [2] If the instruction accesses the AL register, it indirectly accesses the + * AX/EAX/RAX registers as well. + */ +#define ZYDIS_REGISTER_ACCESS_INDIRECT_IMPLICIT_WRITE 0x80 + +/** + * @brief Defines the @c ZydisRegisterInfo struct. + */ +typedef struct ZydisRegisterInfo_ +{ + /** + * @brief The number of items in the @c reg array. + */ + uint8_t count; + /** + * @brief Array with advanced information about every register used by the current + * instruction. + */ + struct + { + /** + * @brief The register id. + */ + ZydisRegister id; + /** + * @brief The register access-flags. + */ + ZydisRegisterAccessFlags access; + } reg[255]; +} ZydisRegisterInfo; + +/* ---------------------------------------------------------------------------------------------- */ + /** * @brief Defines the zydis cpuid-feature-flag datatype. */ diff --git a/include/Zydis/InstructionInfo.h b/include/Zydis/InstructionInfo.h index e5fb393..8602f0f 100644 --- a/include/Zydis/InstructionInfo.h +++ b/include/Zydis/InstructionInfo.h @@ -73,55 +73,59 @@ enum ZydisDisassemblerModes */ typedef uint32_t ZydisInstructionFlags; -/** - * @brief The instruction has one or more operand with position-relative offsets. - */ -#define ZYDIS_IFLAG_RELATIVE 0x00000001 /** * @brief The instruction has the modrm byte. */ -#define ZYDIS_IFLAG_HAS_MODRM 0x00000002 +#define ZYDIS_INSTRUCTION_HAS_MODRM 0x00000001 /** * @brief The instruction has the sib byte. */ -#define ZYDIS_IFLAG_HAS_SIB 0x00000004 +#define ZYDIS_INSTRUCTION_HAS_SIB 0x00000002 +/** + * @brief The instruction has one or more operands with position-relative offsets. + */ +#define ZYDIS_INSTRUCTION_RELATIVE 0x00000004 +/** + * @brief The instruction is privileged and may only be executed in kernel-mode (ring0). + */ +#define ZYDIS_INSTRUCTION_PRIVILEGED 0x00000008 /** * @brief An error occured while decoding the current instruction. */ -#define ZYDIS_IFLAG_ERROR_MASK 0x7F000000 +#define ZYDIS_INSTRUCTION_ERROR_MASK 0x7F000000 /** * @brief The instruction is invalid. */ -#define ZYDIS_IFLAG_ERROR_INVALID 0x01000000 +#define ZYDIS_INSTRUCTION_ERROR_INVALID 0x01000000 /** * @brief The instruction length has exceeded the maximum of 15 bytes. */ -#define ZYDIS_IFLAG_ERROR_INSTRUCTION_LENGTH 0x02000000 +#define ZYDIS_INSTRUCTION_ERROR_INSTRUCTION_LENGTH 0x02000000 /** * @brief An error occured while decoding the vex-prefix. */ -#define ZYDIS_IFLAG_ERROR_MALFORMED_VEX 0x04000000 +#define ZYDIS_INSTRUCTION_ERROR_MALFORMED_VEX 0x04000000 /** * @brief An error occured while decoding the evex-prefix. */ -#define ZYDIS_IFLAG_ERROR_MALFORMED_EVEX 0x08000000 +#define ZYDIS_INSTRUCTION_ERROR_MALFORMED_EVEX 0x08000000 /** * @brief An error occured while decoding the xop-prefix. */ -#define ZYDIS_IFLAG_ERROR_MALFORMED_XOP 0x10000000 +#define ZYDIS_INSTRUCTION_ERROR_MALFORMED_XOP 0x10000000 /** * @brief A rex-prefix was found while decoding a vex/evex/xop instruction. */ -#define ZYDIS_IFLAG_ERROR_ILLEGAL_REX 0x20000000 +#define ZYDIS_INSTRUCTION_ERROR_ILLEGAL_REX 0x20000000 /** * @brief An invalid constellation was found while decoding an instruction that uses the VSIB * addressing mode. */ -#define ZYDIS_IFLAG_ERROR_INVALID_VSIB 0x40000000 +#define ZYDIS_INSTRUCTION_ERROR_INVALID_VSIB 0x40000000 /** * @brief An error occured while decoding the instruction-operands. */ -#define ZYDIS_IFLAG_ERROR_OPERANDS 0x40000000 +#define ZYDIS_INSTRUCTION_ERROR_OPERANDS 0x40000000 /* ---------------------------------------------------------------------------------------------- */ /* Prefix flags */ @@ -385,7 +389,7 @@ enum ZydisOperandEncodings /* ---------------------------------------------------------------------------------------------- */ /** - * @brief Defines an alias representing an operand-access mode. + * @brief Defines the @c ZydisOperandAccess datatype. */ typedef uint8_t ZydisOperandAccess; @@ -554,10 +558,6 @@ typedef struct ZydisOperandInfo_ */ struct { - /** - * @brief The physical displacement size. - */ - uint8_t size; /** * @brief The displacement value */ @@ -568,6 +568,10 @@ typedef struct ZydisOperandInfo_ int32_t sdword; int64_t sqword; } value; + /** + * @brief The physical displacement size. + */ + uint8_t dataSize; /** * @brief The offset of the displacement data, relative to the beginning of the * instruction. @@ -596,10 +600,6 @@ typedef struct ZydisOperandInfo_ * @brief Signals, if the immediate value contains a relative offset. */ bool isRelative; - /** - * @brief The physical immediate size. - */ - uint8_t size; /** * @brief The immediate value. */ @@ -614,6 +614,10 @@ typedef struct ZydisOperandInfo_ int64_t sqword; uint64_t uqword; } value; + /** + * @brief The physical immediate size. + */ + uint8_t dataSize; /** * @brief The offset of the immediate data, relative to the beginning of the instruction. */ @@ -708,7 +712,7 @@ typedef struct ZydisInstructionInfo_ */ ZydisAVXRoundingMode roundingMode; /** - * @brief The AVX suppress-all-exceptions flag. + * @brief @c TRUE, if the AVX suppress-all-exceptions flag is set. */ bool sae; } avx; @@ -721,7 +725,7 @@ typedef struct ZydisInstructionInfo_ * @brief The instruction pointer points at the address of the next instruction (relative * to the initial instruction pointer). * - * This field is used to properly format relative instructions. + * This field is used to properly format relative instructions. */ uint64_t instrPointer; /** @@ -902,9 +906,6 @@ typedef struct ZydisInstructionInfo_ */ struct { - // TODO: Move from this struct to the decoder instance - bool imm8initialized; - uint8_t imm8; uint8_t w; uint8_t r; uint8_t x; diff --git a/include/Zydis/Internal/MnemonicDefines.inc b/include/Zydis/Internal/MnemonicDefines.inc new file mode 100644 index 0000000..ebb3492 --- /dev/null +++ b/include/Zydis/Internal/MnemonicDefines.inc @@ -0,0 +1,1440 @@ +#define /*0000*/ ZYDIS_MNEMONIC_INVALID 0x0000 +#define /*0001*/ ZYDIS_MNEMONIC_AAA 0x0001 +#define /*0002*/ ZYDIS_MNEMONIC_AAD 0x0002 +#define /*0003*/ ZYDIS_MNEMONIC_AAM 0x0003 +#define /*0004*/ ZYDIS_MNEMONIC_AAS 0x0004 +#define /*0005*/ ZYDIS_MNEMONIC_ADC 0x0005 +#define /*0006*/ ZYDIS_MNEMONIC_ADCX 0x0006 +#define /*0007*/ ZYDIS_MNEMONIC_ADD 0x0007 +#define /*0008*/ ZYDIS_MNEMONIC_ADDPD 0x0008 +#define /*0009*/ ZYDIS_MNEMONIC_ADDPS 0x0009 +#define /*000A*/ ZYDIS_MNEMONIC_ADDSD 0x000A +#define /*000B*/ ZYDIS_MNEMONIC_ADDSS 0x000B +#define /*000C*/ ZYDIS_MNEMONIC_ADDSUBPD 0x000C +#define /*000D*/ ZYDIS_MNEMONIC_ADDSUBPS 0x000D +#define /*000E*/ ZYDIS_MNEMONIC_ADOX 0x000E +#define /*000F*/ ZYDIS_MNEMONIC_AESDEC 0x000F +#define /*0010*/ ZYDIS_MNEMONIC_AESDECLAST 0x0010 +#define /*0011*/ ZYDIS_MNEMONIC_AESENC 0x0011 +#define /*0012*/ ZYDIS_MNEMONIC_AESENCLAST 0x0012 +#define /*0013*/ ZYDIS_MNEMONIC_AESIMC 0x0013 +#define /*0014*/ ZYDIS_MNEMONIC_AESKEYGENASSIST 0x0014 +#define /*0015*/ ZYDIS_MNEMONIC_AND 0x0015 +#define /*0016*/ ZYDIS_MNEMONIC_ANDN 0x0016 +#define /*0017*/ ZYDIS_MNEMONIC_ANDNPD 0x0017 +#define /*0018*/ ZYDIS_MNEMONIC_ANDNPS 0x0018 +#define /*0019*/ ZYDIS_MNEMONIC_ANDPD 0x0019 +#define /*001A*/ ZYDIS_MNEMONIC_ANDPS 0x001A +#define /*001B*/ ZYDIS_MNEMONIC_ARPL 0x001B +#define /*001C*/ ZYDIS_MNEMONIC_BEXTR 0x001C +#define /*001D*/ ZYDIS_MNEMONIC_BLCFILL 0x001D +#define /*001E*/ ZYDIS_MNEMONIC_BLCI 0x001E +#define /*001F*/ ZYDIS_MNEMONIC_BLCIC 0x001F +#define /*0020*/ ZYDIS_MNEMONIC_BLCMSK 0x0020 +#define /*0021*/ ZYDIS_MNEMONIC_BLCS 0x0021 +#define /*0022*/ ZYDIS_MNEMONIC_BLENDPD 0x0022 +#define /*0023*/ ZYDIS_MNEMONIC_BLENDPS 0x0023 +#define /*0024*/ ZYDIS_MNEMONIC_BLENDVPD 0x0024 +#define /*0025*/ ZYDIS_MNEMONIC_BLENDVPS 0x0025 +#define /*0026*/ ZYDIS_MNEMONIC_BLSFILL 0x0026 +#define /*0027*/ ZYDIS_MNEMONIC_BLSI 0x0027 +#define /*0028*/ ZYDIS_MNEMONIC_BLSIC 0x0028 +#define /*0029*/ ZYDIS_MNEMONIC_BLSMSK 0x0029 +#define /*002A*/ ZYDIS_MNEMONIC_BLSR 0x002A +#define /*002B*/ ZYDIS_MNEMONIC_BNDCL 0x002B +#define /*002C*/ ZYDIS_MNEMONIC_BNDCN 0x002C +#define /*002D*/ ZYDIS_MNEMONIC_BNDCU 0x002D +#define /*002E*/ ZYDIS_MNEMONIC_BNDLDX 0x002E +#define /*002F*/ ZYDIS_MNEMONIC_BNDMK 0x002F +#define /*0030*/ ZYDIS_MNEMONIC_BNDMOV 0x0030 +#define /*0031*/ ZYDIS_MNEMONIC_BNDSTX 0x0031 +#define /*0032*/ ZYDIS_MNEMONIC_BOUND 0x0032 +#define /*0033*/ ZYDIS_MNEMONIC_BSF 0x0033 +#define /*0034*/ ZYDIS_MNEMONIC_BSR 0x0034 +#define /*0035*/ ZYDIS_MNEMONIC_BSWAP 0x0035 +#define /*0036*/ ZYDIS_MNEMONIC_BT 0x0036 +#define /*0037*/ ZYDIS_MNEMONIC_BTC 0x0037 +#define /*0038*/ ZYDIS_MNEMONIC_BTR 0x0038 +#define /*0039*/ ZYDIS_MNEMONIC_BTS 0x0039 +#define /*003A*/ ZYDIS_MNEMONIC_BZHI 0x003A +#define /*003B*/ ZYDIS_MNEMONIC_CALL 0x003B +#define /*003C*/ ZYDIS_MNEMONIC_CBW 0x003C +#define /*003D*/ ZYDIS_MNEMONIC_CDQ 0x003D +#define /*003E*/ ZYDIS_MNEMONIC_CDQE 0x003E +#define /*003F*/ ZYDIS_MNEMONIC_CLAC 0x003F +#define /*0040*/ ZYDIS_MNEMONIC_CLC 0x0040 +#define /*0041*/ ZYDIS_MNEMONIC_CLD 0x0041 +#define /*0042*/ ZYDIS_MNEMONIC_CLFLUSH 0x0042 +#define /*0043*/ ZYDIS_MNEMONIC_CLFLUSHOPT 0x0043 +#define /*0044*/ ZYDIS_MNEMONIC_CLGI 0x0044 +#define /*0045*/ ZYDIS_MNEMONIC_CLI 0x0045 +#define /*0046*/ ZYDIS_MNEMONIC_CLTS 0x0046 +#define /*0047*/ ZYDIS_MNEMONIC_CLWB 0x0047 +#define /*0048*/ ZYDIS_MNEMONIC_CLZERO 0x0048 +#define /*0049*/ ZYDIS_MNEMONIC_CMC 0x0049 +#define /*004A*/ ZYDIS_MNEMONIC_CMOVA 0x004A +#define /*004B*/ ZYDIS_MNEMONIC_CMOVAE 0x004B +#define /*004C*/ ZYDIS_MNEMONIC_CMOVB 0x004C +#define /*004D*/ ZYDIS_MNEMONIC_CMOVBE 0x004D +#define /*004E*/ ZYDIS_MNEMONIC_CMOVE 0x004E +#define /*004F*/ ZYDIS_MNEMONIC_CMOVG 0x004F +#define /*0050*/ ZYDIS_MNEMONIC_CMOVGE 0x0050 +#define /*0051*/ ZYDIS_MNEMONIC_CMOVL 0x0051 +#define /*0052*/ ZYDIS_MNEMONIC_CMOVLE 0x0052 +#define /*0053*/ ZYDIS_MNEMONIC_CMOVNE 0x0053 +#define /*0054*/ ZYDIS_MNEMONIC_CMOVNO 0x0054 +#define /*0055*/ ZYDIS_MNEMONIC_CMOVNP 0x0055 +#define /*0056*/ ZYDIS_MNEMONIC_CMOVNS 0x0056 +#define /*0057*/ ZYDIS_MNEMONIC_CMOVO 0x0057 +#define /*0058*/ ZYDIS_MNEMONIC_CMOVP 0x0058 +#define /*0059*/ ZYDIS_MNEMONIC_CMOVS 0x0059 +#define /*005A*/ ZYDIS_MNEMONIC_CMP 0x005A +#define /*005B*/ ZYDIS_MNEMONIC_CMPPD 0x005B +#define /*005C*/ ZYDIS_MNEMONIC_CMPPS 0x005C +#define /*005D*/ ZYDIS_MNEMONIC_CMPSB 0x005D +#define /*005E*/ ZYDIS_MNEMONIC_CMPSD 0x005E +#define /*005F*/ ZYDIS_MNEMONIC_CMPSQ 0x005F +#define /*0060*/ ZYDIS_MNEMONIC_CMPSS 0x0060 +#define /*0061*/ ZYDIS_MNEMONIC_CMPSW 0x0061 +#define /*0062*/ ZYDIS_MNEMONIC_CMPXCHG 0x0062 +#define /*0063*/ ZYDIS_MNEMONIC_CMPXCHG16B 0x0063 +#define /*0064*/ ZYDIS_MNEMONIC_CMPXCHG8B 0x0064 +#define /*0065*/ ZYDIS_MNEMONIC_COMISD 0x0065 +#define /*0066*/ ZYDIS_MNEMONIC_COMISS 0x0066 +#define /*0067*/ ZYDIS_MNEMONIC_CPUID 0x0067 +#define /*0068*/ ZYDIS_MNEMONIC_CQO 0x0068 +#define /*0069*/ ZYDIS_MNEMONIC_CRC32 0x0069 +#define /*006A*/ ZYDIS_MNEMONIC_CVTDQ2PD 0x006A +#define /*006B*/ ZYDIS_MNEMONIC_CVTDQ2PS 0x006B +#define /*006C*/ ZYDIS_MNEMONIC_CVTPD2DQ 0x006C +#define /*006D*/ ZYDIS_MNEMONIC_CVTPD2PI 0x006D +#define /*006E*/ ZYDIS_MNEMONIC_CVTPD2PS 0x006E +#define /*006F*/ ZYDIS_MNEMONIC_CVTPI2PD 0x006F +#define /*0070*/ ZYDIS_MNEMONIC_CVTPI2PS 0x0070 +#define /*0071*/ ZYDIS_MNEMONIC_CVTPS2DQ 0x0071 +#define /*0072*/ ZYDIS_MNEMONIC_CVTPS2PD 0x0072 +#define /*0073*/ ZYDIS_MNEMONIC_CVTPS2PI 0x0073 +#define /*0074*/ ZYDIS_MNEMONIC_CVTSD2SI 0x0074 +#define /*0075*/ ZYDIS_MNEMONIC_CVTSD2SS 0x0075 +#define /*0076*/ ZYDIS_MNEMONIC_CVTSI2SD 0x0076 +#define /*0077*/ ZYDIS_MNEMONIC_CVTSI2SS 0x0077 +#define /*0078*/ ZYDIS_MNEMONIC_CVTSS2SD 0x0078 +#define /*0079*/ ZYDIS_MNEMONIC_CVTSS2SI 0x0079 +#define /*007A*/ ZYDIS_MNEMONIC_CVTTPD2DQ 0x007A +#define /*007B*/ ZYDIS_MNEMONIC_CVTTPD2PI 0x007B +#define /*007C*/ ZYDIS_MNEMONIC_CVTTPS2DQ 0x007C +#define /*007D*/ ZYDIS_MNEMONIC_CVTTPS2PI 0x007D +#define /*007E*/ ZYDIS_MNEMONIC_CVTTSD2SI 0x007E +#define /*007F*/ ZYDIS_MNEMONIC_CVTTSS2SI 0x007F +#define /*0080*/ ZYDIS_MNEMONIC_CWD 0x0080 +#define /*0081*/ ZYDIS_MNEMONIC_CWDE 0x0081 +#define /*0082*/ ZYDIS_MNEMONIC_DAA 0x0082 +#define /*0083*/ ZYDIS_MNEMONIC_DAS 0x0083 +#define /*0084*/ ZYDIS_MNEMONIC_DEC 0x0084 +#define /*0085*/ ZYDIS_MNEMONIC_DIV 0x0085 +#define /*0086*/ ZYDIS_MNEMONIC_DIVPD 0x0086 +#define /*0087*/ ZYDIS_MNEMONIC_DIVPS 0x0087 +#define /*0088*/ ZYDIS_MNEMONIC_DIVSD 0x0088 +#define /*0089*/ ZYDIS_MNEMONIC_DIVSS 0x0089 +#define /*008A*/ ZYDIS_MNEMONIC_DPPD 0x008A +#define /*008B*/ ZYDIS_MNEMONIC_DPPS 0x008B +#define /*008C*/ ZYDIS_MNEMONIC_EMMS 0x008C +#define /*008D*/ ZYDIS_MNEMONIC_ENCLS 0x008D +#define /*008E*/ ZYDIS_MNEMONIC_ENCLU 0x008E +#define /*008F*/ ZYDIS_MNEMONIC_ENTER 0x008F +#define /*0090*/ ZYDIS_MNEMONIC_EXTRACTPS 0x0090 +#define /*0091*/ ZYDIS_MNEMONIC_EXTRQ 0x0091 +#define /*0092*/ ZYDIS_MNEMONIC_F2XM1 0x0092 +#define /*0093*/ ZYDIS_MNEMONIC_FABS 0x0093 +#define /*0094*/ ZYDIS_MNEMONIC_FADD 0x0094 +#define /*0095*/ ZYDIS_MNEMONIC_FADDP 0x0095 +#define /*0096*/ ZYDIS_MNEMONIC_FBLD 0x0096 +#define /*0097*/ ZYDIS_MNEMONIC_FBSTP 0x0097 +#define /*0098*/ ZYDIS_MNEMONIC_FCHS 0x0098 +#define /*0099*/ ZYDIS_MNEMONIC_FCMOVB 0x0099 +#define /*009A*/ ZYDIS_MNEMONIC_FCMOVBE 0x009A +#define /*009B*/ ZYDIS_MNEMONIC_FCMOVE 0x009B +#define /*009C*/ ZYDIS_MNEMONIC_FCMOVNB 0x009C +#define /*009D*/ ZYDIS_MNEMONIC_FCMOVNBE 0x009D +#define /*009E*/ ZYDIS_MNEMONIC_FCMOVNE 0x009E +#define /*009F*/ ZYDIS_MNEMONIC_FCMOVNU 0x009F +#define /*00A0*/ ZYDIS_MNEMONIC_FCMOVU 0x00A0 +#define /*00A1*/ ZYDIS_MNEMONIC_FCOM 0x00A1 +#define /*00A2*/ ZYDIS_MNEMONIC_FCOMI 0x00A2 +#define /*00A3*/ ZYDIS_MNEMONIC_FCOMP 0x00A3 +#define /*00A4*/ ZYDIS_MNEMONIC_FCOMPI 0x00A4 +#define /*00A5*/ ZYDIS_MNEMONIC_FCOMPP 0x00A5 +#define /*00A6*/ ZYDIS_MNEMONIC_FCOS 0x00A6 +#define /*00A7*/ ZYDIS_MNEMONIC_FDECSTP 0x00A7 +#define /*00A8*/ ZYDIS_MNEMONIC_FDIV 0x00A8 +#define /*00A9*/ ZYDIS_MNEMONIC_FDIVP 0x00A9 +#define /*00AA*/ ZYDIS_MNEMONIC_FDIVR 0x00AA +#define /*00AB*/ ZYDIS_MNEMONIC_FDIVRP 0x00AB +#define /*00AC*/ ZYDIS_MNEMONIC_FEMMS 0x00AC +#define /*00AD*/ ZYDIS_MNEMONIC_FFREE 0x00AD +#define /*00AE*/ ZYDIS_MNEMONIC_FIADD 0x00AE +#define /*00AF*/ ZYDIS_MNEMONIC_FICOM 0x00AF +#define /*00B0*/ ZYDIS_MNEMONIC_FICOMP 0x00B0 +#define /*00B1*/ ZYDIS_MNEMONIC_FIDIV 0x00B1 +#define /*00B2*/ ZYDIS_MNEMONIC_FIDIVR 0x00B2 +#define /*00B3*/ ZYDIS_MNEMONIC_FILD 0x00B3 +#define /*00B4*/ ZYDIS_MNEMONIC_FIMUL 0x00B4 +#define /*00B5*/ ZYDIS_MNEMONIC_FINCSTP 0x00B5 +#define /*00B6*/ ZYDIS_MNEMONIC_FIST 0x00B6 +#define /*00B7*/ ZYDIS_MNEMONIC_FISTP 0x00B7 +#define /*00B8*/ ZYDIS_MNEMONIC_FISTTP 0x00B8 +#define /*00B9*/ ZYDIS_MNEMONIC_FISUB 0x00B9 +#define /*00BA*/ ZYDIS_MNEMONIC_FISUBR 0x00BA +#define /*00BB*/ ZYDIS_MNEMONIC_FLD 0x00BB +#define /*00BC*/ ZYDIS_MNEMONIC_FLD1 0x00BC +#define /*00BD*/ ZYDIS_MNEMONIC_FLDCW 0x00BD +#define /*00BE*/ ZYDIS_MNEMONIC_FLDENV 0x00BE +#define /*00BF*/ ZYDIS_MNEMONIC_FLDL2E 0x00BF +#define /*00C0*/ ZYDIS_MNEMONIC_FLDL2T 0x00C0 +#define /*00C1*/ ZYDIS_MNEMONIC_FLDLG2 0x00C1 +#define /*00C2*/ ZYDIS_MNEMONIC_FLDLN2 0x00C2 +#define /*00C3*/ ZYDIS_MNEMONIC_FLDPI 0x00C3 +#define /*00C4*/ ZYDIS_MNEMONIC_FLDZ 0x00C4 +#define /*00C5*/ ZYDIS_MNEMONIC_FMUL 0x00C5 +#define /*00C6*/ ZYDIS_MNEMONIC_FMULP 0x00C6 +#define /*00C7*/ ZYDIS_MNEMONIC_FNCLEX 0x00C7 +#define /*00C8*/ ZYDIS_MNEMONIC_FNINIT 0x00C8 +#define /*00C9*/ ZYDIS_MNEMONIC_FNOP 0x00C9 +#define /*00CA*/ ZYDIS_MNEMONIC_FNSAVE 0x00CA +#define /*00CB*/ ZYDIS_MNEMONIC_FNSTCW 0x00CB +#define /*00CC*/ ZYDIS_MNEMONIC_FNSTENV 0x00CC +#define /*00CD*/ ZYDIS_MNEMONIC_FNSTSW 0x00CD +#define /*00CE*/ ZYDIS_MNEMONIC_FPATAN 0x00CE +#define /*00CF*/ ZYDIS_MNEMONIC_FPREM 0x00CF +#define /*00D0*/ ZYDIS_MNEMONIC_FPREM1 0x00D0 +#define /*00D1*/ ZYDIS_MNEMONIC_FPTAN 0x00D1 +#define /*00D2*/ ZYDIS_MNEMONIC_FREEP 0x00D2 +#define /*00D3*/ ZYDIS_MNEMONIC_FRNDINT 0x00D3 +#define /*00D4*/ ZYDIS_MNEMONIC_FRSTOR 0x00D4 +#define /*00D5*/ ZYDIS_MNEMONIC_FSCALE 0x00D5 +#define /*00D6*/ ZYDIS_MNEMONIC_FSIN 0x00D6 +#define /*00D7*/ ZYDIS_MNEMONIC_FSINCOS 0x00D7 +#define /*00D8*/ ZYDIS_MNEMONIC_FSQRT 0x00D8 +#define /*00D9*/ ZYDIS_MNEMONIC_FST 0x00D9 +#define /*00DA*/ ZYDIS_MNEMONIC_FSTDW 0x00DA +#define /*00DB*/ ZYDIS_MNEMONIC_FSTP 0x00DB +#define /*00DC*/ ZYDIS_MNEMONIC_FSTSG 0x00DC +#define /*00DD*/ ZYDIS_MNEMONIC_FSTSW 0x00DD +#define /*00DE*/ ZYDIS_MNEMONIC_FSUB 0x00DE +#define /*00DF*/ ZYDIS_MNEMONIC_FSUBP 0x00DF +#define /*00E0*/ ZYDIS_MNEMONIC_FSUBR 0x00E0 +#define /*00E1*/ ZYDIS_MNEMONIC_FSUBRP 0x00E1 +#define /*00E2*/ ZYDIS_MNEMONIC_FTST 0x00E2 +#define /*00E3*/ ZYDIS_MNEMONIC_FUCOM 0x00E3 +#define /*00E4*/ ZYDIS_MNEMONIC_FUCOMI 0x00E4 +#define /*00E5*/ ZYDIS_MNEMONIC_FUCOMP 0x00E5 +#define /*00E6*/ ZYDIS_MNEMONIC_FUCOMPI 0x00E6 +#define /*00E7*/ ZYDIS_MNEMONIC_FUCOMPP 0x00E7 +#define /*00E8*/ ZYDIS_MNEMONIC_FXAM 0x00E8 +#define /*00E9*/ ZYDIS_MNEMONIC_FXCH 0x00E9 +#define /*00EA*/ ZYDIS_MNEMONIC_FXRSTOR 0x00EA +#define /*00EB*/ ZYDIS_MNEMONIC_FXRSTOR64 0x00EB +#define /*00EC*/ ZYDIS_MNEMONIC_FXSAVE 0x00EC +#define /*00ED*/ ZYDIS_MNEMONIC_FXSAVE64 0x00ED +#define /*00EE*/ ZYDIS_MNEMONIC_FXTRACT 0x00EE +#define /*00EF*/ ZYDIS_MNEMONIC_FYL2X 0x00EF +#define /*00F0*/ ZYDIS_MNEMONIC_FYL2XP1 0x00F0 +#define /*00F1*/ ZYDIS_MNEMONIC_GETSEC 0x00F1 +#define /*00F2*/ ZYDIS_MNEMONIC_HADDPD 0x00F2 +#define /*00F3*/ ZYDIS_MNEMONIC_HADDPS 0x00F3 +#define /*00F4*/ ZYDIS_MNEMONIC_HLT 0x00F4 +#define /*00F5*/ ZYDIS_MNEMONIC_HSUBPD 0x00F5 +#define /*00F6*/ ZYDIS_MNEMONIC_HSUBPS 0x00F6 +#define /*00F7*/ ZYDIS_MNEMONIC_IDIV 0x00F7 +#define /*00F8*/ ZYDIS_MNEMONIC_IMUL 0x00F8 +#define /*00F9*/ ZYDIS_MNEMONIC_IN 0x00F9 +#define /*00FA*/ ZYDIS_MNEMONIC_INC 0x00FA +#define /*00FB*/ ZYDIS_MNEMONIC_INSB 0x00FB +#define /*00FC*/ ZYDIS_MNEMONIC_INSD 0x00FC +#define /*00FD*/ ZYDIS_MNEMONIC_INSERTPS 0x00FD +#define /*00FE*/ ZYDIS_MNEMONIC_INSERTQ 0x00FE +#define /*00FF*/ ZYDIS_MNEMONIC_INSW 0x00FF +#define /*0100*/ ZYDIS_MNEMONIC_INT 0x0100 +#define /*0101*/ ZYDIS_MNEMONIC_INT1 0x0101 +#define /*0102*/ ZYDIS_MNEMONIC_INT3 0x0102 +#define /*0103*/ ZYDIS_MNEMONIC_INTO 0x0103 +#define /*0104*/ ZYDIS_MNEMONIC_INVD 0x0104 +#define /*0105*/ ZYDIS_MNEMONIC_INVEPT 0x0105 +#define /*0106*/ ZYDIS_MNEMONIC_INVLPG 0x0106 +#define /*0107*/ ZYDIS_MNEMONIC_INVLPGA 0x0107 +#define /*0108*/ ZYDIS_MNEMONIC_INVPCID 0x0108 +#define /*0109*/ ZYDIS_MNEMONIC_INVVPID 0x0109 +#define /*010A*/ ZYDIS_MNEMONIC_IRET 0x010A +#define /*010B*/ ZYDIS_MNEMONIC_IRETD 0x010B +#define /*010C*/ ZYDIS_MNEMONIC_IRETQ 0x010C +#define /*010D*/ ZYDIS_MNEMONIC_JA 0x010D +#define /*010E*/ ZYDIS_MNEMONIC_JAE 0x010E +#define /*010F*/ ZYDIS_MNEMONIC_JB 0x010F +#define /*0110*/ ZYDIS_MNEMONIC_JBE 0x0110 +#define /*0111*/ ZYDIS_MNEMONIC_JCXZ 0x0111 +#define /*0112*/ ZYDIS_MNEMONIC_JE 0x0112 +#define /*0113*/ ZYDIS_MNEMONIC_JECXZ 0x0113 +#define /*0114*/ ZYDIS_MNEMONIC_JG 0x0114 +#define /*0115*/ ZYDIS_MNEMONIC_JGE 0x0115 +#define /*0116*/ ZYDIS_MNEMONIC_JL 0x0116 +#define /*0117*/ ZYDIS_MNEMONIC_JLE 0x0117 +#define /*0118*/ ZYDIS_MNEMONIC_JMP 0x0118 +#define /*0119*/ ZYDIS_MNEMONIC_JNE 0x0119 +#define /*011A*/ ZYDIS_MNEMONIC_JNO 0x011A +#define /*011B*/ ZYDIS_MNEMONIC_JNP 0x011B +#define /*011C*/ ZYDIS_MNEMONIC_JNS 0x011C +#define /*011D*/ ZYDIS_MNEMONIC_JO 0x011D +#define /*011E*/ ZYDIS_MNEMONIC_JP 0x011E +#define /*011F*/ ZYDIS_MNEMONIC_JRCXZ 0x011F +#define /*0120*/ ZYDIS_MNEMONIC_JS 0x0120 +#define /*0121*/ ZYDIS_MNEMONIC_KADDB 0x0121 +#define /*0122*/ ZYDIS_MNEMONIC_KADDD 0x0122 +#define /*0123*/ ZYDIS_MNEMONIC_KADDQ 0x0123 +#define /*0124*/ ZYDIS_MNEMONIC_KADDW 0x0124 +#define /*0125*/ ZYDIS_MNEMONIC_KANDB 0x0125 +#define /*0126*/ ZYDIS_MNEMONIC_KANDD 0x0126 +#define /*0127*/ ZYDIS_MNEMONIC_KANDNB 0x0127 +#define /*0128*/ ZYDIS_MNEMONIC_KANDND 0x0128 +#define /*0129*/ ZYDIS_MNEMONIC_KANDNQ 0x0129 +#define /*012A*/ ZYDIS_MNEMONIC_KANDNW 0x012A +#define /*012B*/ ZYDIS_MNEMONIC_KANDQ 0x012B +#define /*012C*/ ZYDIS_MNEMONIC_KANDW 0x012C +#define /*012D*/ ZYDIS_MNEMONIC_KMOVB 0x012D +#define /*012E*/ ZYDIS_MNEMONIC_KMOVD 0x012E +#define /*012F*/ ZYDIS_MNEMONIC_KMOVQ 0x012F +#define /*0130*/ ZYDIS_MNEMONIC_KMOVW 0x0130 +#define /*0131*/ ZYDIS_MNEMONIC_KNOTB 0x0131 +#define /*0132*/ ZYDIS_MNEMONIC_KNOTD 0x0132 +#define /*0133*/ ZYDIS_MNEMONIC_KNOTQ 0x0133 +#define /*0134*/ ZYDIS_MNEMONIC_KNOTW 0x0134 +#define /*0135*/ ZYDIS_MNEMONIC_KORB 0x0135 +#define /*0136*/ ZYDIS_MNEMONIC_KORD 0x0136 +#define /*0137*/ ZYDIS_MNEMONIC_KORQ 0x0137 +#define /*0138*/ ZYDIS_MNEMONIC_KORTESTB 0x0138 +#define /*0139*/ ZYDIS_MNEMONIC_KORTESTD 0x0139 +#define /*013A*/ ZYDIS_MNEMONIC_KORTESTQ 0x013A +#define /*013B*/ ZYDIS_MNEMONIC_KORTESTW 0x013B +#define /*013C*/ ZYDIS_MNEMONIC_KORW 0x013C +#define /*013D*/ ZYDIS_MNEMONIC_KSHIFTLB 0x013D +#define /*013E*/ ZYDIS_MNEMONIC_KSHIFTLD 0x013E +#define /*013F*/ ZYDIS_MNEMONIC_KSHIFTLQ 0x013F +#define /*0140*/ ZYDIS_MNEMONIC_KSHIFTLW 0x0140 +#define /*0141*/ ZYDIS_MNEMONIC_KSHIFTRB 0x0141 +#define /*0142*/ ZYDIS_MNEMONIC_KSHIFTRD 0x0142 +#define /*0143*/ ZYDIS_MNEMONIC_KSHIFTRQ 0x0143 +#define /*0144*/ ZYDIS_MNEMONIC_KSHIFTRW 0x0144 +#define /*0145*/ ZYDIS_MNEMONIC_KTESTB 0x0145 +#define /*0146*/ ZYDIS_MNEMONIC_KTESTD 0x0146 +#define /*0147*/ ZYDIS_MNEMONIC_KTESTQ 0x0147 +#define /*0148*/ ZYDIS_MNEMONIC_KTESTW 0x0148 +#define /*0149*/ ZYDIS_MNEMONIC_KUNPCKBW 0x0149 +#define /*014A*/ ZYDIS_MNEMONIC_KUNPCKDQ 0x014A +#define /*014B*/ ZYDIS_MNEMONIC_KUNPCKWD 0x014B +#define /*014C*/ ZYDIS_MNEMONIC_KXNORB 0x014C +#define /*014D*/ ZYDIS_MNEMONIC_KXNORD 0x014D +#define /*014E*/ ZYDIS_MNEMONIC_KXNORQ 0x014E +#define /*014F*/ ZYDIS_MNEMONIC_KXNORW 0x014F +#define /*0150*/ ZYDIS_MNEMONIC_KXORB 0x0150 +#define /*0151*/ ZYDIS_MNEMONIC_KXORD 0x0151 +#define /*0152*/ ZYDIS_MNEMONIC_KXORQ 0x0152 +#define /*0153*/ ZYDIS_MNEMONIC_KXORW 0x0153 +#define /*0154*/ ZYDIS_MNEMONIC_LAHF 0x0154 +#define /*0155*/ ZYDIS_MNEMONIC_LAR 0x0155 +#define /*0156*/ ZYDIS_MNEMONIC_LDDQU 0x0156 +#define /*0157*/ ZYDIS_MNEMONIC_LDMXCSR 0x0157 +#define /*0158*/ ZYDIS_MNEMONIC_LDS 0x0158 +#define /*0159*/ ZYDIS_MNEMONIC_LEA 0x0159 +#define /*015A*/ ZYDIS_MNEMONIC_LEAVE 0x015A +#define /*015B*/ ZYDIS_MNEMONIC_LES 0x015B +#define /*015C*/ ZYDIS_MNEMONIC_LFENCE 0x015C +#define /*015D*/ ZYDIS_MNEMONIC_LFS 0x015D +#define /*015E*/ ZYDIS_MNEMONIC_LGDT 0x015E +#define /*015F*/ ZYDIS_MNEMONIC_LGS 0x015F +#define /*0160*/ ZYDIS_MNEMONIC_LIDT 0x0160 +#define /*0161*/ ZYDIS_MNEMONIC_LJMP 0x0161 +#define /*0162*/ ZYDIS_MNEMONIC_LLDT 0x0162 +#define /*0163*/ ZYDIS_MNEMONIC_LMSW 0x0163 +#define /*0164*/ ZYDIS_MNEMONIC_LODSB 0x0164 +#define /*0165*/ ZYDIS_MNEMONIC_LODSD 0x0165 +#define /*0166*/ ZYDIS_MNEMONIC_LODSQ 0x0166 +#define /*0167*/ ZYDIS_MNEMONIC_LODSW 0x0167 +#define /*0168*/ ZYDIS_MNEMONIC_LOOP 0x0168 +#define /*0169*/ ZYDIS_MNEMONIC_LOOPE 0x0169 +#define /*016A*/ ZYDIS_MNEMONIC_LOOPNE 0x016A +#define /*016B*/ ZYDIS_MNEMONIC_LSL 0x016B +#define /*016C*/ ZYDIS_MNEMONIC_LSS 0x016C +#define /*016D*/ ZYDIS_MNEMONIC_LTR 0x016D +#define /*016E*/ ZYDIS_MNEMONIC_LZCNT 0x016E +#define /*016F*/ ZYDIS_MNEMONIC_MASKMOVDQU 0x016F +#define /*0170*/ ZYDIS_MNEMONIC_MASKMOVQ 0x0170 +#define /*0171*/ ZYDIS_MNEMONIC_MAXPD 0x0171 +#define /*0172*/ ZYDIS_MNEMONIC_MAXPS 0x0172 +#define /*0173*/ ZYDIS_MNEMONIC_MAXSD 0x0173 +#define /*0174*/ ZYDIS_MNEMONIC_MAXSS 0x0174 +#define /*0175*/ ZYDIS_MNEMONIC_MFENCE 0x0175 +#define /*0176*/ ZYDIS_MNEMONIC_MINPD 0x0176 +#define /*0177*/ ZYDIS_MNEMONIC_MINPS 0x0177 +#define /*0178*/ ZYDIS_MNEMONIC_MINSD 0x0178 +#define /*0179*/ ZYDIS_MNEMONIC_MINSS 0x0179 +#define /*017A*/ ZYDIS_MNEMONIC_MONITOR 0x017A +#define /*017B*/ ZYDIS_MNEMONIC_MONITORX 0x017B +#define /*017C*/ ZYDIS_MNEMONIC_MONTMUL 0x017C +#define /*017D*/ ZYDIS_MNEMONIC_MOV 0x017D +#define /*017E*/ ZYDIS_MNEMONIC_MOVAPD 0x017E +#define /*017F*/ ZYDIS_MNEMONIC_MOVAPS 0x017F +#define /*0180*/ ZYDIS_MNEMONIC_MOVBE 0x0180 +#define /*0181*/ ZYDIS_MNEMONIC_MOVD 0x0181 +#define /*0182*/ ZYDIS_MNEMONIC_MOVDDUP 0x0182 +#define /*0183*/ ZYDIS_MNEMONIC_MOVDQ2Q 0x0183 +#define /*0184*/ ZYDIS_MNEMONIC_MOVDQA 0x0184 +#define /*0185*/ ZYDIS_MNEMONIC_MOVDQU 0x0185 +#define /*0186*/ ZYDIS_MNEMONIC_MOVHLPS 0x0186 +#define /*0187*/ ZYDIS_MNEMONIC_MOVHPD 0x0187 +#define /*0188*/ ZYDIS_MNEMONIC_MOVHPS 0x0188 +#define /*0189*/ ZYDIS_MNEMONIC_MOVLHPS 0x0189 +#define /*018A*/ ZYDIS_MNEMONIC_MOVLPD 0x018A +#define /*018B*/ ZYDIS_MNEMONIC_MOVLPS 0x018B +#define /*018C*/ ZYDIS_MNEMONIC_MOVMSKPD 0x018C +#define /*018D*/ ZYDIS_MNEMONIC_MOVMSKPS 0x018D +#define /*018E*/ ZYDIS_MNEMONIC_MOVNTDQ 0x018E +#define /*018F*/ ZYDIS_MNEMONIC_MOVNTDQA 0x018F +#define /*0190*/ ZYDIS_MNEMONIC_MOVNTI 0x0190 +#define /*0191*/ ZYDIS_MNEMONIC_MOVNTPD 0x0191 +#define /*0192*/ ZYDIS_MNEMONIC_MOVNTPS 0x0192 +#define /*0193*/ ZYDIS_MNEMONIC_MOVNTQ 0x0193 +#define /*0194*/ ZYDIS_MNEMONIC_MOVNTSD 0x0194 +#define /*0195*/ ZYDIS_MNEMONIC_MOVNTSS 0x0195 +#define /*0196*/ ZYDIS_MNEMONIC_MOVQ 0x0196 +#define /*0197*/ ZYDIS_MNEMONIC_MOVQ2DQ 0x0197 +#define /*0198*/ ZYDIS_MNEMONIC_MOVSB 0x0198 +#define /*0199*/ ZYDIS_MNEMONIC_MOVSD 0x0199 +#define /*019A*/ ZYDIS_MNEMONIC_MOVSHDUP 0x019A +#define /*019B*/ ZYDIS_MNEMONIC_MOVSLDUP 0x019B +#define /*019C*/ ZYDIS_MNEMONIC_MOVSQ 0x019C +#define /*019D*/ ZYDIS_MNEMONIC_MOVSS 0x019D +#define /*019E*/ ZYDIS_MNEMONIC_MOVSW 0x019E +#define /*019F*/ ZYDIS_MNEMONIC_MOVSX 0x019F +#define /*01A0*/ ZYDIS_MNEMONIC_MOVSXD 0x01A0 +#define /*01A1*/ ZYDIS_MNEMONIC_MOVUPD 0x01A1 +#define /*01A2*/ ZYDIS_MNEMONIC_MOVUPS 0x01A2 +#define /*01A3*/ ZYDIS_MNEMONIC_MOVZX 0x01A3 +#define /*01A4*/ ZYDIS_MNEMONIC_MPSADBW 0x01A4 +#define /*01A5*/ ZYDIS_MNEMONIC_MUL 0x01A5 +#define /*01A6*/ ZYDIS_MNEMONIC_MULPD 0x01A6 +#define /*01A7*/ ZYDIS_MNEMONIC_MULPS 0x01A7 +#define /*01A8*/ ZYDIS_MNEMONIC_MULSD 0x01A8 +#define /*01A9*/ ZYDIS_MNEMONIC_MULSS 0x01A9 +#define /*01AA*/ ZYDIS_MNEMONIC_MULX 0x01AA +#define /*01AB*/ ZYDIS_MNEMONIC_MWAIT 0x01AB +#define /*01AC*/ ZYDIS_MNEMONIC_MWAITX 0x01AC +#define /*01AD*/ ZYDIS_MNEMONIC_NEG 0x01AD +#define /*01AE*/ ZYDIS_MNEMONIC_NOP 0x01AE +#define /*01AF*/ ZYDIS_MNEMONIC_NOT 0x01AF +#define /*01B0*/ ZYDIS_MNEMONIC_OR 0x01B0 +#define /*01B1*/ ZYDIS_MNEMONIC_ORPD 0x01B1 +#define /*01B2*/ ZYDIS_MNEMONIC_ORPS 0x01B2 +#define /*01B3*/ ZYDIS_MNEMONIC_OUT 0x01B3 +#define /*01B4*/ ZYDIS_MNEMONIC_OUTSB 0x01B4 +#define /*01B5*/ ZYDIS_MNEMONIC_OUTSD 0x01B5 +#define /*01B6*/ ZYDIS_MNEMONIC_OUTSW 0x01B6 +#define /*01B7*/ ZYDIS_MNEMONIC_PABSB 0x01B7 +#define /*01B8*/ ZYDIS_MNEMONIC_PABSD 0x01B8 +#define /*01B9*/ ZYDIS_MNEMONIC_PABSW 0x01B9 +#define /*01BA*/ ZYDIS_MNEMONIC_PACKSSDW 0x01BA +#define /*01BB*/ ZYDIS_MNEMONIC_PACKSSWB 0x01BB +#define /*01BC*/ ZYDIS_MNEMONIC_PACKUSDW 0x01BC +#define /*01BD*/ ZYDIS_MNEMONIC_PACKUSWB 0x01BD +#define /*01BE*/ ZYDIS_MNEMONIC_PADDB 0x01BE +#define /*01BF*/ ZYDIS_MNEMONIC_PADDD 0x01BF +#define /*01C0*/ ZYDIS_MNEMONIC_PADDQ 0x01C0 +#define /*01C1*/ ZYDIS_MNEMONIC_PADDSB 0x01C1 +#define /*01C2*/ ZYDIS_MNEMONIC_PADDSW 0x01C2 +#define /*01C3*/ ZYDIS_MNEMONIC_PADDUSB 0x01C3 +#define /*01C4*/ ZYDIS_MNEMONIC_PADDUSW 0x01C4 +#define /*01C5*/ ZYDIS_MNEMONIC_PADDW 0x01C5 +#define /*01C6*/ ZYDIS_MNEMONIC_PALIGNR 0x01C6 +#define /*01C7*/ ZYDIS_MNEMONIC_PAND 0x01C7 +#define /*01C8*/ ZYDIS_MNEMONIC_PANDN 0x01C8 +#define /*01C9*/ ZYDIS_MNEMONIC_PAUSE 0x01C9 +#define /*01CA*/ ZYDIS_MNEMONIC_PAVGB 0x01CA +#define /*01CB*/ ZYDIS_MNEMONIC_PAVGUSB 0x01CB +#define /*01CC*/ ZYDIS_MNEMONIC_PAVGW 0x01CC +#define /*01CD*/ ZYDIS_MNEMONIC_PBLENDVB 0x01CD +#define /*01CE*/ ZYDIS_MNEMONIC_PBLENDW 0x01CE +#define /*01CF*/ ZYDIS_MNEMONIC_PCLMULQDQ 0x01CF +#define /*01D0*/ ZYDIS_MNEMONIC_PCMPEQB 0x01D0 +#define /*01D1*/ ZYDIS_MNEMONIC_PCMPEQD 0x01D1 +#define /*01D2*/ ZYDIS_MNEMONIC_PCMPEQQ 0x01D2 +#define /*01D3*/ ZYDIS_MNEMONIC_PCMPEQW 0x01D3 +#define /*01D4*/ ZYDIS_MNEMONIC_PCMPESTRI 0x01D4 +#define /*01D5*/ ZYDIS_MNEMONIC_PCMPESTRM 0x01D5 +#define /*01D6*/ ZYDIS_MNEMONIC_PCMPGTB 0x01D6 +#define /*01D7*/ ZYDIS_MNEMONIC_PCMPGTD 0x01D7 +#define /*01D8*/ ZYDIS_MNEMONIC_PCMPGTQ 0x01D8 +#define /*01D9*/ ZYDIS_MNEMONIC_PCMPGTW 0x01D9 +#define /*01DA*/ ZYDIS_MNEMONIC_PCMPISTRI 0x01DA +#define /*01DB*/ ZYDIS_MNEMONIC_PCMPISTRM 0x01DB +#define /*01DC*/ ZYDIS_MNEMONIC_PCOMMIT 0x01DC +#define /*01DD*/ ZYDIS_MNEMONIC_PDEP 0x01DD +#define /*01DE*/ ZYDIS_MNEMONIC_PEXT 0x01DE +#define /*01DF*/ ZYDIS_MNEMONIC_PEXTRB 0x01DF +#define /*01E0*/ ZYDIS_MNEMONIC_PEXTRD 0x01E0 +#define /*01E1*/ ZYDIS_MNEMONIC_PEXTRQ 0x01E1 +#define /*01E2*/ ZYDIS_MNEMONIC_PEXTRW 0x01E2 +#define /*01E3*/ ZYDIS_MNEMONIC_PF2ID 0x01E3 +#define /*01E4*/ ZYDIS_MNEMONIC_PF2IW 0x01E4 +#define /*01E5*/ ZYDIS_MNEMONIC_PFACC 0x01E5 +#define /*01E6*/ ZYDIS_MNEMONIC_PFADD 0x01E6 +#define /*01E7*/ ZYDIS_MNEMONIC_PFCMPEQ 0x01E7 +#define /*01E8*/ ZYDIS_MNEMONIC_PFCMPGE 0x01E8 +#define /*01E9*/ ZYDIS_MNEMONIC_PFCMPGT 0x01E9 +#define /*01EA*/ ZYDIS_MNEMONIC_PFMAX 0x01EA +#define /*01EB*/ ZYDIS_MNEMONIC_PFMIN 0x01EB +#define /*01EC*/ ZYDIS_MNEMONIC_PFMUL 0x01EC +#define /*01ED*/ ZYDIS_MNEMONIC_PFNACC 0x01ED +#define /*01EE*/ ZYDIS_MNEMONIC_PFPNACC 0x01EE +#define /*01EF*/ ZYDIS_MNEMONIC_PFRCP 0x01EF +#define /*01F0*/ ZYDIS_MNEMONIC_PFRCPIT1 0x01F0 +#define /*01F1*/ ZYDIS_MNEMONIC_PFRCPIT2 0x01F1 +#define /*01F2*/ ZYDIS_MNEMONIC_PFRSQIT1 0x01F2 +#define /*01F3*/ ZYDIS_MNEMONIC_PFRSQRT 0x01F3 +#define /*01F4*/ ZYDIS_MNEMONIC_PFSUB 0x01F4 +#define /*01F5*/ ZYDIS_MNEMONIC_PFSUBR 0x01F5 +#define /*01F6*/ ZYDIS_MNEMONIC_PHADDD 0x01F6 +#define /*01F7*/ ZYDIS_MNEMONIC_PHADDSW 0x01F7 +#define /*01F8*/ ZYDIS_MNEMONIC_PHADDW 0x01F8 +#define /*01F9*/ ZYDIS_MNEMONIC_PHMINPOSUW 0x01F9 +#define /*01FA*/ ZYDIS_MNEMONIC_PHSUBD 0x01FA +#define /*01FB*/ ZYDIS_MNEMONIC_PHSUBSW 0x01FB +#define /*01FC*/ ZYDIS_MNEMONIC_PHSUBW 0x01FC +#define /*01FD*/ ZYDIS_MNEMONIC_PI2FD 0x01FD +#define /*01FE*/ ZYDIS_MNEMONIC_PI2FW 0x01FE +#define /*01FF*/ ZYDIS_MNEMONIC_PINSRB 0x01FF +#define /*0200*/ ZYDIS_MNEMONIC_PINSRD 0x0200 +#define /*0201*/ ZYDIS_MNEMONIC_PINSRQ 0x0201 +#define /*0202*/ ZYDIS_MNEMONIC_PINSRW 0x0202 +#define /*0203*/ ZYDIS_MNEMONIC_PMADDUBSW 0x0203 +#define /*0204*/ ZYDIS_MNEMONIC_PMADDWD 0x0204 +#define /*0205*/ ZYDIS_MNEMONIC_PMAXSB 0x0205 +#define /*0206*/ ZYDIS_MNEMONIC_PMAXSD 0x0206 +#define /*0207*/ ZYDIS_MNEMONIC_PMAXSW 0x0207 +#define /*0208*/ ZYDIS_MNEMONIC_PMAXUB 0x0208 +#define /*0209*/ ZYDIS_MNEMONIC_PMAXUD 0x0209 +#define /*020A*/ ZYDIS_MNEMONIC_PMAXUW 0x020A +#define /*020B*/ ZYDIS_MNEMONIC_PMINSB 0x020B +#define /*020C*/ ZYDIS_MNEMONIC_PMINSD 0x020C +#define /*020D*/ ZYDIS_MNEMONIC_PMINSW 0x020D +#define /*020E*/ ZYDIS_MNEMONIC_PMINUB 0x020E +#define /*020F*/ ZYDIS_MNEMONIC_PMINUD 0x020F +#define /*0210*/ ZYDIS_MNEMONIC_PMINUW 0x0210 +#define /*0211*/ ZYDIS_MNEMONIC_PMOVMSKB 0x0211 +#define /*0212*/ ZYDIS_MNEMONIC_PMOVSXBD 0x0212 +#define /*0213*/ ZYDIS_MNEMONIC_PMOVSXBQ 0x0213 +#define /*0214*/ ZYDIS_MNEMONIC_PMOVSXBW 0x0214 +#define /*0215*/ ZYDIS_MNEMONIC_PMOVSXDQ 0x0215 +#define /*0216*/ ZYDIS_MNEMONIC_PMOVSXWD 0x0216 +#define /*0217*/ ZYDIS_MNEMONIC_PMOVSXWQ 0x0217 +#define /*0218*/ ZYDIS_MNEMONIC_PMOVZXBD 0x0218 +#define /*0219*/ ZYDIS_MNEMONIC_PMOVZXBQ 0x0219 +#define /*021A*/ ZYDIS_MNEMONIC_PMOVZXBW 0x021A +#define /*021B*/ ZYDIS_MNEMONIC_PMOVZXDQ 0x021B +#define /*021C*/ ZYDIS_MNEMONIC_PMOVZXWD 0x021C +#define /*021D*/ ZYDIS_MNEMONIC_PMOVZXWQ 0x021D +#define /*021E*/ ZYDIS_MNEMONIC_PMULDQ 0x021E +#define /*021F*/ ZYDIS_MNEMONIC_PMULHRSW 0x021F +#define /*0220*/ ZYDIS_MNEMONIC_PMULHRW 0x0220 +#define /*0221*/ ZYDIS_MNEMONIC_PMULHUW 0x0221 +#define /*0222*/ ZYDIS_MNEMONIC_PMULHW 0x0222 +#define /*0223*/ ZYDIS_MNEMONIC_PMULLD 0x0223 +#define /*0224*/ ZYDIS_MNEMONIC_PMULLW 0x0224 +#define /*0225*/ ZYDIS_MNEMONIC_PMULUDQ 0x0225 +#define /*0226*/ ZYDIS_MNEMONIC_POP 0x0226 +#define /*0227*/ ZYDIS_MNEMONIC_POPAL 0x0227 +#define /*0228*/ ZYDIS_MNEMONIC_POPAW 0x0228 +#define /*0229*/ ZYDIS_MNEMONIC_POPCNT 0x0229 +#define /*022A*/ ZYDIS_MNEMONIC_POPF 0x022A +#define /*022B*/ ZYDIS_MNEMONIC_POPFD 0x022B +#define /*022C*/ ZYDIS_MNEMONIC_POPFQ 0x022C +#define /*022D*/ ZYDIS_MNEMONIC_POR 0x022D +#define /*022E*/ ZYDIS_MNEMONIC_PREFETCH 0x022E +#define /*022F*/ ZYDIS_MNEMONIC_PREFETCHNTA 0x022F +#define /*0230*/ ZYDIS_MNEMONIC_PREFETCHT0 0x0230 +#define /*0231*/ ZYDIS_MNEMONIC_PREFETCHT1 0x0231 +#define /*0232*/ ZYDIS_MNEMONIC_PREFETCHT2 0x0232 +#define /*0233*/ ZYDIS_MNEMONIC_PREFETCHW 0x0233 +#define /*0234*/ ZYDIS_MNEMONIC_PSADBW 0x0234 +#define /*0235*/ ZYDIS_MNEMONIC_PSHUFB 0x0235 +#define /*0236*/ ZYDIS_MNEMONIC_PSHUFD 0x0236 +#define /*0237*/ ZYDIS_MNEMONIC_PSHUFHW 0x0237 +#define /*0238*/ ZYDIS_MNEMONIC_PSHUFLW 0x0238 +#define /*0239*/ ZYDIS_MNEMONIC_PSHUFW 0x0239 +#define /*023A*/ ZYDIS_MNEMONIC_PSIGNB 0x023A +#define /*023B*/ ZYDIS_MNEMONIC_PSIGND 0x023B +#define /*023C*/ ZYDIS_MNEMONIC_PSIGNW 0x023C +#define /*023D*/ ZYDIS_MNEMONIC_PSLLD 0x023D +#define /*023E*/ ZYDIS_MNEMONIC_PSLLDQ 0x023E +#define /*023F*/ ZYDIS_MNEMONIC_PSLLQ 0x023F +#define /*0240*/ ZYDIS_MNEMONIC_PSLLW 0x0240 +#define /*0241*/ ZYDIS_MNEMONIC_PSRAD 0x0241 +#define /*0242*/ ZYDIS_MNEMONIC_PSRAW 0x0242 +#define /*0243*/ ZYDIS_MNEMONIC_PSRLD 0x0243 +#define /*0244*/ ZYDIS_MNEMONIC_PSRLDQ 0x0244 +#define /*0245*/ ZYDIS_MNEMONIC_PSRLQ 0x0245 +#define /*0246*/ ZYDIS_MNEMONIC_PSRLW 0x0246 +#define /*0247*/ ZYDIS_MNEMONIC_PSUBB 0x0247 +#define /*0248*/ ZYDIS_MNEMONIC_PSUBD 0x0248 +#define /*0249*/ ZYDIS_MNEMONIC_PSUBQ 0x0249 +#define /*024A*/ ZYDIS_MNEMONIC_PSUBSB 0x024A +#define /*024B*/ ZYDIS_MNEMONIC_PSUBSW 0x024B +#define /*024C*/ ZYDIS_MNEMONIC_PSUBUSB 0x024C +#define /*024D*/ ZYDIS_MNEMONIC_PSUBUSW 0x024D +#define /*024E*/ ZYDIS_MNEMONIC_PSUBW 0x024E +#define /*024F*/ ZYDIS_MNEMONIC_PSWAPD 0x024F +#define /*0250*/ ZYDIS_MNEMONIC_PTEST 0x0250 +#define /*0251*/ ZYDIS_MNEMONIC_PUNPCKHBW 0x0251 +#define /*0252*/ ZYDIS_MNEMONIC_PUNPCKHDQ 0x0252 +#define /*0253*/ ZYDIS_MNEMONIC_PUNPCKHQDQ 0x0253 +#define /*0254*/ ZYDIS_MNEMONIC_PUNPCKHWD 0x0254 +#define /*0255*/ ZYDIS_MNEMONIC_PUNPCKLBW 0x0255 +#define /*0256*/ ZYDIS_MNEMONIC_PUNPCKLDQ 0x0256 +#define /*0257*/ ZYDIS_MNEMONIC_PUNPCKLQDQ 0x0257 +#define /*0258*/ ZYDIS_MNEMONIC_PUNPCKLWD 0x0258 +#define /*0259*/ ZYDIS_MNEMONIC_PUSH 0x0259 +#define /*025A*/ ZYDIS_MNEMONIC_PUSHAL 0x025A +#define /*025B*/ ZYDIS_MNEMONIC_PUSHAW 0x025B +#define /*025C*/ ZYDIS_MNEMONIC_PUSHF 0x025C +#define /*025D*/ ZYDIS_MNEMONIC_PUSHFD 0x025D +#define /*025E*/ ZYDIS_MNEMONIC_PUSHFQ 0x025E +#define /*025F*/ ZYDIS_MNEMONIC_PXOR 0x025F +#define /*0260*/ ZYDIS_MNEMONIC_RCL 0x0260 +#define /*0261*/ ZYDIS_MNEMONIC_RCPPS 0x0261 +#define /*0262*/ ZYDIS_MNEMONIC_RCPSS 0x0262 +#define /*0263*/ ZYDIS_MNEMONIC_RCR 0x0263 +#define /*0264*/ ZYDIS_MNEMONIC_RDFSBASE 0x0264 +#define /*0265*/ ZYDIS_MNEMONIC_RDGSBASE 0x0265 +#define /*0266*/ ZYDIS_MNEMONIC_RDMSR 0x0266 +#define /*0267*/ ZYDIS_MNEMONIC_RDPKRU 0x0267 +#define /*0268*/ ZYDIS_MNEMONIC_RDPMC 0x0268 +#define /*0269*/ ZYDIS_MNEMONIC_RDRAND 0x0269 +#define /*026A*/ ZYDIS_MNEMONIC_RDSEED 0x026A +#define /*026B*/ ZYDIS_MNEMONIC_RDTSC 0x026B +#define /*026C*/ ZYDIS_MNEMONIC_RDTSCP 0x026C +#define /*026D*/ ZYDIS_MNEMONIC_RET 0x026D +#define /*026E*/ ZYDIS_MNEMONIC_RETF 0x026E +#define /*026F*/ ZYDIS_MNEMONIC_ROL 0x026F +#define /*0270*/ ZYDIS_MNEMONIC_ROR 0x0270 +#define /*0271*/ ZYDIS_MNEMONIC_RORX 0x0271 +#define /*0272*/ ZYDIS_MNEMONIC_ROUNDPD 0x0272 +#define /*0273*/ ZYDIS_MNEMONIC_ROUNDPS 0x0273 +#define /*0274*/ ZYDIS_MNEMONIC_ROUNDSD 0x0274 +#define /*0275*/ ZYDIS_MNEMONIC_ROUNDSS 0x0275 +#define /*0276*/ ZYDIS_MNEMONIC_RSM 0x0276 +#define /*0277*/ ZYDIS_MNEMONIC_RSQRTPS 0x0277 +#define /*0278*/ ZYDIS_MNEMONIC_RSQRTSS 0x0278 +#define /*0279*/ ZYDIS_MNEMONIC_SAHF 0x0279 +#define /*027A*/ ZYDIS_MNEMONIC_SAR 0x027A +#define /*027B*/ ZYDIS_MNEMONIC_SARX 0x027B +#define /*027C*/ ZYDIS_MNEMONIC_SBB 0x027C +#define /*027D*/ ZYDIS_MNEMONIC_SCASB 0x027D +#define /*027E*/ ZYDIS_MNEMONIC_SCASD 0x027E +#define /*027F*/ ZYDIS_MNEMONIC_SCASQ 0x027F +#define /*0280*/ ZYDIS_MNEMONIC_SCASW 0x0280 +#define /*0281*/ ZYDIS_MNEMONIC_SETA 0x0281 +#define /*0282*/ ZYDIS_MNEMONIC_SETAE 0x0282 +#define /*0283*/ ZYDIS_MNEMONIC_SETB 0x0283 +#define /*0284*/ ZYDIS_MNEMONIC_SETBE 0x0284 +#define /*0285*/ ZYDIS_MNEMONIC_SETE 0x0285 +#define /*0286*/ ZYDIS_MNEMONIC_SETG 0x0286 +#define /*0287*/ ZYDIS_MNEMONIC_SETGE 0x0287 +#define /*0288*/ ZYDIS_MNEMONIC_SETL 0x0288 +#define /*0289*/ ZYDIS_MNEMONIC_SETLE 0x0289 +#define /*028A*/ ZYDIS_MNEMONIC_SETNE 0x028A +#define /*028B*/ ZYDIS_MNEMONIC_SETNO 0x028B +#define /*028C*/ ZYDIS_MNEMONIC_SETNP 0x028C +#define /*028D*/ ZYDIS_MNEMONIC_SETNS 0x028D +#define /*028E*/ ZYDIS_MNEMONIC_SETO 0x028E +#define /*028F*/ ZYDIS_MNEMONIC_SETP 0x028F +#define /*0290*/ ZYDIS_MNEMONIC_SETS 0x0290 +#define /*0291*/ ZYDIS_MNEMONIC_SFENCE 0x0291 +#define /*0292*/ ZYDIS_MNEMONIC_SGDT 0x0292 +#define /*0293*/ ZYDIS_MNEMONIC_SHA1MSG1 0x0293 +#define /*0294*/ ZYDIS_MNEMONIC_SHA1MSG2 0x0294 +#define /*0295*/ ZYDIS_MNEMONIC_SHA1NEXTE 0x0295 +#define /*0296*/ ZYDIS_MNEMONIC_SHA1RNDS4 0x0296 +#define /*0297*/ ZYDIS_MNEMONIC_SHA256MSG1 0x0297 +#define /*0298*/ ZYDIS_MNEMONIC_SHA256MSG2 0x0298 +#define /*0299*/ ZYDIS_MNEMONIC_SHA256RNDS2 0x0299 +#define /*029A*/ ZYDIS_MNEMONIC_SHL 0x029A +#define /*029B*/ ZYDIS_MNEMONIC_SHLD 0x029B +#define /*029C*/ ZYDIS_MNEMONIC_SHLX 0x029C +#define /*029D*/ ZYDIS_MNEMONIC_SHR 0x029D +#define /*029E*/ ZYDIS_MNEMONIC_SHRD 0x029E +#define /*029F*/ ZYDIS_MNEMONIC_SHRX 0x029F +#define /*02A0*/ ZYDIS_MNEMONIC_SHUFPD 0x02A0 +#define /*02A1*/ ZYDIS_MNEMONIC_SHUFPS 0x02A1 +#define /*02A2*/ ZYDIS_MNEMONIC_SIDT 0x02A2 +#define /*02A3*/ ZYDIS_MNEMONIC_SKINIT 0x02A3 +#define /*02A4*/ ZYDIS_MNEMONIC_SLDT 0x02A4 +#define /*02A5*/ ZYDIS_MNEMONIC_SMSW 0x02A5 +#define /*02A6*/ ZYDIS_MNEMONIC_SQRTPD 0x02A6 +#define /*02A7*/ ZYDIS_MNEMONIC_SQRTPS 0x02A7 +#define /*02A8*/ ZYDIS_MNEMONIC_SQRTSD 0x02A8 +#define /*02A9*/ ZYDIS_MNEMONIC_SQRTSS 0x02A9 +#define /*02AA*/ ZYDIS_MNEMONIC_STAC 0x02AA +#define /*02AB*/ ZYDIS_MNEMONIC_STC 0x02AB +#define /*02AC*/ ZYDIS_MNEMONIC_STD 0x02AC +#define /*02AD*/ ZYDIS_MNEMONIC_STGI 0x02AD +#define /*02AE*/ ZYDIS_MNEMONIC_STI 0x02AE +#define /*02AF*/ ZYDIS_MNEMONIC_STMXCSR 0x02AF +#define /*02B0*/ ZYDIS_MNEMONIC_STOSB 0x02B0 +#define /*02B1*/ ZYDIS_MNEMONIC_STOSD 0x02B1 +#define /*02B2*/ ZYDIS_MNEMONIC_STOSQ 0x02B2 +#define /*02B3*/ ZYDIS_MNEMONIC_STOSW 0x02B3 +#define /*02B4*/ ZYDIS_MNEMONIC_STR 0x02B4 +#define /*02B5*/ ZYDIS_MNEMONIC_SUB 0x02B5 +#define /*02B6*/ ZYDIS_MNEMONIC_SUBPD 0x02B6 +#define /*02B7*/ ZYDIS_MNEMONIC_SUBPS 0x02B7 +#define /*02B8*/ ZYDIS_MNEMONIC_SUBSD 0x02B8 +#define /*02B9*/ ZYDIS_MNEMONIC_SUBSS 0x02B9 +#define /*02BA*/ ZYDIS_MNEMONIC_SWAPGS 0x02BA +#define /*02BB*/ ZYDIS_MNEMONIC_SYSCALL 0x02BB +#define /*02BC*/ ZYDIS_MNEMONIC_SYSENTER 0x02BC +#define /*02BD*/ ZYDIS_MNEMONIC_SYSEXIT 0x02BD +#define /*02BE*/ ZYDIS_MNEMONIC_SYSRET 0x02BE +#define /*02BF*/ ZYDIS_MNEMONIC_T1MSKC 0x02BF +#define /*02C0*/ ZYDIS_MNEMONIC_TEST 0x02C0 +#define /*02C1*/ ZYDIS_MNEMONIC_TZCNT 0x02C1 +#define /*02C2*/ ZYDIS_MNEMONIC_TZMSK 0x02C2 +#define /*02C3*/ ZYDIS_MNEMONIC_UCOMISD 0x02C3 +#define /*02C4*/ ZYDIS_MNEMONIC_UCOMISS 0x02C4 +#define /*02C5*/ ZYDIS_MNEMONIC_UD0 0x02C5 +#define /*02C6*/ ZYDIS_MNEMONIC_UD1 0x02C6 +#define /*02C7*/ ZYDIS_MNEMONIC_UD2 0x02C7 +#define /*02C8*/ ZYDIS_MNEMONIC_UNPCKHPD 0x02C8 +#define /*02C9*/ ZYDIS_MNEMONIC_UNPCKHPS 0x02C9 +#define /*02CA*/ ZYDIS_MNEMONIC_UNPCKLPD 0x02CA +#define /*02CB*/ ZYDIS_MNEMONIC_UNPCKLPS 0x02CB +#define /*02CC*/ ZYDIS_MNEMONIC_VADDPD 0x02CC +#define /*02CD*/ ZYDIS_MNEMONIC_VADDPS 0x02CD +#define /*02CE*/ ZYDIS_MNEMONIC_VADDSD 0x02CE +#define /*02CF*/ ZYDIS_MNEMONIC_VADDSS 0x02CF +#define /*02D0*/ ZYDIS_MNEMONIC_VADDSUBPD 0x02D0 +#define /*02D1*/ ZYDIS_MNEMONIC_VADDSUBPS 0x02D1 +#define /*02D2*/ ZYDIS_MNEMONIC_VAESDEC 0x02D2 +#define /*02D3*/ ZYDIS_MNEMONIC_VAESDECLAST 0x02D3 +#define /*02D4*/ ZYDIS_MNEMONIC_VAESENC 0x02D4 +#define /*02D5*/ ZYDIS_MNEMONIC_VAESENCLAST 0x02D5 +#define /*02D6*/ ZYDIS_MNEMONIC_VAESIMC 0x02D6 +#define /*02D7*/ ZYDIS_MNEMONIC_VAESKEYGENASSIST 0x02D7 +#define /*02D8*/ ZYDIS_MNEMONIC_VALIGND 0x02D8 +#define /*02D9*/ ZYDIS_MNEMONIC_VALIGNQ 0x02D9 +#define /*02DA*/ ZYDIS_MNEMONIC_VANDNPD 0x02DA +#define /*02DB*/ ZYDIS_MNEMONIC_VANDNPS 0x02DB +#define /*02DC*/ ZYDIS_MNEMONIC_VANDPD 0x02DC +#define /*02DD*/ ZYDIS_MNEMONIC_VANDPS 0x02DD +#define /*02DE*/ ZYDIS_MNEMONIC_VBLENDMPD 0x02DE +#define /*02DF*/ ZYDIS_MNEMONIC_VBLENDMPS 0x02DF +#define /*02E0*/ ZYDIS_MNEMONIC_VBLENDPD 0x02E0 +#define /*02E1*/ ZYDIS_MNEMONIC_VBLENDPS 0x02E1 +#define /*02E2*/ ZYDIS_MNEMONIC_VBLENDVPD 0x02E2 +#define /*02E3*/ ZYDIS_MNEMONIC_VBLENDVPS 0x02E3 +#define /*02E4*/ ZYDIS_MNEMONIC_VBROADCASTF128 0x02E4 +#define /*02E5*/ ZYDIS_MNEMONIC_VBROADCASTF32X2 0x02E5 +#define /*02E6*/ ZYDIS_MNEMONIC_VBROADCASTF32X4 0x02E6 +#define /*02E7*/ ZYDIS_MNEMONIC_VBROADCASTF32X8 0x02E7 +#define /*02E8*/ ZYDIS_MNEMONIC_VBROADCASTF64X2 0x02E8 +#define /*02E9*/ ZYDIS_MNEMONIC_VBROADCASTF64X4 0x02E9 +#define /*02EA*/ ZYDIS_MNEMONIC_VBROADCASTI128 0x02EA +#define /*02EB*/ ZYDIS_MNEMONIC_VBROADCASTI32X2 0x02EB +#define /*02EC*/ ZYDIS_MNEMONIC_VBROADCASTI32X4 0x02EC +#define /*02ED*/ ZYDIS_MNEMONIC_VBROADCASTI32X8 0x02ED +#define /*02EE*/ ZYDIS_MNEMONIC_VBROADCASTI64X2 0x02EE +#define /*02EF*/ ZYDIS_MNEMONIC_VBROADCASTI64X4 0x02EF +#define /*02F0*/ ZYDIS_MNEMONIC_VBROADCASTSD 0x02F0 +#define /*02F1*/ ZYDIS_MNEMONIC_VBROADCASTSS 0x02F1 +#define /*02F2*/ ZYDIS_MNEMONIC_VCMPPD 0x02F2 +#define /*02F3*/ ZYDIS_MNEMONIC_VCMPPS 0x02F3 +#define /*02F4*/ ZYDIS_MNEMONIC_VCMPSD 0x02F4 +#define /*02F5*/ ZYDIS_MNEMONIC_VCMPSS 0x02F5 +#define /*02F6*/ ZYDIS_MNEMONIC_VCOMISD 0x02F6 +#define /*02F7*/ ZYDIS_MNEMONIC_VCOMISS 0x02F7 +#define /*02F8*/ ZYDIS_MNEMONIC_VCOMPRESSPD 0x02F8 +#define /*02F9*/ ZYDIS_MNEMONIC_VCOMPRESSPS 0x02F9 +#define /*02FA*/ ZYDIS_MNEMONIC_VCVTDQ2PD 0x02FA +#define /*02FB*/ ZYDIS_MNEMONIC_VCVTDQ2PS 0x02FB +#define /*02FC*/ ZYDIS_MNEMONIC_VCVTPD2DQ 0x02FC +#define /*02FD*/ ZYDIS_MNEMONIC_VCVTPD2PS 0x02FD +#define /*02FE*/ ZYDIS_MNEMONIC_VCVTPD2QQ 0x02FE +#define /*02FF*/ ZYDIS_MNEMONIC_VCVTPD2UDQ 0x02FF +#define /*0300*/ ZYDIS_MNEMONIC_VCVTPD2UQQ 0x0300 +#define /*0301*/ ZYDIS_MNEMONIC_VCVTPH2PS 0x0301 +#define /*0302*/ ZYDIS_MNEMONIC_VCVTPS2DQ 0x0302 +#define /*0303*/ ZYDIS_MNEMONIC_VCVTPS2PD 0x0303 +#define /*0304*/ ZYDIS_MNEMONIC_VCVTPS2PH 0x0304 +#define /*0305*/ ZYDIS_MNEMONIC_VCVTPS2QQ 0x0305 +#define /*0306*/ ZYDIS_MNEMONIC_VCVTPS2UDQ 0x0306 +#define /*0307*/ ZYDIS_MNEMONIC_VCVTPS2UQQ 0x0307 +#define /*0308*/ ZYDIS_MNEMONIC_VCVTQQ2PD 0x0308 +#define /*0309*/ ZYDIS_MNEMONIC_VCVTQQ2PS 0x0309 +#define /*030A*/ ZYDIS_MNEMONIC_VCVTSD2SI 0x030A +#define /*030B*/ ZYDIS_MNEMONIC_VCVTSD2SS 0x030B +#define /*030C*/ ZYDIS_MNEMONIC_VCVTSD2USI 0x030C +#define /*030D*/ ZYDIS_MNEMONIC_VCVTSI2SD 0x030D +#define /*030E*/ ZYDIS_MNEMONIC_VCVTSI2SS 0x030E +#define /*030F*/ ZYDIS_MNEMONIC_VCVTSS2SD 0x030F +#define /*0310*/ ZYDIS_MNEMONIC_VCVTSS2SI 0x0310 +#define /*0311*/ ZYDIS_MNEMONIC_VCVTSS2USI 0x0311 +#define /*0312*/ ZYDIS_MNEMONIC_VCVTTPD2DQ 0x0312 +#define /*0313*/ ZYDIS_MNEMONIC_VCVTTPD2QQ 0x0313 +#define /*0314*/ ZYDIS_MNEMONIC_VCVTTPD2UDQ 0x0314 +#define /*0315*/ ZYDIS_MNEMONIC_VCVTTPD2UQQ 0x0315 +#define /*0316*/ ZYDIS_MNEMONIC_VCVTTPS2DQ 0x0316 +#define /*0317*/ ZYDIS_MNEMONIC_VCVTTPS2QQ 0x0317 +#define /*0318*/ ZYDIS_MNEMONIC_VCVTTPS2UDQ 0x0318 +#define /*0319*/ ZYDIS_MNEMONIC_VCVTTPS2UQQ 0x0319 +#define /*031A*/ ZYDIS_MNEMONIC_VCVTTSD2SI 0x031A +#define /*031B*/ ZYDIS_MNEMONIC_VCVTTSD2USI 0x031B +#define /*031C*/ ZYDIS_MNEMONIC_VCVTTSS2SI 0x031C +#define /*031D*/ ZYDIS_MNEMONIC_VCVTTSS2USI 0x031D +#define /*031E*/ ZYDIS_MNEMONIC_VCVTUDQ2PD 0x031E +#define /*031F*/ ZYDIS_MNEMONIC_VCVTUDQ2PS 0x031F +#define /*0320*/ ZYDIS_MNEMONIC_VCVTUQQ2PD 0x0320 +#define /*0321*/ ZYDIS_MNEMONIC_VCVTUQQ2PS 0x0321 +#define /*0322*/ ZYDIS_MNEMONIC_VCVTUSI2SD 0x0322 +#define /*0323*/ ZYDIS_MNEMONIC_VCVTUSI2SS 0x0323 +#define /*0324*/ ZYDIS_MNEMONIC_VDBPSADBW 0x0324 +#define /*0325*/ ZYDIS_MNEMONIC_VDIVPD 0x0325 +#define /*0326*/ ZYDIS_MNEMONIC_VDIVPS 0x0326 +#define /*0327*/ ZYDIS_MNEMONIC_VDIVSD 0x0327 +#define /*0328*/ ZYDIS_MNEMONIC_VDIVSS 0x0328 +#define /*0329*/ ZYDIS_MNEMONIC_VDPPD 0x0329 +#define /*032A*/ ZYDIS_MNEMONIC_VDPPS 0x032A +#define /*032B*/ ZYDIS_MNEMONIC_VERR 0x032B +#define /*032C*/ ZYDIS_MNEMONIC_VERW 0x032C +#define /*032D*/ ZYDIS_MNEMONIC_VEXP2PD 0x032D +#define /*032E*/ ZYDIS_MNEMONIC_VEXP2PS 0x032E +#define /*032F*/ ZYDIS_MNEMONIC_VEXPANDPD 0x032F +#define /*0330*/ ZYDIS_MNEMONIC_VEXPANDPS 0x0330 +#define /*0331*/ ZYDIS_MNEMONIC_VEXTRACTF128 0x0331 +#define /*0332*/ ZYDIS_MNEMONIC_VEXTRACTF32X4 0x0332 +#define /*0333*/ ZYDIS_MNEMONIC_VEXTRACTF32X8 0x0333 +#define /*0334*/ ZYDIS_MNEMONIC_VEXTRACTF64X2 0x0334 +#define /*0335*/ ZYDIS_MNEMONIC_VEXTRACTF64X4 0x0335 +#define /*0336*/ ZYDIS_MNEMONIC_VEXTRACTI128 0x0336 +#define /*0337*/ ZYDIS_MNEMONIC_VEXTRACTI32X4 0x0337 +#define /*0338*/ ZYDIS_MNEMONIC_VEXTRACTI32X8 0x0338 +#define /*0339*/ ZYDIS_MNEMONIC_VEXTRACTI64X2 0x0339 +#define /*033A*/ ZYDIS_MNEMONIC_VEXTRACTI64X4 0x033A +#define /*033B*/ ZYDIS_MNEMONIC_VEXTRACTPS 0x033B +#define /*033C*/ ZYDIS_MNEMONIC_VFIXUPIMMPD 0x033C +#define /*033D*/ ZYDIS_MNEMONIC_VFIXUPIMMPS 0x033D +#define /*033E*/ ZYDIS_MNEMONIC_VFIXUPIMMSD 0x033E +#define /*033F*/ ZYDIS_MNEMONIC_VFIXUPIMMSS 0x033F +#define /*0340*/ ZYDIS_MNEMONIC_VFMADD132PD 0x0340 +#define /*0341*/ ZYDIS_MNEMONIC_VFMADD132PS 0x0341 +#define /*0342*/ ZYDIS_MNEMONIC_VFMADD132SD 0x0342 +#define /*0343*/ ZYDIS_MNEMONIC_VFMADD132SS 0x0343 +#define /*0344*/ ZYDIS_MNEMONIC_VFMADD213PD 0x0344 +#define /*0345*/ ZYDIS_MNEMONIC_VFMADD213PS 0x0345 +#define /*0346*/ ZYDIS_MNEMONIC_VFMADD213SD 0x0346 +#define /*0347*/ ZYDIS_MNEMONIC_VFMADD213SS 0x0347 +#define /*0348*/ ZYDIS_MNEMONIC_VFMADD231PD 0x0348 +#define /*0349*/ ZYDIS_MNEMONIC_VFMADD231PS 0x0349 +#define /*034A*/ ZYDIS_MNEMONIC_VFMADD231SD 0x034A +#define /*034B*/ ZYDIS_MNEMONIC_VFMADD231SS 0x034B +#define /*034C*/ ZYDIS_MNEMONIC_VFMADDPD 0x034C +#define /*034D*/ ZYDIS_MNEMONIC_VFMADDPS 0x034D +#define /*034E*/ ZYDIS_MNEMONIC_VFMADDSD 0x034E +#define /*034F*/ ZYDIS_MNEMONIC_VFMADDSS 0x034F +#define /*0350*/ ZYDIS_MNEMONIC_VFMADDSUB132PD 0x0350 +#define /*0351*/ ZYDIS_MNEMONIC_VFMADDSUB132PS 0x0351 +#define /*0352*/ ZYDIS_MNEMONIC_VFMADDSUB213PD 0x0352 +#define /*0353*/ ZYDIS_MNEMONIC_VFMADDSUB213PS 0x0353 +#define /*0354*/ ZYDIS_MNEMONIC_VFMADDSUB231PD 0x0354 +#define /*0355*/ ZYDIS_MNEMONIC_VFMADDSUB231PS 0x0355 +#define /*0356*/ ZYDIS_MNEMONIC_VFMADDSUBPD 0x0356 +#define /*0357*/ ZYDIS_MNEMONIC_VFMADDSUBPS 0x0357 +#define /*0358*/ ZYDIS_MNEMONIC_VFMSUB132PD 0x0358 +#define /*0359*/ ZYDIS_MNEMONIC_VFMSUB132PS 0x0359 +#define /*035A*/ ZYDIS_MNEMONIC_VFMSUB132SD 0x035A +#define /*035B*/ ZYDIS_MNEMONIC_VFMSUB132SS 0x035B +#define /*035C*/ ZYDIS_MNEMONIC_VFMSUB213PD 0x035C +#define /*035D*/ ZYDIS_MNEMONIC_VFMSUB213PS 0x035D +#define /*035E*/ ZYDIS_MNEMONIC_VFMSUB213SD 0x035E +#define /*035F*/ ZYDIS_MNEMONIC_VFMSUB213SS 0x035F +#define /*0360*/ ZYDIS_MNEMONIC_VFMSUB231PD 0x0360 +#define /*0361*/ ZYDIS_MNEMONIC_VFMSUB231PS 0x0361 +#define /*0362*/ ZYDIS_MNEMONIC_VFMSUB231SD 0x0362 +#define /*0363*/ ZYDIS_MNEMONIC_VFMSUB231SS 0x0363 +#define /*0364*/ ZYDIS_MNEMONIC_VFMSUBADD132PD 0x0364 +#define /*0365*/ ZYDIS_MNEMONIC_VFMSUBADD132PS 0x0365 +#define /*0366*/ ZYDIS_MNEMONIC_VFMSUBADD213PD 0x0366 +#define /*0367*/ ZYDIS_MNEMONIC_VFMSUBADD213PS 0x0367 +#define /*0368*/ ZYDIS_MNEMONIC_VFMSUBADD231PD 0x0368 +#define /*0369*/ ZYDIS_MNEMONIC_VFMSUBADD231PS 0x0369 +#define /*036A*/ ZYDIS_MNEMONIC_VFMSUBADDPD 0x036A +#define /*036B*/ ZYDIS_MNEMONIC_VFMSUBADDPS 0x036B +#define /*036C*/ ZYDIS_MNEMONIC_VFMSUBPD 0x036C +#define /*036D*/ ZYDIS_MNEMONIC_VFMSUBPS 0x036D +#define /*036E*/ ZYDIS_MNEMONIC_VFMSUBSD 0x036E +#define /*036F*/ ZYDIS_MNEMONIC_VFMSUBSS 0x036F +#define /*0370*/ ZYDIS_MNEMONIC_VFNMADD132PD 0x0370 +#define /*0371*/ ZYDIS_MNEMONIC_VFNMADD132PS 0x0371 +#define /*0372*/ ZYDIS_MNEMONIC_VFNMADD132SD 0x0372 +#define /*0373*/ ZYDIS_MNEMONIC_VFNMADD132SS 0x0373 +#define /*0374*/ ZYDIS_MNEMONIC_VFNMADD213PD 0x0374 +#define /*0375*/ ZYDIS_MNEMONIC_VFNMADD213PS 0x0375 +#define /*0376*/ ZYDIS_MNEMONIC_VFNMADD213SD 0x0376 +#define /*0377*/ ZYDIS_MNEMONIC_VFNMADD213SS 0x0377 +#define /*0378*/ ZYDIS_MNEMONIC_VFNMADD231PD 0x0378 +#define /*0379*/ ZYDIS_MNEMONIC_VFNMADD231PS 0x0379 +#define /*037A*/ ZYDIS_MNEMONIC_VFNMADD231SD 0x037A +#define /*037B*/ ZYDIS_MNEMONIC_VFNMADD231SS 0x037B +#define /*037C*/ ZYDIS_MNEMONIC_VFNMADDPD 0x037C +#define /*037D*/ ZYDIS_MNEMONIC_VFNMADDPS 0x037D +#define /*037E*/ ZYDIS_MNEMONIC_VFNMADDSD 0x037E +#define /*037F*/ ZYDIS_MNEMONIC_VFNMADDSS 0x037F +#define /*0380*/ ZYDIS_MNEMONIC_VFNMSUB132PD 0x0380 +#define /*0381*/ ZYDIS_MNEMONIC_VFNMSUB132PS 0x0381 +#define /*0382*/ ZYDIS_MNEMONIC_VFNMSUB132SD 0x0382 +#define /*0383*/ ZYDIS_MNEMONIC_VFNMSUB132SS 0x0383 +#define /*0384*/ ZYDIS_MNEMONIC_VFNMSUB213PD 0x0384 +#define /*0385*/ ZYDIS_MNEMONIC_VFNMSUB213PS 0x0385 +#define /*0386*/ ZYDIS_MNEMONIC_VFNMSUB213SD 0x0386 +#define /*0387*/ ZYDIS_MNEMONIC_VFNMSUB213SS 0x0387 +#define /*0388*/ ZYDIS_MNEMONIC_VFNMSUB231PD 0x0388 +#define /*0389*/ ZYDIS_MNEMONIC_VFNMSUB231PS 0x0389 +#define /*038A*/ ZYDIS_MNEMONIC_VFNMSUB231SD 0x038A +#define /*038B*/ ZYDIS_MNEMONIC_VFNMSUB231SS 0x038B +#define /*038C*/ ZYDIS_MNEMONIC_VFNMSUBPD 0x038C +#define /*038D*/ ZYDIS_MNEMONIC_VFNMSUBPS 0x038D +#define /*038E*/ ZYDIS_MNEMONIC_VFNMSUBSD 0x038E +#define /*038F*/ ZYDIS_MNEMONIC_VFNMSUBSS 0x038F +#define /*0390*/ ZYDIS_MNEMONIC_VFPCLASSPD 0x0390 +#define /*0391*/ ZYDIS_MNEMONIC_VFPCLASSPS 0x0391 +#define /*0392*/ ZYDIS_MNEMONIC_VFPCLASSSD 0x0392 +#define /*0393*/ ZYDIS_MNEMONIC_VFPCLASSSS 0x0393 +#define /*0394*/ ZYDIS_MNEMONIC_VFRCZPD 0x0394 +#define /*0395*/ ZYDIS_MNEMONIC_VFRCZPS 0x0395 +#define /*0396*/ ZYDIS_MNEMONIC_VFRCZSD 0x0396 +#define /*0397*/ ZYDIS_MNEMONIC_VFRCZSS 0x0397 +#define /*0398*/ ZYDIS_MNEMONIC_VGATHERDPD 0x0398 +#define /*0399*/ ZYDIS_MNEMONIC_VGATHERDPS 0x0399 +#define /*039A*/ ZYDIS_MNEMONIC_VGATHERPF0DPD 0x039A +#define /*039B*/ ZYDIS_MNEMONIC_VGATHERPF0DPS 0x039B +#define /*039C*/ ZYDIS_MNEMONIC_VGATHERPF0QPD 0x039C +#define /*039D*/ ZYDIS_MNEMONIC_VGATHERPF0QPS 0x039D +#define /*039E*/ ZYDIS_MNEMONIC_VGATHERPF1DPD 0x039E +#define /*039F*/ ZYDIS_MNEMONIC_VGATHERPF1DPS 0x039F +#define /*03A0*/ ZYDIS_MNEMONIC_VGATHERPF1QPD 0x03A0 +#define /*03A1*/ ZYDIS_MNEMONIC_VGATHERPF1QPS 0x03A1 +#define /*03A2*/ ZYDIS_MNEMONIC_VGATHERQPD 0x03A2 +#define /*03A3*/ ZYDIS_MNEMONIC_VGATHERQPS 0x03A3 +#define /*03A4*/ ZYDIS_MNEMONIC_VGETEXPPD 0x03A4 +#define /*03A5*/ ZYDIS_MNEMONIC_VGETEXPPS 0x03A5 +#define /*03A6*/ ZYDIS_MNEMONIC_VGETEXPSD 0x03A6 +#define /*03A7*/ ZYDIS_MNEMONIC_VGETEXPSS 0x03A7 +#define /*03A8*/ ZYDIS_MNEMONIC_VGETMANTPD 0x03A8 +#define /*03A9*/ ZYDIS_MNEMONIC_VGETMANTPS 0x03A9 +#define /*03AA*/ ZYDIS_MNEMONIC_VGETMANTSD 0x03AA +#define /*03AB*/ ZYDIS_MNEMONIC_VGETMANTSS 0x03AB +#define /*03AC*/ ZYDIS_MNEMONIC_VHADDPD 0x03AC +#define /*03AD*/ ZYDIS_MNEMONIC_VHADDPS 0x03AD +#define /*03AE*/ ZYDIS_MNEMONIC_VHSUBPD 0x03AE +#define /*03AF*/ ZYDIS_MNEMONIC_VHSUBPS 0x03AF +#define /*03B0*/ ZYDIS_MNEMONIC_VINSERTF128 0x03B0 +#define /*03B1*/ ZYDIS_MNEMONIC_VINSERTF32X4 0x03B1 +#define /*03B2*/ ZYDIS_MNEMONIC_VINSERTF32X8 0x03B2 +#define /*03B3*/ ZYDIS_MNEMONIC_VINSERTF64X2 0x03B3 +#define /*03B4*/ ZYDIS_MNEMONIC_VINSERTF64X4 0x03B4 +#define /*03B5*/ ZYDIS_MNEMONIC_VINSERTI128 0x03B5 +#define /*03B6*/ ZYDIS_MNEMONIC_VINSERTI32X4 0x03B6 +#define /*03B7*/ ZYDIS_MNEMONIC_VINSERTI32X8 0x03B7 +#define /*03B8*/ ZYDIS_MNEMONIC_VINSERTI64X2 0x03B8 +#define /*03B9*/ ZYDIS_MNEMONIC_VINSERTI64X4 0x03B9 +#define /*03BA*/ ZYDIS_MNEMONIC_VINSERTPS 0x03BA +#define /*03BB*/ ZYDIS_MNEMONIC_VLDDQU 0x03BB +#define /*03BC*/ ZYDIS_MNEMONIC_VLDMXCSR 0x03BC +#define /*03BD*/ ZYDIS_MNEMONIC_VMASKMOVDQU 0x03BD +#define /*03BE*/ ZYDIS_MNEMONIC_VMASKMOVPD 0x03BE +#define /*03BF*/ ZYDIS_MNEMONIC_VMASKMOVPS 0x03BF +#define /*03C0*/ ZYDIS_MNEMONIC_VMAXPD 0x03C0 +#define /*03C1*/ ZYDIS_MNEMONIC_VMAXPS 0x03C1 +#define /*03C2*/ ZYDIS_MNEMONIC_VMAXSD 0x03C2 +#define /*03C3*/ ZYDIS_MNEMONIC_VMAXSS 0x03C3 +#define /*03C4*/ ZYDIS_MNEMONIC_VMCALL 0x03C4 +#define /*03C5*/ ZYDIS_MNEMONIC_VMCLEAR 0x03C5 +#define /*03C6*/ ZYDIS_MNEMONIC_VMFUNC 0x03C6 +#define /*03C7*/ ZYDIS_MNEMONIC_VMINPD 0x03C7 +#define /*03C8*/ ZYDIS_MNEMONIC_VMINPS 0x03C8 +#define /*03C9*/ ZYDIS_MNEMONIC_VMINSD 0x03C9 +#define /*03CA*/ ZYDIS_MNEMONIC_VMINSS 0x03CA +#define /*03CB*/ ZYDIS_MNEMONIC_VMLAUNCH 0x03CB +#define /*03CC*/ ZYDIS_MNEMONIC_VMLOAD 0x03CC +#define /*03CD*/ ZYDIS_MNEMONIC_VMMCALL 0x03CD +#define /*03CE*/ ZYDIS_MNEMONIC_VMOVAPD 0x03CE +#define /*03CF*/ ZYDIS_MNEMONIC_VMOVAPS 0x03CF +#define /*03D0*/ ZYDIS_MNEMONIC_VMOVD 0x03D0 +#define /*03D1*/ ZYDIS_MNEMONIC_VMOVDDUP 0x03D1 +#define /*03D2*/ ZYDIS_MNEMONIC_VMOVDQA 0x03D2 +#define /*03D3*/ ZYDIS_MNEMONIC_VMOVDQA32 0x03D3 +#define /*03D4*/ ZYDIS_MNEMONIC_VMOVDQA64 0x03D4 +#define /*03D5*/ ZYDIS_MNEMONIC_VMOVDQU 0x03D5 +#define /*03D6*/ ZYDIS_MNEMONIC_VMOVDQU16 0x03D6 +#define /*03D7*/ ZYDIS_MNEMONIC_VMOVDQU32 0x03D7 +#define /*03D8*/ ZYDIS_MNEMONIC_VMOVDQU64 0x03D8 +#define /*03D9*/ ZYDIS_MNEMONIC_VMOVDQU8 0x03D9 +#define /*03DA*/ ZYDIS_MNEMONIC_VMOVHLPS 0x03DA +#define /*03DB*/ ZYDIS_MNEMONIC_VMOVHPD 0x03DB +#define /*03DC*/ ZYDIS_MNEMONIC_VMOVHPS 0x03DC +#define /*03DD*/ ZYDIS_MNEMONIC_VMOVLHPS 0x03DD +#define /*03DE*/ ZYDIS_MNEMONIC_VMOVLPD 0x03DE +#define /*03DF*/ ZYDIS_MNEMONIC_VMOVLPS 0x03DF +#define /*03E0*/ ZYDIS_MNEMONIC_VMOVMSKPD 0x03E0 +#define /*03E1*/ ZYDIS_MNEMONIC_VMOVMSKPS 0x03E1 +#define /*03E2*/ ZYDIS_MNEMONIC_VMOVNTDQ 0x03E2 +#define /*03E3*/ ZYDIS_MNEMONIC_VMOVNTDQA 0x03E3 +#define /*03E4*/ ZYDIS_MNEMONIC_VMOVNTPD 0x03E4 +#define /*03E5*/ ZYDIS_MNEMONIC_VMOVNTPS 0x03E5 +#define /*03E6*/ ZYDIS_MNEMONIC_VMOVQ 0x03E6 +#define /*03E7*/ ZYDIS_MNEMONIC_VMOVSD 0x03E7 +#define /*03E8*/ ZYDIS_MNEMONIC_VMOVSHDUP 0x03E8 +#define /*03E9*/ ZYDIS_MNEMONIC_VMOVSLDUP 0x03E9 +#define /*03EA*/ ZYDIS_MNEMONIC_VMOVSS 0x03EA +#define /*03EB*/ ZYDIS_MNEMONIC_VMOVUPD 0x03EB +#define /*03EC*/ ZYDIS_MNEMONIC_VMOVUPS 0x03EC +#define /*03ED*/ ZYDIS_MNEMONIC_VMPSADBW 0x03ED +#define /*03EE*/ ZYDIS_MNEMONIC_VMPTRLD 0x03EE +#define /*03EF*/ ZYDIS_MNEMONIC_VMPTRST 0x03EF +#define /*03F0*/ ZYDIS_MNEMONIC_VMREAD 0x03F0 +#define /*03F1*/ ZYDIS_MNEMONIC_VMRESUME 0x03F1 +#define /*03F2*/ ZYDIS_MNEMONIC_VMRUN 0x03F2 +#define /*03F3*/ ZYDIS_MNEMONIC_VMSAVE 0x03F3 +#define /*03F4*/ ZYDIS_MNEMONIC_VMULPD 0x03F4 +#define /*03F5*/ ZYDIS_MNEMONIC_VMULPS 0x03F5 +#define /*03F6*/ ZYDIS_MNEMONIC_VMULSD 0x03F6 +#define /*03F7*/ ZYDIS_MNEMONIC_VMULSS 0x03F7 +#define /*03F8*/ ZYDIS_MNEMONIC_VMWRITE 0x03F8 +#define /*03F9*/ ZYDIS_MNEMONIC_VMXOFF 0x03F9 +#define /*03FA*/ ZYDIS_MNEMONIC_VMXON 0x03FA +#define /*03FB*/ ZYDIS_MNEMONIC_VORPD 0x03FB +#define /*03FC*/ ZYDIS_MNEMONIC_VORPS 0x03FC +#define /*03FD*/ ZYDIS_MNEMONIC_VPABSB 0x03FD +#define /*03FE*/ ZYDIS_MNEMONIC_VPABSD 0x03FE +#define /*03FF*/ ZYDIS_MNEMONIC_VPABSQ 0x03FF +#define /*0400*/ ZYDIS_MNEMONIC_VPABSW 0x0400 +#define /*0401*/ ZYDIS_MNEMONIC_VPACKSSDW 0x0401 +#define /*0402*/ ZYDIS_MNEMONIC_VPACKSSWB 0x0402 +#define /*0403*/ ZYDIS_MNEMONIC_VPACKUSDW 0x0403 +#define /*0404*/ ZYDIS_MNEMONIC_VPACKUSWB 0x0404 +#define /*0405*/ ZYDIS_MNEMONIC_VPADDB 0x0405 +#define /*0406*/ ZYDIS_MNEMONIC_VPADDD 0x0406 +#define /*0407*/ ZYDIS_MNEMONIC_VPADDQ 0x0407 +#define /*0408*/ ZYDIS_MNEMONIC_VPADDSB 0x0408 +#define /*0409*/ ZYDIS_MNEMONIC_VPADDSW 0x0409 +#define /*040A*/ ZYDIS_MNEMONIC_VPADDUSB 0x040A +#define /*040B*/ ZYDIS_MNEMONIC_VPADDUSW 0x040B +#define /*040C*/ ZYDIS_MNEMONIC_VPADDW 0x040C +#define /*040D*/ ZYDIS_MNEMONIC_VPALIGNR 0x040D +#define /*040E*/ ZYDIS_MNEMONIC_VPAND 0x040E +#define /*040F*/ ZYDIS_MNEMONIC_VPANDD 0x040F +#define /*0410*/ ZYDIS_MNEMONIC_VPANDN 0x0410 +#define /*0411*/ ZYDIS_MNEMONIC_VPANDND 0x0411 +#define /*0412*/ ZYDIS_MNEMONIC_VPANDNQ 0x0412 +#define /*0413*/ ZYDIS_MNEMONIC_VPANDQ 0x0413 +#define /*0414*/ ZYDIS_MNEMONIC_VPAVGB 0x0414 +#define /*0415*/ ZYDIS_MNEMONIC_VPAVGW 0x0415 +#define /*0416*/ ZYDIS_MNEMONIC_VPBLENDD 0x0416 +#define /*0417*/ ZYDIS_MNEMONIC_VPBLENDMB 0x0417 +#define /*0418*/ ZYDIS_MNEMONIC_VPBLENDMD 0x0418 +#define /*0419*/ ZYDIS_MNEMONIC_VPBLENDMQ 0x0419 +#define /*041A*/ ZYDIS_MNEMONIC_VPBLENDMW 0x041A +#define /*041B*/ ZYDIS_MNEMONIC_VPBLENDVB 0x041B +#define /*041C*/ ZYDIS_MNEMONIC_VPBLENDW 0x041C +#define /*041D*/ ZYDIS_MNEMONIC_VPBROADCASTB 0x041D +#define /*041E*/ ZYDIS_MNEMONIC_VPBROADCASTD 0x041E +#define /*041F*/ ZYDIS_MNEMONIC_VPBROADCASTMB2Q 0x041F +#define /*0420*/ ZYDIS_MNEMONIC_VPBROADCASTMW2D 0x0420 +#define /*0421*/ ZYDIS_MNEMONIC_VPBROADCASTQ 0x0421 +#define /*0422*/ ZYDIS_MNEMONIC_VPBROADCASTW 0x0422 +#define /*0423*/ ZYDIS_MNEMONIC_VPCLMULQDQ 0x0423 +#define /*0424*/ ZYDIS_MNEMONIC_VPCMOV 0x0424 +#define /*0425*/ ZYDIS_MNEMONIC_VPCMPB 0x0425 +#define /*0426*/ ZYDIS_MNEMONIC_VPCMPD 0x0426 +#define /*0427*/ ZYDIS_MNEMONIC_VPCMPEQB 0x0427 +#define /*0428*/ ZYDIS_MNEMONIC_VPCMPEQD 0x0428 +#define /*0429*/ ZYDIS_MNEMONIC_VPCMPEQQ 0x0429 +#define /*042A*/ ZYDIS_MNEMONIC_VPCMPEQW 0x042A +#define /*042B*/ ZYDIS_MNEMONIC_VPCMPESTRI 0x042B +#define /*042C*/ ZYDIS_MNEMONIC_VPCMPESTRM 0x042C +#define /*042D*/ ZYDIS_MNEMONIC_VPCMPGTB 0x042D +#define /*042E*/ ZYDIS_MNEMONIC_VPCMPGTD 0x042E +#define /*042F*/ ZYDIS_MNEMONIC_VPCMPGTQ 0x042F +#define /*0430*/ ZYDIS_MNEMONIC_VPCMPGTW 0x0430 +#define /*0431*/ ZYDIS_MNEMONIC_VPCMPISTRI 0x0431 +#define /*0432*/ ZYDIS_MNEMONIC_VPCMPISTRM 0x0432 +#define /*0433*/ ZYDIS_MNEMONIC_VPCMPQ 0x0433 +#define /*0434*/ ZYDIS_MNEMONIC_VPCMPUB 0x0434 +#define /*0435*/ ZYDIS_MNEMONIC_VPCMPUD 0x0435 +#define /*0436*/ ZYDIS_MNEMONIC_VPCMPUQ 0x0436 +#define /*0437*/ ZYDIS_MNEMONIC_VPCMPUW 0x0437 +#define /*0438*/ ZYDIS_MNEMONIC_VPCMPW 0x0438 +#define /*0439*/ ZYDIS_MNEMONIC_VPCOMB 0x0439 +#define /*043A*/ ZYDIS_MNEMONIC_VPCOMD 0x043A +#define /*043B*/ ZYDIS_MNEMONIC_VPCOMPRESSD 0x043B +#define /*043C*/ ZYDIS_MNEMONIC_VPCOMPRESSQ 0x043C +#define /*043D*/ ZYDIS_MNEMONIC_VPCOMQ 0x043D +#define /*043E*/ ZYDIS_MNEMONIC_VPCOMUB 0x043E +#define /*043F*/ ZYDIS_MNEMONIC_VPCOMUD 0x043F +#define /*0440*/ ZYDIS_MNEMONIC_VPCOMUQ 0x0440 +#define /*0441*/ ZYDIS_MNEMONIC_VPCOMUW 0x0441 +#define /*0442*/ ZYDIS_MNEMONIC_VPCOMW 0x0442 +#define /*0443*/ ZYDIS_MNEMONIC_VPCONFLICTD 0x0443 +#define /*0444*/ ZYDIS_MNEMONIC_VPCONFLICTQ 0x0444 +#define /*0445*/ ZYDIS_MNEMONIC_VPERM2F128 0x0445 +#define /*0446*/ ZYDIS_MNEMONIC_VPERM2I128 0x0446 +#define /*0447*/ ZYDIS_MNEMONIC_VPERMB 0x0447 +#define /*0448*/ ZYDIS_MNEMONIC_VPERMD 0x0448 +#define /*0449*/ ZYDIS_MNEMONIC_VPERMI2B 0x0449 +#define /*044A*/ ZYDIS_MNEMONIC_VPERMI2D 0x044A +#define /*044B*/ ZYDIS_MNEMONIC_VPERMI2PD 0x044B +#define /*044C*/ ZYDIS_MNEMONIC_VPERMI2PS 0x044C +#define /*044D*/ ZYDIS_MNEMONIC_VPERMI2Q 0x044D +#define /*044E*/ ZYDIS_MNEMONIC_VPERMI2W 0x044E +#define /*044F*/ ZYDIS_MNEMONIC_VPERMIL2PD 0x044F +#define /*0450*/ ZYDIS_MNEMONIC_VPERMIL2PS 0x0450 +#define /*0451*/ ZYDIS_MNEMONIC_VPERMILPD 0x0451 +#define /*0452*/ ZYDIS_MNEMONIC_VPERMILPS 0x0452 +#define /*0453*/ ZYDIS_MNEMONIC_VPERMPD 0x0453 +#define /*0454*/ ZYDIS_MNEMONIC_VPERMPS 0x0454 +#define /*0455*/ ZYDIS_MNEMONIC_VPERMQ 0x0455 +#define /*0456*/ ZYDIS_MNEMONIC_VPERMT2B 0x0456 +#define /*0457*/ ZYDIS_MNEMONIC_VPERMT2D 0x0457 +#define /*0458*/ ZYDIS_MNEMONIC_VPERMT2PD 0x0458 +#define /*0459*/ ZYDIS_MNEMONIC_VPERMT2PS 0x0459 +#define /*045A*/ ZYDIS_MNEMONIC_VPERMT2Q 0x045A +#define /*045B*/ ZYDIS_MNEMONIC_VPERMT2W 0x045B +#define /*045C*/ ZYDIS_MNEMONIC_VPERMW 0x045C +#define /*045D*/ ZYDIS_MNEMONIC_VPEXPANDD 0x045D +#define /*045E*/ ZYDIS_MNEMONIC_VPEXPANDQ 0x045E +#define /*045F*/ ZYDIS_MNEMONIC_VPEXTRB 0x045F +#define /*0460*/ ZYDIS_MNEMONIC_VPEXTRD 0x0460 +#define /*0461*/ ZYDIS_MNEMONIC_VPEXTRQ 0x0461 +#define /*0462*/ ZYDIS_MNEMONIC_VPEXTRW 0x0462 +#define /*0463*/ ZYDIS_MNEMONIC_VPGATHERDD 0x0463 +#define /*0464*/ ZYDIS_MNEMONIC_VPGATHERDQ 0x0464 +#define /*0465*/ ZYDIS_MNEMONIC_VPGATHERQD 0x0465 +#define /*0466*/ ZYDIS_MNEMONIC_VPGATHERQQ 0x0466 +#define /*0467*/ ZYDIS_MNEMONIC_VPHADDBD 0x0467 +#define /*0468*/ ZYDIS_MNEMONIC_VPHADDBQ 0x0468 +#define /*0469*/ ZYDIS_MNEMONIC_VPHADDBW 0x0469 +#define /*046A*/ ZYDIS_MNEMONIC_VPHADDD 0x046A +#define /*046B*/ ZYDIS_MNEMONIC_VPHADDDQ 0x046B +#define /*046C*/ ZYDIS_MNEMONIC_VPHADDSW 0x046C +#define /*046D*/ ZYDIS_MNEMONIC_VPHADDUBD 0x046D +#define /*046E*/ ZYDIS_MNEMONIC_VPHADDUBQ 0x046E +#define /*046F*/ ZYDIS_MNEMONIC_VPHADDUBW 0x046F +#define /*0470*/ ZYDIS_MNEMONIC_VPHADDUDQ 0x0470 +#define /*0471*/ ZYDIS_MNEMONIC_VPHADDUWD 0x0471 +#define /*0472*/ ZYDIS_MNEMONIC_VPHADDUWQ 0x0472 +#define /*0473*/ ZYDIS_MNEMONIC_VPHADDW 0x0473 +#define /*0474*/ ZYDIS_MNEMONIC_VPHADDWD 0x0474 +#define /*0475*/ ZYDIS_MNEMONIC_VPHADDWQ 0x0475 +#define /*0476*/ ZYDIS_MNEMONIC_VPHMINPOSUW 0x0476 +#define /*0477*/ ZYDIS_MNEMONIC_VPHSUBBW 0x0477 +#define /*0478*/ ZYDIS_MNEMONIC_VPHSUBD 0x0478 +#define /*0479*/ ZYDIS_MNEMONIC_VPHSUBDQ 0x0479 +#define /*047A*/ ZYDIS_MNEMONIC_VPHSUBSW 0x047A +#define /*047B*/ ZYDIS_MNEMONIC_VPHSUBW 0x047B +#define /*047C*/ ZYDIS_MNEMONIC_VPHSUBWD 0x047C +#define /*047D*/ ZYDIS_MNEMONIC_VPINSRB 0x047D +#define /*047E*/ ZYDIS_MNEMONIC_VPINSRD 0x047E +#define /*047F*/ ZYDIS_MNEMONIC_VPINSRQ 0x047F +#define /*0480*/ ZYDIS_MNEMONIC_VPINSRW 0x0480 +#define /*0481*/ ZYDIS_MNEMONIC_VPLZCNTD 0x0481 +#define /*0482*/ ZYDIS_MNEMONIC_VPLZCNTQ 0x0482 +#define /*0483*/ ZYDIS_MNEMONIC_VPMACSDD 0x0483 +#define /*0484*/ ZYDIS_MNEMONIC_VPMACSDQH 0x0484 +#define /*0485*/ ZYDIS_MNEMONIC_VPMACSDQL 0x0485 +#define /*0486*/ ZYDIS_MNEMONIC_VPMACSSDD 0x0486 +#define /*0487*/ ZYDIS_MNEMONIC_VPMACSSDQH 0x0487 +#define /*0488*/ ZYDIS_MNEMONIC_VPMACSSDQL 0x0488 +#define /*0489*/ ZYDIS_MNEMONIC_VPMACSSWD 0x0489 +#define /*048A*/ ZYDIS_MNEMONIC_VPMACSSWW 0x048A +#define /*048B*/ ZYDIS_MNEMONIC_VPMACSWD 0x048B +#define /*048C*/ ZYDIS_MNEMONIC_VPMACSWW 0x048C +#define /*048D*/ ZYDIS_MNEMONIC_VPMADCSSWD 0x048D +#define /*048E*/ ZYDIS_MNEMONIC_VPMADCSWD 0x048E +#define /*048F*/ ZYDIS_MNEMONIC_VPMADD52HUQ 0x048F +#define /*0490*/ ZYDIS_MNEMONIC_VPMADD52LUQ 0x0490 +#define /*0491*/ ZYDIS_MNEMONIC_VPMADDUBSW 0x0491 +#define /*0492*/ ZYDIS_MNEMONIC_VPMADDWD 0x0492 +#define /*0493*/ ZYDIS_MNEMONIC_VPMASKMOVD 0x0493 +#define /*0494*/ ZYDIS_MNEMONIC_VPMASKMOVQ 0x0494 +#define /*0495*/ ZYDIS_MNEMONIC_VPMAXSB 0x0495 +#define /*0496*/ ZYDIS_MNEMONIC_VPMAXSD 0x0496 +#define /*0497*/ ZYDIS_MNEMONIC_VPMAXSQ 0x0497 +#define /*0498*/ ZYDIS_MNEMONIC_VPMAXSW 0x0498 +#define /*0499*/ ZYDIS_MNEMONIC_VPMAXUB 0x0499 +#define /*049A*/ ZYDIS_MNEMONIC_VPMAXUD 0x049A +#define /*049B*/ ZYDIS_MNEMONIC_VPMAXUQ 0x049B +#define /*049C*/ ZYDIS_MNEMONIC_VPMAXUW 0x049C +#define /*049D*/ ZYDIS_MNEMONIC_VPMINSB 0x049D +#define /*049E*/ ZYDIS_MNEMONIC_VPMINSD 0x049E +#define /*049F*/ ZYDIS_MNEMONIC_VPMINSQ 0x049F +#define /*04A0*/ ZYDIS_MNEMONIC_VPMINSW 0x04A0 +#define /*04A1*/ ZYDIS_MNEMONIC_VPMINUB 0x04A1 +#define /*04A2*/ ZYDIS_MNEMONIC_VPMINUD 0x04A2 +#define /*04A3*/ ZYDIS_MNEMONIC_VPMINUQ 0x04A3 +#define /*04A4*/ ZYDIS_MNEMONIC_VPMINUW 0x04A4 +#define /*04A5*/ ZYDIS_MNEMONIC_VPMOVB2M 0x04A5 +#define /*04A6*/ ZYDIS_MNEMONIC_VPMOVD2M 0x04A6 +#define /*04A7*/ ZYDIS_MNEMONIC_VPMOVDB 0x04A7 +#define /*04A8*/ ZYDIS_MNEMONIC_VPMOVDW 0x04A8 +#define /*04A9*/ ZYDIS_MNEMONIC_VPMOVM2B 0x04A9 +#define /*04AA*/ ZYDIS_MNEMONIC_VPMOVM2D 0x04AA +#define /*04AB*/ ZYDIS_MNEMONIC_VPMOVM2Q 0x04AB +#define /*04AC*/ ZYDIS_MNEMONIC_VPMOVM2W 0x04AC +#define /*04AD*/ ZYDIS_MNEMONIC_VPMOVMSKB 0x04AD +#define /*04AE*/ ZYDIS_MNEMONIC_VPMOVQ2M 0x04AE +#define /*04AF*/ ZYDIS_MNEMONIC_VPMOVQB 0x04AF +#define /*04B0*/ ZYDIS_MNEMONIC_VPMOVQD 0x04B0 +#define /*04B1*/ ZYDIS_MNEMONIC_VPMOVQW 0x04B1 +#define /*04B2*/ ZYDIS_MNEMONIC_VPMOVSDB 0x04B2 +#define /*04B3*/ ZYDIS_MNEMONIC_VPMOVSDW 0x04B3 +#define /*04B4*/ ZYDIS_MNEMONIC_VPMOVSQB 0x04B4 +#define /*04B5*/ ZYDIS_MNEMONIC_VPMOVSQD 0x04B5 +#define /*04B6*/ ZYDIS_MNEMONIC_VPMOVSQW 0x04B6 +#define /*04B7*/ ZYDIS_MNEMONIC_VPMOVSWB 0x04B7 +#define /*04B8*/ ZYDIS_MNEMONIC_VPMOVSXBD 0x04B8 +#define /*04B9*/ ZYDIS_MNEMONIC_VPMOVSXBQ 0x04B9 +#define /*04BA*/ ZYDIS_MNEMONIC_VPMOVSXBW 0x04BA +#define /*04BB*/ ZYDIS_MNEMONIC_VPMOVSXDQ 0x04BB +#define /*04BC*/ ZYDIS_MNEMONIC_VPMOVSXWD 0x04BC +#define /*04BD*/ ZYDIS_MNEMONIC_VPMOVSXWQ 0x04BD +#define /*04BE*/ ZYDIS_MNEMONIC_VPMOVUSDB 0x04BE +#define /*04BF*/ ZYDIS_MNEMONIC_VPMOVUSDW 0x04BF +#define /*04C0*/ ZYDIS_MNEMONIC_VPMOVUSQB 0x04C0 +#define /*04C1*/ ZYDIS_MNEMONIC_VPMOVUSQD 0x04C1 +#define /*04C2*/ ZYDIS_MNEMONIC_VPMOVUSQW 0x04C2 +#define /*04C3*/ ZYDIS_MNEMONIC_VPMOVUSWB 0x04C3 +#define /*04C4*/ ZYDIS_MNEMONIC_VPMOVW2M 0x04C4 +#define /*04C5*/ ZYDIS_MNEMONIC_VPMOVWB 0x04C5 +#define /*04C6*/ ZYDIS_MNEMONIC_VPMOVZXBD 0x04C6 +#define /*04C7*/ ZYDIS_MNEMONIC_VPMOVZXBQ 0x04C7 +#define /*04C8*/ ZYDIS_MNEMONIC_VPMOVZXBW 0x04C8 +#define /*04C9*/ ZYDIS_MNEMONIC_VPMOVZXDQ 0x04C9 +#define /*04CA*/ ZYDIS_MNEMONIC_VPMOVZXWD 0x04CA +#define /*04CB*/ ZYDIS_MNEMONIC_VPMOVZXWQ 0x04CB +#define /*04CC*/ ZYDIS_MNEMONIC_VPMULDQ 0x04CC +#define /*04CD*/ ZYDIS_MNEMONIC_VPMULHRSW 0x04CD +#define /*04CE*/ ZYDIS_MNEMONIC_VPMULHUW 0x04CE +#define /*04CF*/ ZYDIS_MNEMONIC_VPMULHW 0x04CF +#define /*04D0*/ ZYDIS_MNEMONIC_VPMULLD 0x04D0 +#define /*04D1*/ ZYDIS_MNEMONIC_VPMULLQ 0x04D1 +#define /*04D2*/ ZYDIS_MNEMONIC_VPMULLW 0x04D2 +#define /*04D3*/ ZYDIS_MNEMONIC_VPMULTISHIFTQB 0x04D3 +#define /*04D4*/ ZYDIS_MNEMONIC_VPMULUDQ 0x04D4 +#define /*04D5*/ ZYDIS_MNEMONIC_VPOR 0x04D5 +#define /*04D6*/ ZYDIS_MNEMONIC_VPORD 0x04D6 +#define /*04D7*/ ZYDIS_MNEMONIC_VPORQ 0x04D7 +#define /*04D8*/ ZYDIS_MNEMONIC_VPPERM 0x04D8 +#define /*04D9*/ ZYDIS_MNEMONIC_VPROLD 0x04D9 +#define /*04DA*/ ZYDIS_MNEMONIC_VPROLQ 0x04DA +#define /*04DB*/ ZYDIS_MNEMONIC_VPROLVD 0x04DB +#define /*04DC*/ ZYDIS_MNEMONIC_VPROLVQ 0x04DC +#define /*04DD*/ ZYDIS_MNEMONIC_VPRORD 0x04DD +#define /*04DE*/ ZYDIS_MNEMONIC_VPRORQ 0x04DE +#define /*04DF*/ ZYDIS_MNEMONIC_VPRORVD 0x04DF +#define /*04E0*/ ZYDIS_MNEMONIC_VPRORVQ 0x04E0 +#define /*04E1*/ ZYDIS_MNEMONIC_VPROTB 0x04E1 +#define /*04E2*/ ZYDIS_MNEMONIC_VPROTD 0x04E2 +#define /*04E3*/ ZYDIS_MNEMONIC_VPROTQ 0x04E3 +#define /*04E4*/ ZYDIS_MNEMONIC_VPROTW 0x04E4 +#define /*04E5*/ ZYDIS_MNEMONIC_VPSADBW 0x04E5 +#define /*04E6*/ ZYDIS_MNEMONIC_VPSCATTERDD 0x04E6 +#define /*04E7*/ ZYDIS_MNEMONIC_VPSCATTERDQ 0x04E7 +#define /*04E8*/ ZYDIS_MNEMONIC_VPSCATTERQD 0x04E8 +#define /*04E9*/ ZYDIS_MNEMONIC_VPSCATTERQQ 0x04E9 +#define /*04EA*/ ZYDIS_MNEMONIC_VPSHAB 0x04EA +#define /*04EB*/ ZYDIS_MNEMONIC_VPSHAD 0x04EB +#define /*04EC*/ ZYDIS_MNEMONIC_VPSHAQ 0x04EC +#define /*04ED*/ ZYDIS_MNEMONIC_VPSHAW 0x04ED +#define /*04EE*/ ZYDIS_MNEMONIC_VPSHLB 0x04EE +#define /*04EF*/ ZYDIS_MNEMONIC_VPSHLD 0x04EF +#define /*04F0*/ ZYDIS_MNEMONIC_VPSHLQ 0x04F0 +#define /*04F1*/ ZYDIS_MNEMONIC_VPSHLW 0x04F1 +#define /*04F2*/ ZYDIS_MNEMONIC_VPSHUFB 0x04F2 +#define /*04F3*/ ZYDIS_MNEMONIC_VPSHUFD 0x04F3 +#define /*04F4*/ ZYDIS_MNEMONIC_VPSHUFHW 0x04F4 +#define /*04F5*/ ZYDIS_MNEMONIC_VPSHUFLW 0x04F5 +#define /*04F6*/ ZYDIS_MNEMONIC_VPSIGNB 0x04F6 +#define /*04F7*/ ZYDIS_MNEMONIC_VPSIGND 0x04F7 +#define /*04F8*/ ZYDIS_MNEMONIC_VPSIGNW 0x04F8 +#define /*04F9*/ ZYDIS_MNEMONIC_VPSLLD 0x04F9 +#define /*04FA*/ ZYDIS_MNEMONIC_VPSLLDQ 0x04FA +#define /*04FB*/ ZYDIS_MNEMONIC_VPSLLQ 0x04FB +#define /*04FC*/ ZYDIS_MNEMONIC_VPSLLVD 0x04FC +#define /*04FD*/ ZYDIS_MNEMONIC_VPSLLVQ 0x04FD +#define /*04FE*/ ZYDIS_MNEMONIC_VPSLLVW 0x04FE +#define /*04FF*/ ZYDIS_MNEMONIC_VPSLLW 0x04FF +#define /*0500*/ ZYDIS_MNEMONIC_VPSRAD 0x0500 +#define /*0501*/ ZYDIS_MNEMONIC_VPSRAQ 0x0501 +#define /*0502*/ ZYDIS_MNEMONIC_VPSRAVD 0x0502 +#define /*0503*/ ZYDIS_MNEMONIC_VPSRAVQ 0x0503 +#define /*0504*/ ZYDIS_MNEMONIC_VPSRAVW 0x0504 +#define /*0505*/ ZYDIS_MNEMONIC_VPSRAW 0x0505 +#define /*0506*/ ZYDIS_MNEMONIC_VPSRLD 0x0506 +#define /*0507*/ ZYDIS_MNEMONIC_VPSRLDQ 0x0507 +#define /*0508*/ ZYDIS_MNEMONIC_VPSRLQ 0x0508 +#define /*0509*/ ZYDIS_MNEMONIC_VPSRLVD 0x0509 +#define /*050A*/ ZYDIS_MNEMONIC_VPSRLVQ 0x050A +#define /*050B*/ ZYDIS_MNEMONIC_VPSRLVW 0x050B +#define /*050C*/ ZYDIS_MNEMONIC_VPSRLW 0x050C +#define /*050D*/ ZYDIS_MNEMONIC_VPSUBB 0x050D +#define /*050E*/ ZYDIS_MNEMONIC_VPSUBD 0x050E +#define /*050F*/ ZYDIS_MNEMONIC_VPSUBQ 0x050F +#define /*0510*/ ZYDIS_MNEMONIC_VPSUBSB 0x0510 +#define /*0511*/ ZYDIS_MNEMONIC_VPSUBSW 0x0511 +#define /*0512*/ ZYDIS_MNEMONIC_VPSUBUSB 0x0512 +#define /*0513*/ ZYDIS_MNEMONIC_VPSUBUSW 0x0513 +#define /*0514*/ ZYDIS_MNEMONIC_VPSUBW 0x0514 +#define /*0515*/ ZYDIS_MNEMONIC_VPTERNLOGD 0x0515 +#define /*0516*/ ZYDIS_MNEMONIC_VPTERNLOGQ 0x0516 +#define /*0517*/ ZYDIS_MNEMONIC_VPTEST 0x0517 +#define /*0518*/ ZYDIS_MNEMONIC_VPTESTMB 0x0518 +#define /*0519*/ ZYDIS_MNEMONIC_VPTESTMD 0x0519 +#define /*051A*/ ZYDIS_MNEMONIC_VPTESTMQ 0x051A +#define /*051B*/ ZYDIS_MNEMONIC_VPTESTMW 0x051B +#define /*051C*/ ZYDIS_MNEMONIC_VPTESTNMB 0x051C +#define /*051D*/ ZYDIS_MNEMONIC_VPTESTNMD 0x051D +#define /*051E*/ ZYDIS_MNEMONIC_VPTESTNMQ 0x051E +#define /*051F*/ ZYDIS_MNEMONIC_VPTESTNMW 0x051F +#define /*0520*/ ZYDIS_MNEMONIC_VPUNPCKHBW 0x0520 +#define /*0521*/ ZYDIS_MNEMONIC_VPUNPCKHDQ 0x0521 +#define /*0522*/ ZYDIS_MNEMONIC_VPUNPCKHQDQ 0x0522 +#define /*0523*/ ZYDIS_MNEMONIC_VPUNPCKHWD 0x0523 +#define /*0524*/ ZYDIS_MNEMONIC_VPUNPCKLBW 0x0524 +#define /*0525*/ ZYDIS_MNEMONIC_VPUNPCKLDQ 0x0525 +#define /*0526*/ ZYDIS_MNEMONIC_VPUNPCKLQDQ 0x0526 +#define /*0527*/ ZYDIS_MNEMONIC_VPUNPCKLWD 0x0527 +#define /*0528*/ ZYDIS_MNEMONIC_VPXOR 0x0528 +#define /*0529*/ ZYDIS_MNEMONIC_VPXORD 0x0529 +#define /*052A*/ ZYDIS_MNEMONIC_VPXORQ 0x052A +#define /*052B*/ ZYDIS_MNEMONIC_VRANGEPD 0x052B +#define /*052C*/ ZYDIS_MNEMONIC_VRANGEPS 0x052C +#define /*052D*/ ZYDIS_MNEMONIC_VRANGESD 0x052D +#define /*052E*/ ZYDIS_MNEMONIC_VRANGESS 0x052E +#define /*052F*/ ZYDIS_MNEMONIC_VRCP14PD 0x052F +#define /*0530*/ ZYDIS_MNEMONIC_VRCP14PS 0x0530 +#define /*0531*/ ZYDIS_MNEMONIC_VRCP14SD 0x0531 +#define /*0532*/ ZYDIS_MNEMONIC_VRCP14SS 0x0532 +#define /*0533*/ ZYDIS_MNEMONIC_VRCP28PD 0x0533 +#define /*0534*/ ZYDIS_MNEMONIC_VRCP28PS 0x0534 +#define /*0535*/ ZYDIS_MNEMONIC_VRCP28SD 0x0535 +#define /*0536*/ ZYDIS_MNEMONIC_VRCP28SS 0x0536 +#define /*0537*/ ZYDIS_MNEMONIC_VRCPPS 0x0537 +#define /*0538*/ ZYDIS_MNEMONIC_VRCPSS 0x0538 +#define /*0539*/ ZYDIS_MNEMONIC_VREDUCEPD 0x0539 +#define /*053A*/ ZYDIS_MNEMONIC_VREDUCEPS 0x053A +#define /*053B*/ ZYDIS_MNEMONIC_VREDUCESD 0x053B +#define /*053C*/ ZYDIS_MNEMONIC_VREDUCESS 0x053C +#define /*053D*/ ZYDIS_MNEMONIC_VRNDSCALEPD 0x053D +#define /*053E*/ ZYDIS_MNEMONIC_VRNDSCALEPS 0x053E +#define /*053F*/ ZYDIS_MNEMONIC_VRNDSCALESD 0x053F +#define /*0540*/ ZYDIS_MNEMONIC_VRNDSCALESS 0x0540 +#define /*0541*/ ZYDIS_MNEMONIC_VROUNDPD 0x0541 +#define /*0542*/ ZYDIS_MNEMONIC_VROUNDPS 0x0542 +#define /*0543*/ ZYDIS_MNEMONIC_VROUNDSD 0x0543 +#define /*0544*/ ZYDIS_MNEMONIC_VROUNDSS 0x0544 +#define /*0545*/ ZYDIS_MNEMONIC_VRSQRT14PD 0x0545 +#define /*0546*/ ZYDIS_MNEMONIC_VRSQRT14PS 0x0546 +#define /*0547*/ ZYDIS_MNEMONIC_VRSQRT14SD 0x0547 +#define /*0548*/ ZYDIS_MNEMONIC_VRSQRT14SS 0x0548 +#define /*0549*/ ZYDIS_MNEMONIC_VRSQRT28PD 0x0549 +#define /*054A*/ ZYDIS_MNEMONIC_VRSQRT28PS 0x054A +#define /*054B*/ ZYDIS_MNEMONIC_VRSQRT28SD 0x054B +#define /*054C*/ ZYDIS_MNEMONIC_VRSQRT28SS 0x054C +#define /*054D*/ ZYDIS_MNEMONIC_VRSQRTPS 0x054D +#define /*054E*/ ZYDIS_MNEMONIC_VRSQRTSS 0x054E +#define /*054F*/ ZYDIS_MNEMONIC_VSCALEFPD 0x054F +#define /*0550*/ ZYDIS_MNEMONIC_VSCALEFPS 0x0550 +#define /*0551*/ ZYDIS_MNEMONIC_VSCALEFSD 0x0551 +#define /*0552*/ ZYDIS_MNEMONIC_VSCALEFSS 0x0552 +#define /*0553*/ ZYDIS_MNEMONIC_VSCATTERDPD 0x0553 +#define /*0554*/ ZYDIS_MNEMONIC_VSCATTERDPS 0x0554 +#define /*0555*/ ZYDIS_MNEMONIC_VSCATTERPF0DPD 0x0555 +#define /*0556*/ ZYDIS_MNEMONIC_VSCATTERPF0DPS 0x0556 +#define /*0557*/ ZYDIS_MNEMONIC_VSCATTERPF0QPD 0x0557 +#define /*0558*/ ZYDIS_MNEMONIC_VSCATTERPF0QPS 0x0558 +#define /*0559*/ ZYDIS_MNEMONIC_VSCATTERPF1DPD 0x0559 +#define /*055A*/ ZYDIS_MNEMONIC_VSCATTERPF1DPS 0x055A +#define /*055B*/ ZYDIS_MNEMONIC_VSCATTERPF1QPD 0x055B +#define /*055C*/ ZYDIS_MNEMONIC_VSCATTERPF1QPS 0x055C +#define /*055D*/ ZYDIS_MNEMONIC_VSCATTERQPD 0x055D +#define /*055E*/ ZYDIS_MNEMONIC_VSCATTERQPS 0x055E +#define /*055F*/ ZYDIS_MNEMONIC_VSHUFF32X4 0x055F +#define /*0560*/ ZYDIS_MNEMONIC_VSHUFF64X2 0x0560 +#define /*0561*/ ZYDIS_MNEMONIC_VSHUFI32X4 0x0561 +#define /*0562*/ ZYDIS_MNEMONIC_VSHUFI64X2 0x0562 +#define /*0563*/ ZYDIS_MNEMONIC_VSHUFPD 0x0563 +#define /*0564*/ ZYDIS_MNEMONIC_VSHUFPS 0x0564 +#define /*0565*/ ZYDIS_MNEMONIC_VSQRTPD 0x0565 +#define /*0566*/ ZYDIS_MNEMONIC_VSQRTPS 0x0566 +#define /*0567*/ ZYDIS_MNEMONIC_VSQRTSD 0x0567 +#define /*0568*/ ZYDIS_MNEMONIC_VSQRTSS 0x0568 +#define /*0569*/ ZYDIS_MNEMONIC_VSTMXCSR 0x0569 +#define /*056A*/ ZYDIS_MNEMONIC_VSUBPD 0x056A +#define /*056B*/ ZYDIS_MNEMONIC_VSUBPS 0x056B +#define /*056C*/ ZYDIS_MNEMONIC_VSUBSD 0x056C +#define /*056D*/ ZYDIS_MNEMONIC_VSUBSS 0x056D +#define /*056E*/ ZYDIS_MNEMONIC_VTESTPD 0x056E +#define /*056F*/ ZYDIS_MNEMONIC_VTESTPS 0x056F +#define /*0570*/ ZYDIS_MNEMONIC_VUCOMISD 0x0570 +#define /*0571*/ ZYDIS_MNEMONIC_VUCOMISS 0x0571 +#define /*0572*/ ZYDIS_MNEMONIC_VUNPCKHPD 0x0572 +#define /*0573*/ ZYDIS_MNEMONIC_VUNPCKHPS 0x0573 +#define /*0574*/ ZYDIS_MNEMONIC_VUNPCKLPD 0x0574 +#define /*0575*/ ZYDIS_MNEMONIC_VUNPCKLPS 0x0575 +#define /*0576*/ ZYDIS_MNEMONIC_VXORPD 0x0576 +#define /*0577*/ ZYDIS_MNEMONIC_VXORPS 0x0577 +#define /*0578*/ ZYDIS_MNEMONIC_VZEROALL 0x0578 +#define /*0579*/ ZYDIS_MNEMONIC_VZEROUPPER 0x0579 +#define /*057A*/ ZYDIS_MNEMONIC_WAIT 0x057A +#define /*057B*/ ZYDIS_MNEMONIC_WBINVD 0x057B +#define /*057C*/ ZYDIS_MNEMONIC_WRFSBASE 0x057C +#define /*057D*/ ZYDIS_MNEMONIC_WRGSBASE 0x057D +#define /*057E*/ ZYDIS_MNEMONIC_WRMSR 0x057E +#define /*057F*/ ZYDIS_MNEMONIC_WRPKRU 0x057F +#define /*0580*/ ZYDIS_MNEMONIC_XABORT 0x0580 +#define /*0581*/ ZYDIS_MNEMONIC_XADD 0x0581 +#define /*0582*/ ZYDIS_MNEMONIC_XBEGIN 0x0582 +#define /*0583*/ ZYDIS_MNEMONIC_XCHG 0x0583 +#define /*0584*/ ZYDIS_MNEMONIC_XCRYPTCBC 0x0584 +#define /*0585*/ ZYDIS_MNEMONIC_XCRYPTCFB 0x0585 +#define /*0586*/ ZYDIS_MNEMONIC_XCRYPTCTR 0x0586 +#define /*0587*/ ZYDIS_MNEMONIC_XCRYPTECB 0x0587 +#define /*0588*/ ZYDIS_MNEMONIC_XCRYPTOFB 0x0588 +#define /*0589*/ ZYDIS_MNEMONIC_XEND 0x0589 +#define /*058A*/ ZYDIS_MNEMONIC_XGETBV 0x058A +#define /*058B*/ ZYDIS_MNEMONIC_XLATB 0x058B +#define /*058C*/ ZYDIS_MNEMONIC_XOR 0x058C +#define /*058D*/ ZYDIS_MNEMONIC_XORPD 0x058D +#define /*058E*/ ZYDIS_MNEMONIC_XORPS 0x058E +#define /*058F*/ ZYDIS_MNEMONIC_XRSTOR 0x058F +#define /*0590*/ ZYDIS_MNEMONIC_XRSTOR64 0x0590 +#define /*0591*/ ZYDIS_MNEMONIC_XRSTORS 0x0591 +#define /*0592*/ ZYDIS_MNEMONIC_XRSTORS64 0x0592 +#define /*0593*/ ZYDIS_MNEMONIC_XSAVE 0x0593 +#define /*0594*/ ZYDIS_MNEMONIC_XSAVE64 0x0594 +#define /*0595*/ ZYDIS_MNEMONIC_XSAVEC 0x0595 +#define /*0596*/ ZYDIS_MNEMONIC_XSAVEC64 0x0596 +#define /*0597*/ ZYDIS_MNEMONIC_XSAVEOPT 0x0597 +#define /*0598*/ ZYDIS_MNEMONIC_XSAVEOPT64 0x0598 +#define /*0599*/ ZYDIS_MNEMONIC_XSAVES 0x0599 +#define /*059A*/ ZYDIS_MNEMONIC_XSAVES64 0x059A +#define /*059B*/ ZYDIS_MNEMONIC_XSETBV 0x059B +#define /*059C*/ ZYDIS_MNEMONIC_XSHA1 0x059C +#define /*059D*/ ZYDIS_MNEMONIC_XSHA256 0x059D +#define /*059E*/ ZYDIS_MNEMONIC_XSTORE 0x059E +#define /*059F*/ ZYDIS_MNEMONIC_XTEST 0x059F diff --git a/include/Zydis/Mnemonic.h b/include/Zydis/Mnemonic.h index 8ce15fc..ae7fd3e 100644 --- a/include/Zydis/Mnemonic.h +++ b/include/Zydis/Mnemonic.h @@ -44,13 +44,7 @@ extern "C" { */ typedef uint16_t ZydisInstructionMnemonic; -/** - * @brief Values that represent zydis instruction-mnemonics. - */ -enum ZydisInstructionMnemonics -{ -#include -}; +#include /* ============================================================================================== */ /* Exported functions */ diff --git a/include/Zydis/Register.h b/include/Zydis/Register.h index 93c93dd..dfd9c9a 100644 --- a/include/Zydis/Register.h +++ b/include/Zydis/Register.h @@ -158,6 +158,8 @@ enum ZydisRegisterClasses ZYDIS_REGISTERCLASS_BOUNDS }; +/* ---------------------------------------------------------------------------------------------- */ + /** * @brief Defines the @c ZydisRegisterSize datatype. */ diff --git a/include/Zydis/Status.h b/include/Zydis/Status.h index 4d05cf7..e673613 100644 --- a/include/Zydis/Status.h +++ b/include/Zydis/Status.h @@ -73,10 +73,6 @@ enum ZydisStatusCode * @brief A buffer passed to a function was too small to complete the requested operation. */ ZYDIS_STATUS_INSUFFICIENT_BUFFER_SIZE = 0x00000008, - /** - * @brief The start range of user defined status-codes. - */ - ZYDIS_STATUS_USER = 0x10000000 // TODO: Remove }; /* ============================================================================================== */ diff --git a/include/Zydis/Zydis.h b/include/Zydis/Zydis.h index eb70c2a..ae443f9 100644 --- a/include/Zydis/Zydis.h +++ b/include/Zydis/Zydis.h @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include diff --git a/src/Decoder.c b/src/Decoder.c index 9357389..60c2c46 100644 --- a/src/Decoder.c +++ b/src/Decoder.c @@ -110,7 +110,7 @@ static ZydisDecoderStatus ZydisInputPeek(ZydisInstructionDecoder* decoder, if (info->length >= ZYDIS_MAX_INSTRUCTION_LENGTH) { - info->flags |= ZYDIS_IFLAG_ERROR_INSTRUCTION_LENGTH; + info->flags |= ZYDIS_INSTRUCTION_ERROR_INSTRUCTION_LENGTH; return ZYDIS_STATUS_DECODER_INVALID_INSTRUCTION_LENGTH; } @@ -388,7 +388,7 @@ static void ZydisDecodeModrm(uint8_t modrmByte, ZydisInstructionInfo* info) { ZYDIS_ASSERT(info); - info->flags |= ZYDIS_IFLAG_HAS_MODRM; + info->flags |= ZYDIS_INSTRUCTION_HAS_MODRM; info->details.modrm.isDecoded = true; info->details.modrm.data[0] = modrmByte; info->details.modrm.mod = (modrmByte >> 6) & 0x03; @@ -408,7 +408,7 @@ static void ZydisDecodeSib(uint8_t sibByte, ZydisInstructionInfo* info) ZYDIS_ASSERT(info->details.modrm.isDecoded); ZYDIS_ASSERT((info->details.modrm.rm & 0x7) == 4); - info->flags |= ZYDIS_IFLAG_HAS_SIB; + info->flags |= ZYDIS_INSTRUCTION_HAS_SIB; info->details.sib.isDecoded = true; info->details.sib.data[0] = sibByte; info->details.sib.scale = (sibByte >> 6) & 0x03; @@ -556,7 +556,7 @@ static ZydisDecoderStatus ZydisDecodeOperandImmediate(ZydisInstructionDecoder* d operand->type = ZYDIS_OPERAND_TYPE_IMMEDIATE; operand->imm.isSigned = isSigned; - operand->imm.size = physicalSize; + operand->imm.dataSize = physicalSize; operand->imm.dataOffset = info->length; switch (physicalSize) { @@ -564,10 +564,9 @@ static ZydisDecoderStatus ZydisDecodeOperandImmediate(ZydisInstructionDecoder* d { // We have to store a copy of the imm8 value for instructions that encode different operands // in the lo and hi part of the immediate. - if (info->details.internal.imm8initialized) + if (decoder->imm8initialized) { - // TODO: Implement clean solution - operand->imm.value.ubyte = info->details.internal.imm8; + operand->imm.value.ubyte = decoder->imm8; } else { uint8_t immediate; @@ -579,8 +578,8 @@ static ZydisDecoderStatus ZydisDecodeOperandImmediate(ZydisInstructionDecoder* d { operand->imm.value.uqword = immediate; } - info->details.internal.imm8initialized = true; - info->details.internal.imm8 = operand->imm.value.ubyte; + decoder->imm8initialized = true; + decoder->imm8 = operand->imm.value.ubyte; } break; } @@ -646,7 +645,6 @@ static ZydisDecoderStatus ZydisDecodeOperandImmediate(ZydisInstructionDecoder* d /** * @brief Decodes an register-operand. * - * @param decoder A pointer to the @c ZydisInstructionDecoder decoder instance. * @param info A pointer to the @c ZydisInstructionInfo struct. * @param operand A pointer to the @c ZydisOperandInfo struct. * @param registerClass The register class. @@ -749,7 +747,7 @@ static ZydisDecoderStatus ZydisDecodeOperandModrmRm(ZydisInstructionDecoder* dec { if (decoder->disassemblerMode == ZYDIS_DISASSEMBLER_MODE_64BIT) { - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->mem.base = ZYDIS_REGISTER_EIP; } else { @@ -808,7 +806,7 @@ static ZydisDecoderStatus ZydisDecodeOperandModrmRm(ZydisInstructionDecoder* dec case 0: if (modrm_rm == 5) { - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->mem.base = ZYDIS_REGISTER_RIP; displacementSize = 32; } @@ -862,13 +860,13 @@ static ZydisDecoderStatus ZydisDecodeOperandModrmRm(ZydisInstructionDecoder* dec if (displacementSize) { ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, displacementSize, true)); - info->details.internal.imm8initialized = false; + decoder->imm8initialized = false; operand->type = ZYDIS_OPERAND_TYPE_MEMORY; - operand->mem.disp.size = displacementSize; + operand->mem.disp.dataSize = displacementSize; operand->mem.disp.value.sqword = operand->imm.value.sqword; operand->mem.disp.dataOffset = operand->imm.dataOffset; operand->imm.isSigned = false; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.value.sqword = 0; operand->imm.dataOffset = 0; } @@ -962,6 +960,8 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->type = ZYDIS_OPERAND_TYPE_REGISTER; operand->reg = ZYDIS_REGISTER_ST0; return ZYDIS_STATUS_DECODER_SUCCESS; + default: + break; } // Register operands @@ -1024,6 +1024,8 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->size = 128; registerClass = ZYDIS_REGISTERCLASS_BOUNDS; break; + default: + break; } if (registerClass != ZYDIS_REGISTERCLASS_INVALID) { @@ -1078,7 +1080,7 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 8, false)); ZYDIS_CHECK(ZydisDecodeOperandRegister(info, operand, registerClass, (operand->imm.value.ubyte & 0xF0) >> 4)); - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; return ZYDIS_STATUS_DECODER_SUCCESS; @@ -1109,6 +1111,8 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, case ZYDIS_OPERAND_ENCODING_RM_CD64: evexCD8Scale = 64; break; + default: + break; }; ZydisRegister vsibBaseRegister = ZYDIS_REGISTER_NONE; switch (type) @@ -1233,11 +1237,13 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->size = 64; ZYDIS_CHECK(ZydisDecodeOperandModrmRm(decoder, info, operand, ZYDIS_REGISTERCLASS_INVALID)); break; + default: + break; } if (evexCD8Scale) { ZYDIS_ASSERT(info->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX); - if (operand->mem.disp.size == 8) + if (operand->mem.disp.dataSize == 8) { operand->mem.disp.value.sdword *= evexCD8Scale; } @@ -1246,13 +1252,13 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, { if (info->details.modrm.rm != 0x04) { - info->flags |= ZYDIS_IFLAG_ERROR_INVALID_VSIB; + info->flags |= ZYDIS_INSTRUCTION_ERROR_INVALID_VSIB; return ZYDIS_STATUS_DECODER_INVALID_VSIB; } switch (info->addressMode) { case 16: - info->flags |= ZYDIS_IFLAG_ERROR_INVALID_VSIB; + info->flags |= ZYDIS_INSTRUCTION_ERROR_INVALID_VSIB; return ZYDIS_STATUS_DECODER_INVALID_VSIB; case 32: operand->mem.index = operand->mem.index - ZYDIS_REGISTER_EAX + vsibBaseRegister; @@ -1276,7 +1282,7 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->imm.value.ubyte = 1; return ZYDIS_STATUS_DECODER_SUCCESS; case ZYDIS_SEM_OPERAND_TYPE_REL8: - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->imm.isRelative = true; case ZYDIS_SEM_OPERAND_TYPE_IMM8: operand->size = 8; @@ -1287,26 +1293,28 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->imm.isSigned = false; break; case ZYDIS_SEM_OPERAND_TYPE_REL16: - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->imm.isRelative = true; case ZYDIS_SEM_OPERAND_TYPE_IMM16: operand->size = 16; operand->imm.isSigned = true; break; case ZYDIS_SEM_OPERAND_TYPE_REL32: - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->imm.isRelative = true; case ZYDIS_SEM_OPERAND_TYPE_IMM32: operand->size = 32; operand->imm.isSigned = true; break; case ZYDIS_SEM_OPERAND_TYPE_REL64: - info->flags |= ZYDIS_IFLAG_RELATIVE; + info->flags |= ZYDIS_INSTRUCTION_RELATIVE; operand->imm.isRelative = true; case ZYDIS_SEM_OPERAND_TYPE_IMM64: operand->size = 64; operand->imm.isSigned = true; break; + default: + break; } switch (type) { @@ -1343,7 +1351,7 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->ptr.offset = operand->imm.value.uword; ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 16, false)); operand->ptr.segment = operand->imm.value.uword; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; operand->type = ZYDIS_OPERAND_TYPE_POINTER; @@ -1354,7 +1362,7 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, operand->ptr.offset = operand->imm.value.udword; ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 16, false)); operand->ptr.segment = operand->imm.value.uword; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; operand->type = ZYDIS_OPERAND_TYPE_POINTER; @@ -1364,6 +1372,8 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, // TODO: ? assert(0); return ZYDIS_STATUS_DECODER_SUCCESS; + default: + break; } // Moffs @@ -1373,10 +1383,10 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 16, false)); operand->type = ZYDIS_OPERAND_TYPE_MEMORY; operand->size = 16; - operand->mem.disp.size = 16; + operand->mem.disp.dataSize = 16; operand->mem.disp.dataOffset = operand->imm.dataOffset; operand->mem.disp.value.sword = operand->imm.value.sword; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; return ZYDIS_STATUS_DECODER_SUCCESS; @@ -1384,10 +1394,10 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 32, false)); operand->type = ZYDIS_OPERAND_TYPE_MEMORY; operand->size = 32; - operand->mem.disp.size = 32; + operand->mem.disp.dataSize = 32; operand->mem.disp.dataOffset = operand->imm.dataOffset; operand->mem.disp.value.sdword = operand->imm.value.sdword; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; return ZYDIS_STATUS_DECODER_SUCCESS; @@ -1395,13 +1405,15 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, ZYDIS_CHECK(ZydisDecodeOperandImmediate(decoder, info, operand, 64, false)); operand->type = ZYDIS_OPERAND_TYPE_MEMORY; operand->size = 64; - operand->mem.disp.size = 64; + operand->mem.disp.dataSize = 64; operand->mem.disp.dataOffset = operand->imm.dataOffset; operand->mem.disp.value.sqword = operand->imm.value.sqword; - operand->imm.size = 0; + operand->imm.dataSize = 0; operand->imm.dataOffset = 0; operand->imm.value.uqword = 0; return ZYDIS_STATUS_DECODER_SUCCESS; + default: + break; } // SrcIdx and DstIdx operands @@ -1433,6 +1445,8 @@ static ZydisDecoderStatus ZydisDecodeOperand(ZydisInstructionDecoder* decoder, case ZYDIS_SEM_OPERAND_TYPE_DSTIDX64: dstidx = 64; break; + default: + break; } if (srcidx || dstidx) { @@ -1508,7 +1522,7 @@ static ZydisDecoderStatus ZydisDecodeOperands(ZydisInstructionDecoder* decoder, info->operand[i].access = definition->operands[i].access; if (status != ZYDIS_STATUS_DECODER_SUCCESS) { - info->flags |= ZYDIS_IFLAG_ERROR_OPERANDS; + info->flags |= ZYDIS_INSTRUCTION_ERROR_OPERANDS; return status; } // Adjust segment register for memory operands @@ -1568,7 +1582,7 @@ static void ZydisFinalizeInstructionInfo(ZydisInstructionInfo* info) // Adjust operand-mode /*if (info->mode == ZYDIS_DISASSEMBLER_MODE_64BIT) { - if ((info->flags & ZYDIS_IFLAG_RELATIVE) && + if ((info->flags & ZYDIS_INSTRUCTION_RELATIVE) && (info->operand[0].type == ZYDIS_OPERAND_TYPE_IMMEDIATE)) { info->operandMode = 64; @@ -1690,6 +1704,8 @@ static void ZydisFinalizeInstructionInfo(ZydisInstructionInfo* info) info->prefixFlags |= ZYDIS_PREFIX_BRANCH_TAKEN; } break; + default: + break; } if ((info->prefixFlags & ZYDIS_PREFIX_ACCEPTS_LOCK) && ((info->prefixFlags & ZYDIS_PREFIX_REP) || (info->prefixFlags & ZYDIS_PREFIX_REPNE))) @@ -1770,7 +1786,7 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode { if (info->prefixFlags & ZYDIS_PREFIX_REX) { - info->flags |= ZYDIS_IFLAG_ERROR_ILLEGAL_REX; + info->flags |= ZYDIS_INSTRUCTION_ERROR_ILLEGAL_REX; return ZYDIS_STATUS_DECODER_ILLEGAL_REX; } uint8_t prefixBytes[3]; @@ -1807,7 +1823,7 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode if (!ZydisDecodeVexPrefix(info->opcode, prefixBytes[0], prefixBytes[1], info)) { - info->flags |= ZYDIS_IFLAG_ERROR_MALFORMED_VEX; + info->flags |= ZYDIS_INSTRUCTION_ERROR_MALFORMED_VEX; return ZYDIS_STATUS_DECODER_MALFORMED_VEX_PREFIX; } info->opcodeMap = info->details.vex.m_mmmm; @@ -1819,7 +1835,7 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode if (!ZydisDecodeEvexPrefix(prefixBytes[0], prefixBytes[1], prefixBytes[2], info)) { - info->flags |= ZYDIS_IFLAG_ERROR_MALFORMED_EVEX; + info->flags |= ZYDIS_INSTRUCTION_ERROR_MALFORMED_EVEX; return ZYDIS_STATUS_DECODER_MALFORMED_EVEX_PREFIX; } info->opcodeMap = info->details.evex.mm; @@ -1838,7 +1854,7 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode { if (info->prefixFlags & ZYDIS_PREFIX_REX) { - info->flags |= ZYDIS_IFLAG_ERROR_ILLEGAL_REX; + info->flags |= ZYDIS_INSTRUCTION_ERROR_ILLEGAL_REX; return ZYDIS_STATUS_DECODER_ILLEGAL_REX; } uint8_t prefixBytes[2]; @@ -1851,13 +1867,15 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode info->prefixFlags |= ZYDIS_PREFIX_XOP; if (!ZydisDecodeXopPrefix(prefixBytes[0], prefixBytes[1], info)) { - info->flags |= ZYDIS_IFLAG_ERROR_MALFORMED_XOP; + info->flags |= ZYDIS_INSTRUCTION_ERROR_MALFORMED_XOP; return ZYDIS_STATUS_DECODER_MALFORMED_XOP_PREFIX; } info->opcodeMap = ZYDIS_OPCODE_MAP_XOP8 + info->details.xop.m_mmmm - 0x08; } break; } + default: + break; } break; case ZYDIS_OPCODE_MAP_0F: @@ -1873,6 +1891,8 @@ static ZydisDecoderStatus ZydisNodeHandlerOpcode(ZydisInstructionDecoder* decode case 0x3A: info->opcodeMap = ZYDIS_OPCODE_MAP_0F3A; break; + default: + break; } break; case ZYDIS_OPCODE_MAP_0F38: @@ -2193,7 +2213,7 @@ static ZydisDecoderStatus ZydisDecodeOpcode(ZydisInstructionDecoder* decoder, { case ZYDIS_NODETYPE_INVALID: { - info->flags |= ZYDIS_IFLAG_ERROR_INVALID; + info->flags |= ZYDIS_INSTRUCTION_ERROR_INVALID; return ZYDIS_STATUS_DECODER_INVALID_INSTRUCTION; } case ZYDIS_NODETYPE_DEFINITION_0OP: @@ -2262,7 +2282,7 @@ static ZydisDecoderStatus ZydisDecodeOpcode(ZydisInstructionDecoder* decoder, node = ZydisInstructionTableGetChildNode(node, info->opcode); if (ZydisInstructionTableGetNodeType(node) == ZYDIS_NODETYPE_INVALID) { - info->flags |= ZYDIS_IFLAG_ERROR_INVALID; + info->flags |= ZYDIS_INSTRUCTION_ERROR_INVALID; return ZYDIS_STATUS_DECODER_INVALID_INSTRUCTION; } node = ZydisInstructionTableGetChildNode(node, @@ -2437,6 +2457,9 @@ ZydisStatus ZydisDecoderSetDecoderInput(ZydisInstructionDecoder* decoder, return ZYDIS_STATUS_INVALID_PARAMETER; } decoder->input = input; + decoder->buffer.count = 0; + decoder->buffer.posRead = 0; + decoder->buffer.posWrite = 0; return ZYDIS_STATUS_SUCCESS; } @@ -2496,6 +2519,8 @@ ZydisStatus ZydisDecoderDecodeNextInstruction(ZydisInstructionDecoder* decoder, return ZYDIS_STATUS_NO_MORE_DATA; } + decoder->imm8initialized = false; + void* userData[6]; for (int i = 0; i < 5; ++i) { @@ -2560,7 +2585,7 @@ DecodeError: ++decoder->instructionPointer; info->mode = decoder->disassemblerMode; - info->flags = flags & ZYDIS_IFLAG_ERROR_MASK; + info->flags = flags & ZYDIS_INSTRUCTION_ERROR_MASK; info->length = 1; info->data[0] = firstByte; info->instrAddress = instrAddress; diff --git a/src/Formatter.c b/src/Formatter.c index b2cda13..3782c0f 100644 --- a/src/Formatter.c +++ b/src/Formatter.c @@ -153,7 +153,7 @@ static ZydisStatus ZydisBufferAppendAbsoluteAddress(const ZydisInstructionFormat switch (operand->type) { case ZYDIS_OPERAND_TYPE_MEMORY: - ZYDIS_ASSERT(operand->mem.disp.size != 0); + ZYDIS_ASSERT(operand->mem.disp.dataSize != 0); if ((operand->mem.base == ZYDIS_REGISTER_EIP) || (operand->mem.base == ZYDIS_REGISTER_RIP)) { ZYDIS_CHECK(ZydisUtilsCalcAbsoluteTargetAddress(info, operand, &address)); @@ -168,6 +168,8 @@ static ZydisStatus ZydisBufferAppendAbsoluteAddress(const ZydisInstructionFormat case ZYDIS_OPERAND_TYPE_IMMEDIATE: ZYDIS_CHECK(ZydisUtilsCalcAbsoluteTargetAddress(info, operand, &address)); break; + default: + break; } const char* symbol = NULL; @@ -323,6 +325,8 @@ static ZydisStatus ZydisBufferAppendOperandIntelMemory(const ZydisInstructionFor case 512: str = "zmmword ptr "; break; + default: + break; } ZYDIS_CHECK(ZydisBufferAppend( buffer, bufferLen, offset, (formatter->flags & ZYDIS_FORMATTER_FLAG_UPPERCASE), str)); @@ -342,7 +346,7 @@ static ZydisStatus ZydisBufferAppendOperandIntelMemory(const ZydisInstructionFor } ZYDIS_CHECK(ZydisBufferAppend( buffer, bufferLen, offset, (formatter->flags & ZYDIS_FORMATTER_FLAG_UPPERCASE), "[")); - if ((operand->mem.disp.size != 0) && ((operand->mem.base == ZYDIS_REGISTER_NONE) || + if ((operand->mem.disp.dataSize != 0) && ((operand->mem.base == ZYDIS_REGISTER_NONE) || (operand->mem.base == ZYDIS_REGISTER_EIP) || (operand->mem.base == ZYDIS_REGISTER_RIP)) && (operand->mem.index == ZYDIS_REGISTER_NONE) && (operand->mem.scale == 0)) { @@ -369,7 +373,7 @@ static ZydisStatus ZydisBufferAppendOperandIntelMemory(const ZydisInstructionFor operand->mem.scale)); } } - if ((operand->mem.disp.size) && ((operand->mem.disp.value.sqword) || + if ((operand->mem.disp.dataSize) && ((operand->mem.disp.value.sqword) || ((operand->mem.base == ZYDIS_REGISTER_NONE) && (operand->mem.index == ZYDIS_REGISTER_NONE)))) { @@ -426,6 +430,8 @@ static ZydisStatus ZydisBufferAppendOperandIntel(const ZydisInstructionFormatter operand->ptr.segment, operand->ptr.offset); case ZYDIS_OPERAND_TYPE_IMMEDIATE: return ZydisBufferAppendImmediate(formatter, buffer, bufferLen, offset, info, operand); + default: + break; } return ZYDIS_STATUS_INVALID_PARAMETER; } @@ -526,6 +532,8 @@ static ZydisStatus ZydisFormatterFormatInstructionIntel(ZydisInstructionFormatte case ZYDIS_MNEMONIC_SHR: case ZYDIS_MNEMONIC_SAR: typecast = info->operand[0].size; + default: + break; } } break; @@ -534,6 +542,8 @@ static ZydisStatus ZydisFormatterFormatInstructionIntel(ZydisInstructionFormatte typecast = (info->operand[i - 1].size != info->operand[i].size) ? info->operand[i].size : 0; break; + default: + break; } } ZYDIS_CHECK(ZydisBufferAppendOperandIntel(formatter, buffer, bufferLen, &offset, info, @@ -575,6 +585,8 @@ static ZydisStatus ZydisFormatterFormatInstructionIntel(ZydisInstructionFormatte ZYDIS_CHECK(ZydisBufferAppend(buffer, bufferLen, &offset, (formatter->flags & ZYDIS_FORMATTER_FLAG_UPPERCASE), " {1to16}")); break; + default: + break; } } if ((i == (info->operandCount - 1)) || ((i != (info->operandCount - 1)) && diff --git a/src/Register.c b/src/Register.c index f5c52b8..d73fb83 100644 --- a/src/Register.c +++ b/src/Register.c @@ -121,93 +121,81 @@ ZydisRegister ZydisRegisterGetById(ZydisRegisterClass registerClass, uint8_t id) switch (registerClass) { case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE8: - if (id > 19) + if (id <= 19) { - return ZYDIS_REGISTER_NONE; + return ZYDIS_REGISTER_AL + id; } - return ZYDIS_REGISTER_AL + id; case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE16: - if (id > 15) + if (id <= 15) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_AX + id; + return ZYDIS_REGISTER_AX + id; + } case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE32: - if (id > 15) + if (id <= 15) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_EAX + id; + return ZYDIS_REGISTER_EAX + id; + } case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE64: - if (id > 15) + if (id <= 15) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_RAX + id; + return ZYDIS_REGISTER_RAX + id; + } case ZYDIS_REGISTERCLASS_FLOATING_POINT: - if (id > 7) + if (id <= 7) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_ST0 + id; + return ZYDIS_REGISTER_ST0 + id; + } case ZYDIS_REGISTERCLASS_MULTIMEDIA: - if (id > 7) + if (id <= 7) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_MM0 + id; + return ZYDIS_REGISTER_MM0 + id; + } case ZYDIS_REGISTERCLASS_VECTOR128: - if (id > 31) + if (id <= 31) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_XMM0 + id; + return ZYDIS_REGISTER_XMM0 + id; + } case ZYDIS_REGISTERCLASS_VECTOR256: - if (id > 31) + if (id <= 31) { - return ZYDIS_REGISTER_NONE; + return ZYDIS_REGISTER_YMM0 + id; } - return ZYDIS_REGISTER_YMM0 + id; case ZYDIS_REGISTERCLASS_VECTOR512: - if (id > 31) + if (id <= 31) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_ZMM0 + id; + return ZYDIS_REGISTER_ZMM0 + id; + } case ZYDIS_REGISTERCLASS_SEGMENT: - if (id > 5) + if (id <= 5) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_ES + id; + return ZYDIS_REGISTER_ES + id; + } case ZYDIS_REGISTERCLASS_CONTROL: - if (id > 15) + if (id <= 15) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_CR0 + id; + return ZYDIS_REGISTER_CR0 + id; + } case ZYDIS_REGISTERCLASS_DEBUG: - if (id > 15) + if (id <= 15) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_DR0 + id; + return ZYDIS_REGISTER_DR0 + id; + } case ZYDIS_REGISTERCLASS_MASK: - if (id > 7) + if (id <= 7) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_K0 + id; + return ZYDIS_REGISTER_K0 + id; + } case ZYDIS_REGISTERCLASS_BOUNDS: - if (id > 3) + if (id <= 3) { - return ZYDIS_REGISTER_NONE; - } - return ZYDIS_REGISTER_BND0 + id; + return ZYDIS_REGISTER_BND0 + id; + } case ZYDIS_REGISTERCLASS_FLAGS: case ZYDIS_REGISTERCLASS_IP: // These registers are unique break; + default: + break; } return ZYDIS_REGISTER_NONE; } @@ -323,6 +311,8 @@ ZydisRegisterSize ZydisRegisterGetSize(ZydisRegister reg) return ZYDIS_REGISTERSIZE_64; case ZYDIS_REGISTERCLASS_BOUNDS: return ZYDIS_REGISTERSIZE_128; + default: + break; } return ZYDIS_REGISTERSIZE_INVALID; } @@ -336,6 +326,8 @@ bool ZydisRegisterIsGPR(ZydisRegister reg) case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE16: case ZYDIS_REGISTERCLASS_GENERAL_PURPOSE8: return true; + default: + break; } return false; } @@ -378,6 +370,8 @@ bool ZydisRegisterIsVR(ZydisRegister reg) case ZYDIS_REGISTERCLASS_VECTOR256: case ZYDIS_REGISTERCLASS_VECTOR128: return true; + default: + break; } return false; } diff --git a/src/Utils.c b/src/Utils.c index 61a7094..76b599d 100644 --- a/src/Utils.c +++ b/src/Utils.c @@ -45,7 +45,7 @@ ZydisStatus ZydisUtilsCalcAbsoluteTargetAddress(const ZydisInstructionInfo* info switch (operand->type) { case ZYDIS_OPERAND_TYPE_MEMORY: - if (operand->mem.disp.size == 0) + if (operand->mem.disp.dataSize == 0) { return ZYDIS_STATUS_INVALID_PARAMETER; } @@ -75,10 +75,14 @@ ZydisStatus ZydisUtilsCalcAbsoluteTargetAddress(const ZydisInstructionInfo* info *address = (uint32_t)*address; } break; + default: + break; } return ZYDIS_STATUS_SUCCESS; } break; + default: + break; } return ZYDIS_STATUS_INVALID_PARAMETER; } diff --git a/src/Zydis.c b/src/Zydis.c index ce88ef6..03d345d 100644 --- a/src/Zydis.c +++ b/src/Zydis.c @@ -57,6 +57,8 @@ bool ZydisIsFeatureEnabled(ZydisFeature feature) #else return false; #endif + default: + break; } return false; }