├── .gitignore ├── LICENSE ├── README.md ├── lj2zydis ├── ZydisDecoder.lua ├── ZydisFormatter.lua ├── enum.lua ├── ffi │ ├── CommonTypes.lua │ ├── Decoder.lua │ ├── DecoderTypes.lua │ ├── EnumISAExt.lua │ ├── EnumISASet.lua │ ├── EnumInstructionCategory.lua │ ├── EnumMnemonic.lua │ ├── EnumRegister.lua │ ├── Formatter.lua │ ├── MetaInfo.lua │ ├── Mnemonic.lua │ ├── Register.lua │ ├── SharedTypes.lua │ ├── Status.lua │ ├── String.lua │ └── Utils.lua ├── namespace.lua └── zydis.lua └── testy ├── DOSExample.lua ├── README.md ├── WebExample.lua ├── ZydisEnums.lua ├── ZydisInfo.lua ├── test_ZydisDecoder.lua └── test_basic.lua /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Lua sources 2 | luac.out 3 | 4 | # luarocks build files 5 | *.src.rock 6 | *.zip 7 | *.tar.gz 8 | 9 | # Object files 10 | *.o 11 | *.os 12 | *.ko 13 | *.obj 14 | *.elf 15 | 16 | # Precompiled Headers 17 | *.gch 18 | *.pch 19 | 20 | # Libraries 21 | *.lib 22 | *.a 23 | *.la 24 | *.lo 25 | *.def 26 | *.exp 27 | 28 | # Shared objects (inc. Windows DLLs) 29 | *.dll 30 | *.so 31 | *.so.* 32 | *.dylib 33 | 34 | # Executables 35 | *.exe 36 | *.out 37 | *.app 38 | *.i*86 39 | *.x86_64 40 | *.hex 41 | 42 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 William Adams 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # lj2zydis 2 | LuaJIT binding to Zydis - Zyantific disassembly tools 3 | 4 | * https://github.com/zyantific/zydis 5 | 6 | This binding is fairly complete as it captures all the exported functions, data types, and enums. The 'WebExample' is taken from the web page of the Zydis github project, and replicates the output almost exactly. The 'DOSExample' comes from taking a typical DOS Stub from a Portable Executable file. -------------------------------------------------------------------------------- /lj2zydis/ZydisDecoder.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | require("lj2zydis.ffi.Decoder") 3 | local zydis = require("lj2zydis.zydis") 4 | 5 | local ZydisLib = zydis.Lib; 6 | 7 | 8 | local ZydisDecoder = {} 9 | -- set metamethod on ZydisDecoder to ease construction 10 | local ZydisDecoder_mt = { 11 | __new = function(ct, machineMode, addressWidth) 12 | machineMode = machineMode or ffi.C.ZYDIS_MACHINE_MODE_LONG_64; 13 | addressWidth = addressWidth or ffi.C.ZYDIS_ADDRESS_WIDTH_64; 14 | 15 | local obj = ffi.new(ct) 16 | ZydisLib.ZydisDecoderInit(obj, machineMode, addressWidth) 17 | 18 | return obj; 19 | end; 20 | 21 | __index = ZydisDecoder; 22 | 23 | } 24 | ffi.metatype(ffi.typeof("ZydisDecoder"), ZydisDecoder_mt); 25 | 26 | 27 | function ZydisDecoder.DecodeBuffer(self, buffer, bufferLen, instructionPointer, instruction) 28 | return ZydisLib.ZydisDecoderDecodeBuffer(self, buffer, bufferLen, instructionPointer, instruction) == 0; 29 | end 30 | 31 | function ZydisDecoder.EnableMode(self, mode, enabled) 32 | mode = mode or ffi.C.ZYDIS_DECODER_MODE_MINIMAL; 33 | local able = 1; 34 | if not enabled then able = 0 end 35 | 36 | return ZydisLib.ZydisDecoderEnableMode(self, mode, able) == 0; 37 | end 38 | 39 | return ffi.typeof("ZydisDecoder") 40 | -------------------------------------------------------------------------------- /lj2zydis/ZydisFormatter.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.Formatter") 4 | local zydis = require("lj2zydis.zydis") 5 | 6 | local ZydisLib = zydis.Lib; 7 | 8 | -- A basic class to wrap ZydisFormatter functions 9 | local ZydisFormatter = {} 10 | 11 | -- set metamethod on ZydisFormatter to ease construction 12 | -- Since we're still using the ZydisFormatter 'C' struct 13 | -- we have to associate a metatype with it 14 | local ZydisFormatter_mt = { 15 | __new = function(ct, style) 16 | style = style or ffi.C.ZYDIS_FORMATTER_STYLE_INTEL; 17 | local obj = ffi.new(ct) 18 | ZydisLib.ZydisFormatterInit(obj, style) 19 | 20 | return obj; 21 | end, 22 | --[[ 23 | __index = { 24 | FormatInstruction = function(self, instruction, buffer, bufferLen) 25 | return ZydisLib.ZydisFormatterFormatInstruction(self, instruction, buffer, bufferLen) == 0; 26 | end 27 | }; 28 | --]] 29 | __index = ZydisFormatter; 30 | } 31 | ffi.metatype(ffi.typeof("ZydisFormatter"), ZydisFormatter_mt); 32 | 33 | --[[ 34 | Actual functions 35 | ]] 36 | function ZydisFormatter.FormatInstruction(self, instruction, buffer, bufferLen) 37 | return ZydisLib.ZydisFormatterFormatInstruction(self, instruction, buffer, bufferLen) == 0; 38 | end 39 | 40 | return ffi.typeof("ZydisFormatter") 41 | -------------------------------------------------------------------------------- /lj2zydis/enum.lua: -------------------------------------------------------------------------------- 1 | local pow = math.pow 2 | local bit = require("bit") 3 | local lshift, rshift, band, bor = bit.lshift, bit.rshift, bit.band, bit.bor 4 | 5 | --[[ 6 | -- metatable for enums 7 | -- simply provides the 'reverse lookup' in a 8 | -- dictionary. Make this the metatable whenever 9 | -- you need such functionality. 10 | -- 11 | Usage: 12 | local myenum = enum { 13 | name1 = value1; 14 | name2 = value2; 15 | name3 = value3; 16 | } 17 | --]] 18 | 19 | local enum = {} 20 | setmetatable(enum, { 21 | __call = function(self, ...) 22 | return self:create(...) 23 | end, 24 | }) 25 | 26 | local enum_mt = { 27 | __index = function(tbl, value) 28 | for key, code in pairs(tbl) do 29 | if code == value then 30 | return key; 31 | end 32 | end 33 | 34 | return false; 35 | end; 36 | } 37 | function enum.init(self, alist) 38 | setmetatable(alist, enum_mt) 39 | 40 | return alist; 41 | end 42 | 43 | function enum.create(self, alist) 44 | local alist = alist or {} 45 | return self:init(alist); 46 | end 47 | 48 | --[[ 49 | Function: enumbits 50 | Parameters: 51 | bistValue - this is an integer value representing the bit flags 52 | tbl - the table the contains the name/value pairs that define the meaning of the bit flags 53 | bitsSize - how many bits are in the numeric values, default is 32 54 | 55 | Description: Given an integer value that represents a bunch of individual 56 | flags of some state, we want to get the string value which 57 | is used as a key to represent the integer flag value in a table. 58 | 59 | The enumbits() function returns an iterator, which will push 60 | out the names of the individual bits, as they are found in a 61 | table. 62 | 63 | for _, name in enumbits(0x04000001, tbleOfValues, b2) do 64 | print(name) 65 | end 66 | --]] 67 | 68 | function enum.enumbits(tbl, bitsValue, bitsSize) 69 | local function name_gen(params, state) 70 | if state >= params.bitsSize then return nil; end 71 | 72 | while(true) do 73 | local mask = pow(2,state) 74 | local maskedValue = band(mask, params.bitsValue) 75 | --print(string.format("(%2d) MASK [%x] - %#x", state, mask, maskedValue)) 76 | if maskedValue ~= 0 then 77 | return state + 1, params.tbl[maskedValue] or "UNKNOWN" 78 | end 79 | 80 | state = state + 1; 81 | if state >= params.bitsSize then return nil; end 82 | end 83 | 84 | return nil; 85 | end 86 | 87 | return name_gen, {bitsValue = bitsValue, tbl = tbl, bitsSize = bitsSize or 32}, 0 88 | end 89 | 90 | --[[ 91 | When a value represents a composite set of bits 92 | return the value as a string expansion of the bit values 93 | ]] 94 | function enum.bitValues(tbl, value, bitsSize) 95 | local res = {} 96 | for _, name in enum.enumbits(tbl, value, bitsSize) do 97 | table.insert(res, name) 98 | end 99 | return table.concat(res,', ') 100 | end 101 | 102 | function enum.inject(self, tbl) 103 | tbl = tbl or _G; 104 | for k,v in pairs(self) do 105 | rawset(tbl, k, v); 106 | end 107 | end 108 | 109 | return enum 110 | -------------------------------------------------------------------------------- /lj2zydis/ffi/CommonTypes.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | ffi.cdef[[ 4 | typedef uint8_t ZydisU8; 5 | typedef uint16_t ZydisU16; 6 | typedef uint32_t ZydisU32; 7 | typedef uint64_t ZydisU64; 8 | typedef int8_t ZydisI8; 9 | typedef int16_t ZydisI16; 10 | typedef int32_t ZydisI32; 11 | typedef int64_t ZydisI64; 12 | typedef size_t ZydisUSize; 13 | typedef ptrdiff_t ZydisISize; 14 | typedef uintptr_t ZydisUPointer; 15 | typedef intptr_t ZydisIPointer; 16 | 17 | typedef ZydisU8 ZydisBool; 18 | 19 | ]] 20 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Decoder.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | require("lj2zydis.ffi.DecoderTypes") 5 | require("lj2zydis.ffi.Status") 6 | 7 | ffi.cdef[[ 8 | typedef ZydisU8 ZydisDecoderMode; 9 | ]] 10 | 11 | ffi.cdef[[ 12 | enum ZydisDecoderModes 13 | { 14 | ZYDIS_DECODER_MODE_MINIMAL, 15 | ZYDIS_DECODER_MODE_AMD_BRANCHES, 16 | ZYDIS_DECODER_MODE_KNC, 17 | ZYDIS_DECODER_MODE_MPX, 18 | ZYDIS_DECODER_MODE_CET, 19 | ZYDIS_DECODER_MODE_LZCNT, 20 | ZYDIS_DECODER_MODE_TZCNT, 21 | ZYDIS_DECODER_MODE_WBNOINVD, 22 | 23 | ZYDIS_DECODER_MODE_MAX_VALUE = ZYDIS_DECODER_MODE_WBNOINVD 24 | }; 25 | ]] 26 | 27 | ffi.cdef[[ 28 | typedef struct ZydisDecoder_ 29 | { 30 | ZydisMachineMode machineMode; 31 | ZydisAddressWidth addressWidth; 32 | ZydisBool decoderMode[ZYDIS_DECODER_MODE_MAX_VALUE + 1]; 33 | } ZydisDecoder; 34 | ]] 35 | 36 | ffi.cdef[[ 37 | ZydisStatus ZydisDecoderInit(ZydisDecoder* decoder, ZydisMachineMode machineMode, ZydisAddressWidth addressWidth); 38 | ZydisStatus ZydisDecoderEnableMode(ZydisDecoder* decoder, ZydisDecoderMode mode, ZydisBool enabled); 39 | ZydisStatus ZydisDecoderDecodeBuffer(const ZydisDecoder* decoder, const void* buffer, ZydisUSize bufferLen, ZydisU64 instructionPointer, ZydisDecodedInstruction* instruction); 40 | ]] 41 | 42 | -------------------------------------------------------------------------------- /lj2zydis/ffi/DecoderTypes.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | require("lj2zydis.ffi.MetaInfo") 5 | require("lj2zydis.ffi.Mnemonic") 6 | require("lj2zydis.ffi.Register") 7 | require("lj2zydis.ffi.SharedTypes") 8 | 9 | ffi.cdef[[ 10 | typedef ZydisU8 ZydisMemoryOperandType; 11 | ]] 12 | 13 | ffi.cdef[[ 14 | enum ZydisMemoryOperandTypes 15 | { 16 | ZYDIS_MEMOP_TYPE_INVALID, 17 | ZYDIS_MEMOP_TYPE_MEM, 18 | ZYDIS_MEMOP_TYPE_AGEN, 19 | ZYDIS_MEMOP_TYPE_MIB, 20 | 21 | ZYDIS_MEMOP_TYPE_MAX_VALUE = ZYDIS_MEMOP_TYPE_MIB 22 | }; 23 | ]] 24 | 25 | ffi.cdef[[ 26 | typedef struct ZydisDecodedOperand_ 27 | { 28 | /** 29 | * @brief The operand-id. 30 | */ 31 | ZydisU8 id; 32 | /** 33 | * @brief The type of the operand. 34 | */ 35 | ZydisOperandType type; 36 | /** 37 | * @brief The visibility of the operand. 38 | */ 39 | ZydisOperandVisibility visibility; 40 | /** 41 | * @brief The operand-action. 42 | */ 43 | ZydisOperandAction action; 44 | /** 45 | * @brief The operand-encoding. 46 | */ 47 | ZydisOperandEncoding encoding; 48 | /** 49 | * @brief The logical size of the operand (in bits). 50 | */ 51 | ZydisU16 size; 52 | /** 53 | * @brief The element-type. 54 | */ 55 | ZydisElementType elementType; 56 | /** 57 | * @brief The size of a single element. 58 | */ 59 | ZydisElementSize elementSize; 60 | /** 61 | * @brief The number of elements. 62 | */ 63 | ZydisU16 elementCount; 64 | /** 65 | * @brief Extended info for register-operands. 66 | */ 67 | struct 68 | { 69 | /** 70 | * @brief The register value. 71 | */ 72 | ZydisRegister value; 73 | // TODO: AVX512_4VNNIW MULTISOURCE registers 74 | } reg; 75 | /** 76 | * @brief Extended info for memory-operands. 77 | */ 78 | struct 79 | { 80 | /** 81 | * @brief The type of the memory operand. 82 | */ 83 | ZydisMemoryOperandType type; 84 | /** 85 | * @brief The segment register. 86 | */ 87 | ZydisRegister segment; 88 | /** 89 | * @brief The base register. 90 | */ 91 | ZydisRegister base; 92 | /** 93 | * @brief The index register. 94 | */ 95 | ZydisRegister index; 96 | /** 97 | * @brief The scale factor. 98 | */ 99 | ZydisU8 scale; 100 | /** 101 | * @brief Extended info for memory-operands with displacement. 102 | */ 103 | struct 104 | { 105 | /** 106 | * @brief Signals, if the displacement value is used. 107 | */ 108 | ZydisBool hasDisplacement; 109 | /** 110 | * @brief The displacement value 111 | */ 112 | ZydisI64 value; 113 | } disp; 114 | } mem; 115 | /** 116 | * @brief Extended info for pointer-operands. 117 | */ 118 | struct 119 | { 120 | ZydisU16 segment; 121 | ZydisU32 offset; 122 | } ptr; 123 | /** 124 | * @brief Extended info for immediate-operands. 125 | */ 126 | struct 127 | { 128 | /** 129 | * @brief Signals, if the immediate value is signed. 130 | */ 131 | ZydisBool isSigned; 132 | /** 133 | * @brief Signals, if the immediate value contains a relative offset. You can use 134 | * @c ZydisCalcAbsoluteAddress to determine the absolute address value. 135 | */ 136 | ZydisBool isRelative; 137 | /** 138 | * @brief The immediate value. 139 | */ 140 | union 141 | { 142 | ZydisU64 u; 143 | ZydisI64 s; 144 | } value; 145 | } imm; 146 | } ZydisDecodedOperand; 147 | ]] 148 | 149 | ffi.cdef[[ 150 | typedef ZydisU64 ZydisInstructionAttributes; 151 | ]] 152 | 153 | 154 | -- The instruction has the ModRM byte. 155 | local ZYDIS_INSTRUCTION_ATTRIBUTE = { 156 | ZYDIS_ATTRIB_HAS_MODRM = 0x0000000000000001ULL; -- (1 << 0) 157 | ZYDIS_ATTRIB_HAS_SIB = 0x0000000000000002; --(1 << 1) 158 | ZYDIS_ATTRIB_HAS_REX = 0x0000000000000004; --(1 << 2) 159 | ZYDIS_ATTRIB_HAS_XOP = 0x0000000000000008; --(1 << 3) 160 | ZYDIS_ATTRIB_HAS_VEX = 0x0000000000000010; --(1 << 4) 161 | ZYDIS_ATTRIB_HAS_EVEX = 0x0000000000000020; --(1 << 5) 162 | ZYDIS_ATTRIB_HAS_MVEX = 0x0000000000000040; --(1 << 6) 163 | ZYDIS_ATTRIB_IS_RELATIVE = 0x0000000000000080; --(1 << 7) 164 | ZYDIS_ATTRIB_IS_PRIVILEGED = 0x0000000000000100; --(1 << 8) 165 | ZYDIS_ATTRIB_IS_FAR_BRANCH = 0x0000001000000000; --(1 << 36); 166 | ZYDIS_ATTRIB_ACCEPTS_LOCK = 0x0000000000000200; --(1 << 9) 167 | ZYDIS_ATTRIB_ACCEPTS_REP = 0x0000000000000400; --(1 << 10) 168 | ZYDIS_ATTRIB_ACCEPTS_REPE = 0x0000000000000800; --(1 << 11) 169 | ZYDIS_ATTRIB_ACCEPTS_REPZ = 0x0000000000000800; --(1 << 11) 170 | ZYDIS_ATTRIB_ACCEPTS_REPNE = 0x0000000000001000; --(1 << 12) 171 | ZYDIS_ATTRIB_ACCEPTS_REPNZ = 0x0000000000001000; --(1 << 12) 172 | ZYDIS_ATTRIB_ACCEPTS_BOUND = 0x0000000000002000; --(1 << 13) 173 | ZYDIS_ATTRIB_ACCEPTS_XACQUIRE = 0x0000000000004000; --(1 << 14) 174 | ZYDIS_ATTRIB_ACCEPTS_XRELEASE = 0x0000000000008000; --(1 << 15) 175 | ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK = 0x0000000000010000; --(1 << 16) 176 | ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS = 0x0000000000020000; --(1 << 17) 177 | ZYDIS_ATTRIB_ACCEPTS_SEGMENT = 0x0000000000040000; --(1 << 18) 178 | ZYDIS_ATTRIB_HAS_LOCK = 0x0000000000080000; --(1 << 19) 179 | ZYDIS_ATTRIB_HAS_REP = 0x0000000000100000; --(1 << 20) 180 | ZYDIS_ATTRIB_HAS_REPE = 0x0000000000200000; --(1 << 21) 181 | ZYDIS_ATTRIB_HAS_REPZ = 0x0000000000200000; --(1 << 21) 182 | ZYDIS_ATTRIB_HAS_REPNE = 0x0000000000400000; --(1 << 22) 183 | ZYDIS_ATTRIB_HAS_REPNZ = 0x0000000000400000; --(1 << 22) 184 | ZYDIS_ATTRIB_HAS_BOUND = 0x0000000000800000; --(1 << 23) 185 | ZYDIS_ATTRIB_HAS_XACQUIRE = 0x0000000001000000; --(1 << 24) 186 | ZYDIS_ATTRIB_HAS_XRELEASE = 0x0000000002000000; --(1 << 25) 187 | ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN = 0x0000000004000000; --(1 << 26) 188 | ZYDIS_ATTRIB_HAS_BRANCH_TAKEN = 0x0000000008000000; --(1 << 27) 189 | ZYDIS_ATTRIB_HAS_SEGMENT = 0x00000003F0000000; 190 | ZYDIS_ATTRIB_HAS_SEGMENT_CS = 0x0000000010000000; --(1 << 28) 191 | ZYDIS_ATTRIB_HAS_SEGMENT_SS = 0x0000000020000000; --(1 << 29) 192 | ZYDIS_ATTRIB_HAS_SEGMENT_DS = 0x0000000040000000; --(1 << 30) 193 | ZYDIS_ATTRIB_HAS_SEGMENT_ES = 0x0000000080000000; --(1 << 31) 194 | ZYDIS_ATTRIB_HAS_SEGMENT_FS = 0x0000000100000000; --(1 << 32) 195 | ZYDIS_ATTRIB_HAS_SEGMENT_GS = 0x0000000200000000; --(1 << 33) 196 | ZYDIS_ATTRIB_HAS_OPERANDSIZE = 0x0000000400000000; --(1 << 34); 197 | ZYDIS_ATTRIB_HAS_ADDRESSSIZE = 0x0000000800000000; --(1 << 35); 198 | } 199 | 200 | ffi.cdef[[ 201 | typedef ZydisU8 ZydisCPUFlag; 202 | 203 | typedef ZydisU32 ZydisCPUFlagMask; 204 | 205 | 206 | enum ZydisCPUFlags 207 | { 208 | ZYDIS_CPUFLAG_CF, 209 | ZYDIS_CPUFLAG_PF, 210 | ZYDIS_CPUFLAG_AF, 211 | ZYDIS_CPUFLAG_ZF, 212 | ZYDIS_CPUFLAG_SF, 213 | ZYDIS_CPUFLAG_TF, 214 | ZYDIS_CPUFLAG_IF, 215 | ZYDIS_CPUFLAG_DF, 216 | ZYDIS_CPUFLAG_OF, 217 | ZYDIS_CPUFLAG_IOPL, 218 | ZYDIS_CPUFLAG_NT, 219 | ZYDIS_CPUFLAG_RF, 220 | ZYDIS_CPUFLAG_VM, 221 | ZYDIS_CPUFLAG_AC, 222 | ZYDIS_CPUFLAG_VIF, 223 | ZYDIS_CPUFLAG_VIP, 224 | ZYDIS_CPUFLAG_ID, 225 | ZYDIS_CPUFLAG_C0, 226 | ZYDIS_CPUFLAG_C1, 227 | ZYDIS_CPUFLAG_C2, 228 | ZYDIS_CPUFLAG_C3, 229 | 230 | 231 | ZYDIS_CPUFLAG_MAX_VALUE = ZYDIS_CPUFLAG_C3 232 | }; 233 | ]] 234 | 235 | ffi.cdef[[ 236 | 237 | typedef ZydisU8 ZydisCPUFlagAction; 238 | 239 | 240 | enum ZydisCPUFlagActions 241 | { 242 | ZYDIS_CPUFLAG_ACTION_NONE, 243 | ZYDIS_CPUFLAG_ACTION_TESTED, 244 | ZYDIS_CPUFLAG_ACTION_TESTED_MODIFIED, 245 | ZYDIS_CPUFLAG_ACTION_MODIFIED, 246 | ZYDIS_CPUFLAG_ACTION_SET_0, 247 | ZYDIS_CPUFLAG_ACTION_SET_1, 248 | ZYDIS_CPUFLAG_ACTION_UNDEFINED, 249 | 250 | ZYDIS_CPUFLAG_ACTION_MAX_VALUE = ZYDIS_CPUFLAG_ACTION_UNDEFINED 251 | }; 252 | ]] 253 | 254 | ffi.cdef[[ 255 | typedef ZydisU8 ZydisExceptionClass; 256 | 257 | enum ZydisExceptionClasses 258 | { 259 | ZYDIS_EXCEPTION_CLASS_NONE, 260 | // TODO: FP Exceptions 261 | ZYDIS_EXCEPTION_CLASS_SSE1, 262 | ZYDIS_EXCEPTION_CLASS_SSE2, 263 | ZYDIS_EXCEPTION_CLASS_SSE3, 264 | ZYDIS_EXCEPTION_CLASS_SSE4, 265 | ZYDIS_EXCEPTION_CLASS_SSE5, 266 | ZYDIS_EXCEPTION_CLASS_SSE7, 267 | ZYDIS_EXCEPTION_CLASS_AVX1, 268 | ZYDIS_EXCEPTION_CLASS_AVX2, 269 | ZYDIS_EXCEPTION_CLASS_AVX3, 270 | ZYDIS_EXCEPTION_CLASS_AVX4, 271 | ZYDIS_EXCEPTION_CLASS_AVX5, 272 | ZYDIS_EXCEPTION_CLASS_AVX6, 273 | ZYDIS_EXCEPTION_CLASS_AVX7, 274 | ZYDIS_EXCEPTION_CLASS_AVX8, 275 | ZYDIS_EXCEPTION_CLASS_AVX11, 276 | ZYDIS_EXCEPTION_CLASS_AVX12, 277 | ZYDIS_EXCEPTION_CLASS_E1, 278 | ZYDIS_EXCEPTION_CLASS_E1NF, 279 | ZYDIS_EXCEPTION_CLASS_E2, 280 | ZYDIS_EXCEPTION_CLASS_E2NF, 281 | ZYDIS_EXCEPTION_CLASS_E3, 282 | ZYDIS_EXCEPTION_CLASS_E3NF, 283 | ZYDIS_EXCEPTION_CLASS_E4, 284 | ZYDIS_EXCEPTION_CLASS_E4NF, 285 | ZYDIS_EXCEPTION_CLASS_E5, 286 | ZYDIS_EXCEPTION_CLASS_E5NF, 287 | ZYDIS_EXCEPTION_CLASS_E6, 288 | ZYDIS_EXCEPTION_CLASS_E6NF, 289 | ZYDIS_EXCEPTION_CLASS_E7NM, 290 | ZYDIS_EXCEPTION_CLASS_E7NM128, 291 | ZYDIS_EXCEPTION_CLASS_E9NF, 292 | ZYDIS_EXCEPTION_CLASS_E10, 293 | ZYDIS_EXCEPTION_CLASS_E10NF, 294 | ZYDIS_EXCEPTION_CLASS_E11, 295 | ZYDIS_EXCEPTION_CLASS_E11NF, 296 | ZYDIS_EXCEPTION_CLASS_E12, 297 | ZYDIS_EXCEPTION_CLASS_E12NP, 298 | ZYDIS_EXCEPTION_CLASS_K20, 299 | ZYDIS_EXCEPTION_CLASS_K21, 300 | 301 | ZYDIS_EXCEPTION_CLASS_MAX_VALUE = ZYDIS_EXCEPTION_CLASS_K21 302 | }; 303 | ]] 304 | 305 | ffi.cdef[[ 306 | typedef ZydisU16 ZydisVectorLength; 307 | 308 | enum ZydisVectorLengths 309 | { 310 | ZYDIS_VECTOR_LENGTH_INVALID = 0, 311 | ZYDIS_VECTOR_LENGTH_128 = 128, 312 | ZYDIS_VECTOR_LENGTH_256 = 256, 313 | ZYDIS_VECTOR_LENGTH_512 = 512, 314 | 315 | ZYDIS_VECTOR_LENGTH_MAX_VALUE = ZYDIS_VECTOR_LENGTH_512 316 | }; 317 | ]] 318 | 319 | ffi.cdef[[ 320 | typedef ZydisU8 ZydisMaskMode; 321 | 322 | 323 | enum ZydisMaskModes 324 | { 325 | ZYDIS_MASK_MODE_INVALID, 326 | ZYDIS_MASK_MODE_MERGE, 327 | ZYDIS_MASK_MODE_ZERO, 328 | 329 | ZYDIS_MASK_MODE_MAX_VALUE = ZYDIS_MASK_MODE_ZERO 330 | }; 331 | ]] 332 | 333 | ffi.cdef[[ 334 | typedef ZydisU8 ZydisBroadcastMode; 335 | 336 | enum ZydisBroadcastModes 337 | { 338 | ZYDIS_BROADCAST_MODE_INVALID, 339 | ZYDIS_BROADCAST_MODE_1_TO_2, 340 | ZYDIS_BROADCAST_MODE_1_TO_4, 341 | ZYDIS_BROADCAST_MODE_1_TO_8, 342 | ZYDIS_BROADCAST_MODE_1_TO_16, 343 | ZYDIS_BROADCAST_MODE_1_TO_32, 344 | ZYDIS_BROADCAST_MODE_1_TO_64, 345 | ZYDIS_BROADCAST_MODE_2_TO_4, 346 | ZYDIS_BROADCAST_MODE_2_TO_8, 347 | ZYDIS_BROADCAST_MODE_2_TO_16, 348 | ZYDIS_BROADCAST_MODE_4_TO_8, 349 | ZYDIS_BROADCAST_MODE_4_TO_16, 350 | ZYDIS_BROADCAST_MODE_8_TO_16, 351 | 352 | ZYDIS_BROADCAST_MODE_MAX_VALUE = ZYDIS_BROADCAST_MODE_8_TO_16 353 | }; 354 | ]] 355 | 356 | ffi.cdef[[ 357 | typedef ZydisU8 ZydisRoundingMode; 358 | 359 | enum ZydisRoundingModes 360 | { 361 | ZYDIS_ROUNDING_MODE_INVALID, 362 | ZYDIS_ROUNDING_MODE_RN, 363 | ZYDIS_ROUNDING_MODE_RD, 364 | ZYDIS_ROUNDING_MODE_RU, 365 | ZYDIS_ROUNDING_MODE_RZ, 366 | 367 | ZYDIS_ROUNDING_MODE_MAX_VALUE = ZYDIS_ROUNDING_MODE_RZ 368 | }; 369 | ]] 370 | 371 | ffi.cdef[[ 372 | typedef ZydisU8 ZydisSwizzleMode; 373 | 374 | enum ZydisSwizzleModes 375 | { 376 | ZYDIS_SWIZZLE_MODE_INVALID, 377 | ZYDIS_SWIZZLE_MODE_DCBA, 378 | ZYDIS_SWIZZLE_MODE_CDAB, 379 | ZYDIS_SWIZZLE_MODE_BADC, 380 | ZYDIS_SWIZZLE_MODE_DACB, 381 | ZYDIS_SWIZZLE_MODE_AAAA, 382 | ZYDIS_SWIZZLE_MODE_BBBB, 383 | ZYDIS_SWIZZLE_MODE_CCCC, 384 | ZYDIS_SWIZZLE_MODE_DDDD, 385 | 386 | ZYDIS_SWIZZLE_MODE_MAX_VALUE = ZYDIS_SWIZZLE_MODE_DDDD 387 | }; 388 | ]] 389 | 390 | ffi.cdef[[ 391 | 392 | typedef ZydisU8 ZydisConversionMode; 393 | 394 | enum ZydisConversionModes 395 | { 396 | ZYDIS_CONVERSION_MODE_INVALID, 397 | ZYDIS_CONVERSION_MODE_FLOAT16, 398 | ZYDIS_CONVERSION_MODE_SINT8, 399 | ZYDIS_CONVERSION_MODE_UINT8, 400 | ZYDIS_CONVERSION_MODE_SINT16, 401 | ZYDIS_CONVERSION_MODE_UINT16, 402 | 403 | ZYDIS_CONVERSION_MODE_MAX_VALUE = ZYDIS_CONVERSION_MODE_UINT16 404 | }; 405 | ]] 406 | 407 | ffi.cdef[[ 408 | typedef struct ZydisDecodedInstruction_ 409 | { 410 | ZydisMachineMode machineMode; 411 | ZydisMnemonic mnemonic; 412 | ZydisU8 length; 413 | ZydisU8 data[ZYDIS_MAX_INSTRUCTION_LENGTH]; 414 | ZydisInstructionEncoding encoding; 415 | ZydisOpcodeMap opcodeMap; 416 | ZydisU8 opcode; 417 | ZydisU8 stackWidth; 418 | ZydisU8 operandWidth; 419 | ZydisU8 addressWidth; 420 | ZydisU8 operandCount; 421 | ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT]; 422 | ZydisInstructionAttributes attributes; 423 | ZydisU64 instrAddress; 424 | 425 | struct 426 | { 427 | ZydisCPUFlagAction action; 428 | } accessedFlags[ZYDIS_CPUFLAG_MAX_VALUE + 1]; 429 | 430 | struct 431 | { 432 | ZydisVectorLength vectorLength; 433 | 434 | struct 435 | { 436 | ZydisMaskMode mode; 437 | ZydisRegister reg; 438 | ZydisBool isControlMask; 439 | } mask; 440 | 441 | struct 442 | { 443 | ZydisBool isStatic; 444 | ZydisBroadcastMode mode; 445 | } broadcast; 446 | 447 | struct 448 | { 449 | ZydisRoundingMode mode; 450 | } rounding; 451 | 452 | struct 453 | { 454 | ZydisSwizzleMode mode; 455 | } swizzle; 456 | 457 | struct 458 | { 459 | ZydisConversionMode mode; 460 | } conversion; 461 | 462 | ZydisBool hasSAE; 463 | ZydisBool hasEvictionHint; 464 | } avx; 465 | 466 | struct 467 | { 468 | ZydisInstructionCategory category; 469 | ZydisISASet isaSet; 470 | ZydisISAExt isaExt; 471 | ZydisExceptionClass exceptionClass; 472 | } meta; 473 | 474 | struct 475 | { 476 | struct 477 | { 478 | ZydisU8 data[ZYDIS_MAX_INSTRUCTION_LENGTH - 1]; 479 | ZydisU8 count; 480 | ZydisU8 hasF0; 481 | ZydisU8 hasF3; 482 | ZydisU8 hasF2; 483 | ZydisU8 has2E; 484 | ZydisU8 has36; 485 | ZydisU8 has3E; 486 | ZydisU8 has26; 487 | ZydisU8 has64; 488 | ZydisU8 has65; 489 | ZydisU8 has66; 490 | ZydisU8 has67; 491 | } prefixes; 492 | 493 | struct 494 | { 495 | ZydisBool isDecoded; 496 | ZydisU8 data[1]; 497 | ZydisU8 W; 498 | ZydisU8 R; 499 | ZydisU8 X; 500 | ZydisU8 B; 501 | } rex; 502 | 503 | struct 504 | { 505 | ZydisBool isDecoded; 506 | ZydisU8 data[3]; 507 | ZydisU8 R; 508 | ZydisU8 X; 509 | ZydisU8 B; 510 | ZydisU8 m_mmmm; 511 | ZydisU8 W; 512 | ZydisU8 vvvv; 513 | ZydisU8 L; 514 | ZydisU8 pp; 515 | } xop; 516 | 517 | struct 518 | { 519 | ZydisBool isDecoded; 520 | ZydisU8 data[3]; 521 | ZydisU8 R; 522 | ZydisU8 X; 523 | ZydisU8 B; 524 | ZydisU8 m_mmmm; 525 | ZydisU8 W; 526 | ZydisU8 vvvv; 527 | ZydisU8 L; 528 | ZydisU8 pp; 529 | } vex; 530 | 531 | struct 532 | { 533 | ZydisBool isDecoded; 534 | ZydisU8 data[4]; 535 | ZydisU8 R; 536 | ZydisU8 X; 537 | ZydisU8 B; 538 | ZydisU8 R2; 539 | ZydisU8 mm; 540 | ZydisU8 W; 541 | ZydisU8 vvvv; 542 | ZydisU8 pp; 543 | ZydisU8 z; 544 | ZydisU8 L2; 545 | ZydisU8 L; 546 | ZydisU8 b; 547 | ZydisU8 V2; 548 | ZydisU8 aaa; 549 | } evex; 550 | 551 | struct 552 | { 553 | ZydisBool isDecoded; 554 | ZydisU8 data[4]; 555 | ZydisU8 R; 556 | ZydisU8 X; 557 | ZydisU8 B; 558 | ZydisU8 R2; 559 | ZydisU8 mmmm; 560 | ZydisU8 W; 561 | ZydisU8 vvvv; 562 | ZydisU8 pp; 563 | ZydisU8 E; 564 | ZydisU8 SSS; 565 | ZydisU8 V2; 566 | ZydisU8 kkk; 567 | } mvex; 568 | 569 | struct 570 | { 571 | ZydisBool isDecoded; 572 | ZydisU8 data[1]; 573 | ZydisU8 mod; 574 | ZydisU8 reg; 575 | ZydisU8 rm; 576 | } modrm; 577 | 578 | struct 579 | { 580 | ZydisBool isDecoded; 581 | ZydisU8 data[1]; 582 | ZydisU8 scale; 583 | ZydisU8 index; 584 | ZydisU8 base; 585 | } sib; 586 | 587 | struct 588 | { 589 | ZydisI64 value; 590 | ZydisU8 size; 591 | ZydisU8 offset; 592 | } disp; 593 | 594 | struct 595 | { 596 | ZydisBool isSigned; 597 | ZydisBool isRelative; 598 | 599 | union 600 | { 601 | ZydisU64 u; 602 | ZydisI64 s; 603 | } value; 604 | 605 | ZydisU8 size; 606 | ZydisU8 offset; 607 | } imm[2]; 608 | } raw; 609 | } ZydisDecodedInstruction; 610 | ]] 611 | -------------------------------------------------------------------------------- /lj2zydis/ffi/EnumISAExt.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | /** 7 | * @brief Defines the `ZydisISAExt` datatype. 8 | */ 9 | typedef ZydisU8 ZydisISAExt; 10 | 11 | /** 12 | * @brief Values that represent `ZydisISAExt` elements. 13 | */ 14 | enum ZydisISAExts 15 | { 16 | ZYDIS_ISA_EXT_INVALID, 17 | ZYDIS_ISA_EXT_ADOX_ADCX, 18 | ZYDIS_ISA_EXT_AES, 19 | ZYDIS_ISA_EXT_AMD, 20 | ZYDIS_ISA_EXT_AMD3DNOW, 21 | ZYDIS_ISA_EXT_AVX, 22 | ZYDIS_ISA_EXT_AVX2, 23 | ZYDIS_ISA_EXT_AVX2GATHER, 24 | ZYDIS_ISA_EXT_AVX512BW_128, 25 | ZYDIS_ISA_EXT_AVX512BW_128N, 26 | ZYDIS_ISA_EXT_AVX512BW_256, 27 | ZYDIS_ISA_EXT_AVX512BW_512, 28 | ZYDIS_ISA_EXT_AVX512BW_KOP, 29 | ZYDIS_ISA_EXT_AVX512CD_128, 30 | ZYDIS_ISA_EXT_AVX512CD_256, 31 | ZYDIS_ISA_EXT_AVX512CD_512, 32 | ZYDIS_ISA_EXT_AVX512DQ_128, 33 | ZYDIS_ISA_EXT_AVX512DQ_128N, 34 | ZYDIS_ISA_EXT_AVX512DQ_256, 35 | ZYDIS_ISA_EXT_AVX512DQ_512, 36 | ZYDIS_ISA_EXT_AVX512DQ_KOP, 37 | ZYDIS_ISA_EXT_AVX512DQ_SCALAR, 38 | ZYDIS_ISA_EXT_AVX512ER_512, 39 | ZYDIS_ISA_EXT_AVX512ER_SCALAR, 40 | ZYDIS_ISA_EXT_AVX512F_128, 41 | ZYDIS_ISA_EXT_AVX512F_128N, 42 | ZYDIS_ISA_EXT_AVX512F_256, 43 | ZYDIS_ISA_EXT_AVX512F_512, 44 | ZYDIS_ISA_EXT_AVX512F_KOP, 45 | ZYDIS_ISA_EXT_AVX512F_SCALAR, 46 | ZYDIS_ISA_EXT_AVX512PF_512, 47 | ZYDIS_ISA_EXT_AVX512_4FMAPS_512, 48 | ZYDIS_ISA_EXT_AVX512_4FMAPS_SCALAR, 49 | ZYDIS_ISA_EXT_AVX512_4VNNIW_512, 50 | ZYDIS_ISA_EXT_AVX512_BITALG_128, 51 | ZYDIS_ISA_EXT_AVX512_BITALG_256, 52 | ZYDIS_ISA_EXT_AVX512_BITALG_512, 53 | ZYDIS_ISA_EXT_AVX512_GFNI_128, 54 | ZYDIS_ISA_EXT_AVX512_GFNI_256, 55 | ZYDIS_ISA_EXT_AVX512_GFNI_512, 56 | ZYDIS_ISA_EXT_AVX512_IFMA_128, 57 | ZYDIS_ISA_EXT_AVX512_IFMA_256, 58 | ZYDIS_ISA_EXT_AVX512_IFMA_512, 59 | ZYDIS_ISA_EXT_AVX512_VAES_128, 60 | ZYDIS_ISA_EXT_AVX512_VAES_256, 61 | ZYDIS_ISA_EXT_AVX512_VAES_512, 62 | ZYDIS_ISA_EXT_AVX512_VBMI2_128, 63 | ZYDIS_ISA_EXT_AVX512_VBMI2_256, 64 | ZYDIS_ISA_EXT_AVX512_VBMI2_512, 65 | ZYDIS_ISA_EXT_AVX512_VBMI_128, 66 | ZYDIS_ISA_EXT_AVX512_VBMI_256, 67 | ZYDIS_ISA_EXT_AVX512_VBMI_512, 68 | ZYDIS_ISA_EXT_AVX512_VNNI_128, 69 | ZYDIS_ISA_EXT_AVX512_VNNI_256, 70 | ZYDIS_ISA_EXT_AVX512_VNNI_512, 71 | ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_128, 72 | ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_256, 73 | ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_512, 74 | ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_128, 75 | ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_256, 76 | ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_512, 77 | ZYDIS_ISA_EXT_AVXAES, 78 | ZYDIS_ISA_EXT_AVX_GFNI, 79 | ZYDIS_ISA_EXT_BMI1, 80 | ZYDIS_ISA_EXT_BMI2, 81 | ZYDIS_ISA_EXT_CET, 82 | ZYDIS_ISA_EXT_CLFLUSHOPT, 83 | ZYDIS_ISA_EXT_CLFSH, 84 | ZYDIS_ISA_EXT_CLWB, 85 | ZYDIS_ISA_EXT_CLZERO, 86 | ZYDIS_ISA_EXT_CMOV, 87 | ZYDIS_ISA_EXT_CMPXCHG16B, 88 | ZYDIS_ISA_EXT_F16C, 89 | ZYDIS_ISA_EXT_FAT_NOP, 90 | ZYDIS_ISA_EXT_FCMOV, 91 | ZYDIS_ISA_EXT_FMA, 92 | ZYDIS_ISA_EXT_FMA4, 93 | ZYDIS_ISA_EXT_FXSAVE, 94 | ZYDIS_ISA_EXT_FXSAVE64, 95 | ZYDIS_ISA_EXT_GFNI, 96 | ZYDIS_ISA_EXT_I186, 97 | ZYDIS_ISA_EXT_I286PROTECTED, 98 | ZYDIS_ISA_EXT_I286REAL, 99 | ZYDIS_ISA_EXT_I386, 100 | ZYDIS_ISA_EXT_I486, 101 | ZYDIS_ISA_EXT_I486REAL, 102 | ZYDIS_ISA_EXT_I86, 103 | ZYDIS_ISA_EXT_INVPCID, 104 | ZYDIS_ISA_EXT_KNCE, 105 | ZYDIS_ISA_EXT_KNCJKBR, 106 | ZYDIS_ISA_EXT_KNCSTREAM, 107 | ZYDIS_ISA_EXT_KNCV, 108 | ZYDIS_ISA_EXT_KNC_MISC, 109 | ZYDIS_ISA_EXT_KNC_PF_HINT, 110 | ZYDIS_ISA_EXT_LAHF, 111 | ZYDIS_ISA_EXT_LONGMODE, 112 | ZYDIS_ISA_EXT_LZCNT, 113 | ZYDIS_ISA_EXT_MONITOR, 114 | ZYDIS_ISA_EXT_MONITORX, 115 | ZYDIS_ISA_EXT_MOVBE, 116 | ZYDIS_ISA_EXT_MPX, 117 | ZYDIS_ISA_EXT_PAUSE, 118 | ZYDIS_ISA_EXT_PCLMULQDQ, 119 | ZYDIS_ISA_EXT_PCONFIG, 120 | ZYDIS_ISA_EXT_PENTIUMMMX, 121 | ZYDIS_ISA_EXT_PENTIUMREAL, 122 | ZYDIS_ISA_EXT_PKU, 123 | ZYDIS_ISA_EXT_POPCNT, 124 | ZYDIS_ISA_EXT_PPRO, 125 | ZYDIS_ISA_EXT_PREFETCHWT1, 126 | ZYDIS_ISA_EXT_PREFETCH_NOP, 127 | ZYDIS_ISA_EXT_PT, 128 | ZYDIS_ISA_EXT_RDPID, 129 | ZYDIS_ISA_EXT_RDPMC, 130 | ZYDIS_ISA_EXT_RDRAND, 131 | ZYDIS_ISA_EXT_RDSEED, 132 | ZYDIS_ISA_EXT_RDTSCP, 133 | ZYDIS_ISA_EXT_RDWRFSGS, 134 | ZYDIS_ISA_EXT_RTM, 135 | ZYDIS_ISA_EXT_SGX, 136 | ZYDIS_ISA_EXT_SGX_ENCLV, 137 | ZYDIS_ISA_EXT_SHA, 138 | ZYDIS_ISA_EXT_SMAP, 139 | ZYDIS_ISA_EXT_SMX, 140 | ZYDIS_ISA_EXT_SSE, 141 | ZYDIS_ISA_EXT_SSE2, 142 | ZYDIS_ISA_EXT_SSE2MMX, 143 | ZYDIS_ISA_EXT_SSE3, 144 | ZYDIS_ISA_EXT_SSE3X87, 145 | ZYDIS_ISA_EXT_SSE4, 146 | ZYDIS_ISA_EXT_SSE42, 147 | ZYDIS_ISA_EXT_SSE4A, 148 | ZYDIS_ISA_EXT_SSEMXCSR, 149 | ZYDIS_ISA_EXT_SSE_PREFETCH, 150 | ZYDIS_ISA_EXT_SSSE3, 151 | ZYDIS_ISA_EXT_SSSE3MMX, 152 | ZYDIS_ISA_EXT_SVM, 153 | ZYDIS_ISA_EXT_TBM, 154 | ZYDIS_ISA_EXT_VAES, 155 | ZYDIS_ISA_EXT_VMFUNC, 156 | ZYDIS_ISA_EXT_VPCLMULQDQ, 157 | ZYDIS_ISA_EXT_VTX, 158 | ZYDIS_ISA_EXT_X87, 159 | ZYDIS_ISA_EXT_XOP, 160 | ZYDIS_ISA_EXT_XSAVE, 161 | ZYDIS_ISA_EXT_XSAVEC, 162 | ZYDIS_ISA_EXT_XSAVEOPT, 163 | ZYDIS_ISA_EXT_XSAVES, 164 | 165 | /** 166 | * @brief Maximum value of this enum. 167 | */ 168 | ZYDIS_ISA_EXT_MAX_VALUE = ZYDIS_ISA_EXT_XSAVES, 169 | /** 170 | * @brief Minimum amount of bits required to store a value of this enum. 171 | */ 172 | ZYDIS_ISA_EXT_MIN_BITS = 0x0008 173 | }; 174 | ]] -------------------------------------------------------------------------------- /lj2zydis/ffi/EnumISASet.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | typedef ZydisU8 ZydisISASet; 7 | 8 | enum ZydisISASets 9 | { 10 | ZYDIS_ISA_SET_INVALID, 11 | ZYDIS_ISA_SET_ADOX_ADCX, 12 | ZYDIS_ISA_SET_AES, 13 | ZYDIS_ISA_SET_AMD3DNOW, 14 | ZYDIS_ISA_SET_AVX, 15 | ZYDIS_ISA_SET_AVX2, 16 | ZYDIS_ISA_SET_AVX2GATHER, 17 | ZYDIS_ISA_SET_AVX512EVEX, 18 | ZYDIS_ISA_SET_AVX512VEX, 19 | ZYDIS_ISA_SET_AVXAES, 20 | ZYDIS_ISA_SET_BASE, 21 | ZYDIS_ISA_SET_BMI1, 22 | ZYDIS_ISA_SET_BMI2, 23 | ZYDIS_ISA_SET_CET, 24 | ZYDIS_ISA_SET_CLFLUSHOPT, 25 | ZYDIS_ISA_SET_CLFSH, 26 | ZYDIS_ISA_SET_CLWB, 27 | ZYDIS_ISA_SET_CLZERO, 28 | ZYDIS_ISA_SET_F16C, 29 | ZYDIS_ISA_SET_FMA, 30 | ZYDIS_ISA_SET_FMA4, 31 | ZYDIS_ISA_SET_GFNI, 32 | ZYDIS_ISA_SET_INVPCID, 33 | ZYDIS_ISA_SET_KNC, 34 | ZYDIS_ISA_SET_KNCE, 35 | ZYDIS_ISA_SET_KNCV, 36 | ZYDIS_ISA_SET_LONGMODE, 37 | ZYDIS_ISA_SET_LZCNT, 38 | ZYDIS_ISA_SET_MMX, 39 | ZYDIS_ISA_SET_MONITOR, 40 | ZYDIS_ISA_SET_MONITORX, 41 | ZYDIS_ISA_SET_MOVBE, 42 | ZYDIS_ISA_SET_MPX, 43 | ZYDIS_ISA_SET_PAUSE, 44 | ZYDIS_ISA_SET_PCLMULQDQ, 45 | ZYDIS_ISA_SET_PCONFIG, 46 | ZYDIS_ISA_SET_PKU, 47 | ZYDIS_ISA_SET_PREFETCHWT1, 48 | ZYDIS_ISA_SET_PT, 49 | ZYDIS_ISA_SET_RDPID, 50 | ZYDIS_ISA_SET_RDRAND, 51 | ZYDIS_ISA_SET_RDSEED, 52 | ZYDIS_ISA_SET_RDTSCP, 53 | ZYDIS_ISA_SET_RDWRFSGS, 54 | ZYDIS_ISA_SET_RTM, 55 | ZYDIS_ISA_SET_SGX, 56 | ZYDIS_ISA_SET_SGX_ENCLV, 57 | ZYDIS_ISA_SET_SHA, 58 | ZYDIS_ISA_SET_SMAP, 59 | ZYDIS_ISA_SET_SMX, 60 | ZYDIS_ISA_SET_SSE, 61 | ZYDIS_ISA_SET_SSE2, 62 | ZYDIS_ISA_SET_SSE3, 63 | ZYDIS_ISA_SET_SSE4, 64 | ZYDIS_ISA_SET_SSE4A, 65 | ZYDIS_ISA_SET_SSSE3, 66 | ZYDIS_ISA_SET_SVM, 67 | ZYDIS_ISA_SET_TBM, 68 | ZYDIS_ISA_SET_VAES, 69 | ZYDIS_ISA_SET_VMFUNC, 70 | ZYDIS_ISA_SET_VPCLMULQDQ, 71 | ZYDIS_ISA_SET_VTX, 72 | ZYDIS_ISA_SET_X87, 73 | ZYDIS_ISA_SET_XOP, 74 | ZYDIS_ISA_SET_XSAVE, 75 | ZYDIS_ISA_SET_XSAVEC, 76 | ZYDIS_ISA_SET_XSAVEOPT, 77 | ZYDIS_ISA_SET_XSAVES, 78 | 79 | /** 80 | * @brief Maximum value of this enum. 81 | */ 82 | ZYDIS_ISA_SET_MAX_VALUE = ZYDIS_ISA_SET_XSAVES, 83 | /** 84 | * @brief Minimum amount of bits required to store a value of this enum. 85 | */ 86 | ZYDIS_ISA_SET_MIN_BITS = 0x0007 87 | }; 88 | ]] 89 | -------------------------------------------------------------------------------- /lj2zydis/ffi/EnumInstructionCategory.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | typedef ZydisU8 ZydisInstructionCategory; 7 | 8 | enum ZydisInstructionCategories 9 | { 10 | ZYDIS_CATEGORY_INVALID, 11 | ZYDIS_CATEGORY_ADOX_ADCX, 12 | ZYDIS_CATEGORY_AES, 13 | ZYDIS_CATEGORY_AMD3DNOW, 14 | ZYDIS_CATEGORY_AVX, 15 | ZYDIS_CATEGORY_AVX2, 16 | ZYDIS_CATEGORY_AVX2GATHER, 17 | ZYDIS_CATEGORY_AVX512, 18 | ZYDIS_CATEGORY_AVX512_4FMAPS, 19 | ZYDIS_CATEGORY_AVX512_4VNNIW, 20 | ZYDIS_CATEGORY_AVX512_BITALG, 21 | ZYDIS_CATEGORY_AVX512_VBMI, 22 | ZYDIS_CATEGORY_BINARY, 23 | ZYDIS_CATEGORY_BITBYTE, 24 | ZYDIS_CATEGORY_BLEND, 25 | ZYDIS_CATEGORY_BMI1, 26 | ZYDIS_CATEGORY_BMI2, 27 | ZYDIS_CATEGORY_BROADCAST, 28 | ZYDIS_CATEGORY_CALL, 29 | ZYDIS_CATEGORY_CET, 30 | ZYDIS_CATEGORY_CLFLUSHOPT, 31 | ZYDIS_CATEGORY_CLWB, 32 | ZYDIS_CATEGORY_CLZERO, 33 | ZYDIS_CATEGORY_CMOV, 34 | ZYDIS_CATEGORY_COMPRESS, 35 | ZYDIS_CATEGORY_COND_BR, 36 | ZYDIS_CATEGORY_CONFLICT, 37 | ZYDIS_CATEGORY_CONVERT, 38 | ZYDIS_CATEGORY_DATAXFER, 39 | ZYDIS_CATEGORY_DECIMAL, 40 | ZYDIS_CATEGORY_EXPAND, 41 | ZYDIS_CATEGORY_FCMOV, 42 | ZYDIS_CATEGORY_FLAGOP, 43 | ZYDIS_CATEGORY_FMA4, 44 | ZYDIS_CATEGORY_GATHER, 45 | ZYDIS_CATEGORY_GFNI, 46 | ZYDIS_CATEGORY_IFMA, 47 | ZYDIS_CATEGORY_INTERRUPT, 48 | ZYDIS_CATEGORY_IO, 49 | ZYDIS_CATEGORY_IOSTRINGOP, 50 | ZYDIS_CATEGORY_KMASK, 51 | ZYDIS_CATEGORY_KNC, 52 | ZYDIS_CATEGORY_KNCMASK, 53 | ZYDIS_CATEGORY_KNCSCALAR, 54 | ZYDIS_CATEGORY_LOGICAL, 55 | ZYDIS_CATEGORY_LOGICAL_FP, 56 | ZYDIS_CATEGORY_LZCNT, 57 | ZYDIS_CATEGORY_MISC, 58 | ZYDIS_CATEGORY_MMX, 59 | ZYDIS_CATEGORY_MPX, 60 | ZYDIS_CATEGORY_NOP, 61 | ZYDIS_CATEGORY_PCLMULQDQ, 62 | ZYDIS_CATEGORY_PCONFIG, 63 | ZYDIS_CATEGORY_PKU, 64 | ZYDIS_CATEGORY_POP, 65 | ZYDIS_CATEGORY_PREFETCH, 66 | ZYDIS_CATEGORY_PREFETCHWT1, 67 | ZYDIS_CATEGORY_PT, 68 | ZYDIS_CATEGORY_PUSH, 69 | ZYDIS_CATEGORY_RDPID, 70 | ZYDIS_CATEGORY_RDRAND, 71 | ZYDIS_CATEGORY_RDSEED, 72 | ZYDIS_CATEGORY_RDWRFSGS, 73 | ZYDIS_CATEGORY_RET, 74 | ZYDIS_CATEGORY_ROTATE, 75 | ZYDIS_CATEGORY_SCATTER, 76 | ZYDIS_CATEGORY_SEGOP, 77 | ZYDIS_CATEGORY_SEMAPHORE, 78 | ZYDIS_CATEGORY_SETCC, 79 | ZYDIS_CATEGORY_SGX, 80 | ZYDIS_CATEGORY_SHA, 81 | ZYDIS_CATEGORY_SHIFT, 82 | ZYDIS_CATEGORY_SMAP, 83 | ZYDIS_CATEGORY_SSE, 84 | ZYDIS_CATEGORY_STRINGOP, 85 | ZYDIS_CATEGORY_STTNI, 86 | ZYDIS_CATEGORY_SYSCALL, 87 | ZYDIS_CATEGORY_SYSRET, 88 | ZYDIS_CATEGORY_SYSTEM, 89 | ZYDIS_CATEGORY_TBM, 90 | ZYDIS_CATEGORY_UFMA, 91 | ZYDIS_CATEGORY_UNCOND_BR, 92 | ZYDIS_CATEGORY_VAES, 93 | ZYDIS_CATEGORY_VBMI2, 94 | ZYDIS_CATEGORY_VFMA, 95 | ZYDIS_CATEGORY_VPCLMULQDQ, 96 | ZYDIS_CATEGORY_VTX, 97 | ZYDIS_CATEGORY_WIDENOP, 98 | ZYDIS_CATEGORY_X87_ALU, 99 | ZYDIS_CATEGORY_XOP, 100 | ZYDIS_CATEGORY_XSAVE, 101 | ZYDIS_CATEGORY_XSAVEOPT, 102 | 103 | /** 104 | * @brief Maximum value of this enum. 105 | */ 106 | ZYDIS_CATEGORY_MAX_VALUE = ZYDIS_CATEGORY_XSAVEOPT, 107 | /** 108 | * @brief Minimum amount of bits required to store a value of this enum. 109 | */ 110 | ZYDIS_CATEGORY_MIN_BITS = 0x0007 111 | }; 112 | ]] -------------------------------------------------------------------------------- /lj2zydis/ffi/EnumMnemonic.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | /** 7 | * @brief Defines the `ZydisMnemonic` datatype. 8 | */ 9 | typedef ZydisU16 ZydisMnemonic; 10 | 11 | /** 12 | * @brief Values that represent `ZydisMnemonic` elements. 13 | */ 14 | enum ZydisMnemonics 15 | { 16 | ZYDIS_MNEMONIC_INVALID, 17 | ZYDIS_MNEMONIC_AAA, 18 | ZYDIS_MNEMONIC_AAD, 19 | ZYDIS_MNEMONIC_AAM, 20 | ZYDIS_MNEMONIC_AAS, 21 | ZYDIS_MNEMONIC_ADC, 22 | ZYDIS_MNEMONIC_ADCX, 23 | ZYDIS_MNEMONIC_ADD, 24 | ZYDIS_MNEMONIC_ADDPD, 25 | ZYDIS_MNEMONIC_ADDPS, 26 | ZYDIS_MNEMONIC_ADDSD, 27 | ZYDIS_MNEMONIC_ADDSS, 28 | ZYDIS_MNEMONIC_ADDSUBPD, 29 | ZYDIS_MNEMONIC_ADDSUBPS, 30 | ZYDIS_MNEMONIC_ADOX, 31 | ZYDIS_MNEMONIC_AESDEC, 32 | ZYDIS_MNEMONIC_AESDECLAST, 33 | ZYDIS_MNEMONIC_AESENC, 34 | ZYDIS_MNEMONIC_AESENCLAST, 35 | ZYDIS_MNEMONIC_AESIMC, 36 | ZYDIS_MNEMONIC_AESKEYGENASSIST, 37 | ZYDIS_MNEMONIC_AND, 38 | ZYDIS_MNEMONIC_ANDN, 39 | ZYDIS_MNEMONIC_ANDNPD, 40 | ZYDIS_MNEMONIC_ANDNPS, 41 | ZYDIS_MNEMONIC_ANDPD, 42 | ZYDIS_MNEMONIC_ANDPS, 43 | ZYDIS_MNEMONIC_ARPL, 44 | ZYDIS_MNEMONIC_BEXTR, 45 | ZYDIS_MNEMONIC_BLCFILL, 46 | ZYDIS_MNEMONIC_BLCI, 47 | ZYDIS_MNEMONIC_BLCIC, 48 | ZYDIS_MNEMONIC_BLCMSK, 49 | ZYDIS_MNEMONIC_BLCS, 50 | ZYDIS_MNEMONIC_BLENDPD, 51 | ZYDIS_MNEMONIC_BLENDPS, 52 | ZYDIS_MNEMONIC_BLENDVPD, 53 | ZYDIS_MNEMONIC_BLENDVPS, 54 | ZYDIS_MNEMONIC_BLSFILL, 55 | ZYDIS_MNEMONIC_BLSI, 56 | ZYDIS_MNEMONIC_BLSIC, 57 | ZYDIS_MNEMONIC_BLSMSK, 58 | ZYDIS_MNEMONIC_BLSR, 59 | ZYDIS_MNEMONIC_BNDCL, 60 | ZYDIS_MNEMONIC_BNDCN, 61 | ZYDIS_MNEMONIC_BNDCU, 62 | ZYDIS_MNEMONIC_BNDLDX, 63 | ZYDIS_MNEMONIC_BNDMK, 64 | ZYDIS_MNEMONIC_BNDMOV, 65 | ZYDIS_MNEMONIC_BNDSTX, 66 | ZYDIS_MNEMONIC_BOUND, 67 | ZYDIS_MNEMONIC_BSF, 68 | ZYDIS_MNEMONIC_BSR, 69 | ZYDIS_MNEMONIC_BSWAP, 70 | ZYDIS_MNEMONIC_BT, 71 | ZYDIS_MNEMONIC_BTC, 72 | ZYDIS_MNEMONIC_BTR, 73 | ZYDIS_MNEMONIC_BTS, 74 | ZYDIS_MNEMONIC_BZHI, 75 | ZYDIS_MNEMONIC_CALL, 76 | ZYDIS_MNEMONIC_CBW, 77 | ZYDIS_MNEMONIC_CDQ, 78 | ZYDIS_MNEMONIC_CDQE, 79 | ZYDIS_MNEMONIC_CLAC, 80 | ZYDIS_MNEMONIC_CLC, 81 | ZYDIS_MNEMONIC_CLD, 82 | ZYDIS_MNEMONIC_CLEVICT0, 83 | ZYDIS_MNEMONIC_CLEVICT1, 84 | ZYDIS_MNEMONIC_CLFLUSH, 85 | ZYDIS_MNEMONIC_CLFLUSHOPT, 86 | ZYDIS_MNEMONIC_CLGI, 87 | ZYDIS_MNEMONIC_CLI, 88 | ZYDIS_MNEMONIC_CLRSSBSY, 89 | ZYDIS_MNEMONIC_CLTS, 90 | ZYDIS_MNEMONIC_CLWB, 91 | ZYDIS_MNEMONIC_CLZERO, 92 | ZYDIS_MNEMONIC_CMC, 93 | ZYDIS_MNEMONIC_CMOVB, 94 | ZYDIS_MNEMONIC_CMOVBE, 95 | ZYDIS_MNEMONIC_CMOVL, 96 | ZYDIS_MNEMONIC_CMOVLE, 97 | ZYDIS_MNEMONIC_CMOVNB, 98 | ZYDIS_MNEMONIC_CMOVNBE, 99 | ZYDIS_MNEMONIC_CMOVNL, 100 | ZYDIS_MNEMONIC_CMOVNLE, 101 | ZYDIS_MNEMONIC_CMOVNO, 102 | ZYDIS_MNEMONIC_CMOVNP, 103 | ZYDIS_MNEMONIC_CMOVNS, 104 | ZYDIS_MNEMONIC_CMOVNZ, 105 | ZYDIS_MNEMONIC_CMOVO, 106 | ZYDIS_MNEMONIC_CMOVP, 107 | ZYDIS_MNEMONIC_CMOVS, 108 | ZYDIS_MNEMONIC_CMOVZ, 109 | ZYDIS_MNEMONIC_CMP, 110 | ZYDIS_MNEMONIC_CMPPD, 111 | ZYDIS_MNEMONIC_CMPPS, 112 | ZYDIS_MNEMONIC_CMPSB, 113 | ZYDIS_MNEMONIC_CMPSD, 114 | ZYDIS_MNEMONIC_CMPSQ, 115 | ZYDIS_MNEMONIC_CMPSS, 116 | ZYDIS_MNEMONIC_CMPSW, 117 | ZYDIS_MNEMONIC_CMPXCHG, 118 | ZYDIS_MNEMONIC_CMPXCHG16B, 119 | ZYDIS_MNEMONIC_CMPXCHG8B, 120 | ZYDIS_MNEMONIC_COMISD, 121 | ZYDIS_MNEMONIC_COMISS, 122 | ZYDIS_MNEMONIC_CPUID, 123 | ZYDIS_MNEMONIC_CQO, 124 | ZYDIS_MNEMONIC_CRC32, 125 | ZYDIS_MNEMONIC_CVTDQ2PD, 126 | ZYDIS_MNEMONIC_CVTDQ2PS, 127 | ZYDIS_MNEMONIC_CVTPD2DQ, 128 | ZYDIS_MNEMONIC_CVTPD2PI, 129 | ZYDIS_MNEMONIC_CVTPD2PS, 130 | ZYDIS_MNEMONIC_CVTPI2PD, 131 | ZYDIS_MNEMONIC_CVTPI2PS, 132 | ZYDIS_MNEMONIC_CVTPS2DQ, 133 | ZYDIS_MNEMONIC_CVTPS2PD, 134 | ZYDIS_MNEMONIC_CVTPS2PI, 135 | ZYDIS_MNEMONIC_CVTSD2SI, 136 | ZYDIS_MNEMONIC_CVTSD2SS, 137 | ZYDIS_MNEMONIC_CVTSI2SD, 138 | ZYDIS_MNEMONIC_CVTSI2SS, 139 | ZYDIS_MNEMONIC_CVTSS2SD, 140 | ZYDIS_MNEMONIC_CVTSS2SI, 141 | ZYDIS_MNEMONIC_CVTTPD2DQ, 142 | ZYDIS_MNEMONIC_CVTTPD2PI, 143 | ZYDIS_MNEMONIC_CVTTPS2DQ, 144 | ZYDIS_MNEMONIC_CVTTPS2PI, 145 | ZYDIS_MNEMONIC_CVTTSD2SI, 146 | ZYDIS_MNEMONIC_CVTTSS2SI, 147 | ZYDIS_MNEMONIC_CWD, 148 | ZYDIS_MNEMONIC_CWDE, 149 | ZYDIS_MNEMONIC_DAA, 150 | ZYDIS_MNEMONIC_DAS, 151 | ZYDIS_MNEMONIC_DEC, 152 | ZYDIS_MNEMONIC_DELAY, 153 | ZYDIS_MNEMONIC_DIV, 154 | ZYDIS_MNEMONIC_DIVPD, 155 | ZYDIS_MNEMONIC_DIVPS, 156 | ZYDIS_MNEMONIC_DIVSD, 157 | ZYDIS_MNEMONIC_DIVSS, 158 | ZYDIS_MNEMONIC_DPPD, 159 | ZYDIS_MNEMONIC_DPPS, 160 | ZYDIS_MNEMONIC_EMMS, 161 | ZYDIS_MNEMONIC_ENCLS, 162 | ZYDIS_MNEMONIC_ENCLU, 163 | ZYDIS_MNEMONIC_ENCLV, 164 | ZYDIS_MNEMONIC_ENDBR32, 165 | ZYDIS_MNEMONIC_ENDBR64, 166 | ZYDIS_MNEMONIC_ENTER, 167 | ZYDIS_MNEMONIC_EXTRACTPS, 168 | ZYDIS_MNEMONIC_EXTRQ, 169 | ZYDIS_MNEMONIC_F2XM1, 170 | ZYDIS_MNEMONIC_FABS, 171 | ZYDIS_MNEMONIC_FADD, 172 | ZYDIS_MNEMONIC_FADDP, 173 | ZYDIS_MNEMONIC_FBLD, 174 | ZYDIS_MNEMONIC_FBSTP, 175 | ZYDIS_MNEMONIC_FCHS, 176 | ZYDIS_MNEMONIC_FCMOVB, 177 | ZYDIS_MNEMONIC_FCMOVBE, 178 | ZYDIS_MNEMONIC_FCMOVE, 179 | ZYDIS_MNEMONIC_FCMOVNB, 180 | ZYDIS_MNEMONIC_FCMOVNBE, 181 | ZYDIS_MNEMONIC_FCMOVNE, 182 | ZYDIS_MNEMONIC_FCMOVNU, 183 | ZYDIS_MNEMONIC_FCMOVU, 184 | ZYDIS_MNEMONIC_FCOM, 185 | ZYDIS_MNEMONIC_FCOMI, 186 | ZYDIS_MNEMONIC_FCOMIP, 187 | ZYDIS_MNEMONIC_FCOMP, 188 | ZYDIS_MNEMONIC_FCOMPP, 189 | ZYDIS_MNEMONIC_FCOS, 190 | ZYDIS_MNEMONIC_FDECSTP, 191 | ZYDIS_MNEMONIC_FDISI8087_NOP, 192 | ZYDIS_MNEMONIC_FDIV, 193 | ZYDIS_MNEMONIC_FDIVP, 194 | ZYDIS_MNEMONIC_FDIVR, 195 | ZYDIS_MNEMONIC_FDIVRP, 196 | ZYDIS_MNEMONIC_FEMMS, 197 | ZYDIS_MNEMONIC_FENI8087_NOP, 198 | ZYDIS_MNEMONIC_FFREE, 199 | ZYDIS_MNEMONIC_FFREEP, 200 | ZYDIS_MNEMONIC_FIADD, 201 | ZYDIS_MNEMONIC_FICOM, 202 | ZYDIS_MNEMONIC_FICOMP, 203 | ZYDIS_MNEMONIC_FIDIV, 204 | ZYDIS_MNEMONIC_FIDIVR, 205 | ZYDIS_MNEMONIC_FILD, 206 | ZYDIS_MNEMONIC_FIMUL, 207 | ZYDIS_MNEMONIC_FINCSTP, 208 | ZYDIS_MNEMONIC_FIST, 209 | ZYDIS_MNEMONIC_FISTP, 210 | ZYDIS_MNEMONIC_FISTTP, 211 | ZYDIS_MNEMONIC_FISUB, 212 | ZYDIS_MNEMONIC_FISUBR, 213 | ZYDIS_MNEMONIC_FLD, 214 | ZYDIS_MNEMONIC_FLD1, 215 | ZYDIS_MNEMONIC_FLDCW, 216 | ZYDIS_MNEMONIC_FLDENV, 217 | ZYDIS_MNEMONIC_FLDL2E, 218 | ZYDIS_MNEMONIC_FLDL2T, 219 | ZYDIS_MNEMONIC_FLDLG2, 220 | ZYDIS_MNEMONIC_FLDLN2, 221 | ZYDIS_MNEMONIC_FLDPI, 222 | ZYDIS_MNEMONIC_FLDZ, 223 | ZYDIS_MNEMONIC_FMUL, 224 | ZYDIS_MNEMONIC_FMULP, 225 | ZYDIS_MNEMONIC_FNCLEX, 226 | ZYDIS_MNEMONIC_FNINIT, 227 | ZYDIS_MNEMONIC_FNOP, 228 | ZYDIS_MNEMONIC_FNSAVE, 229 | ZYDIS_MNEMONIC_FNSTCW, 230 | ZYDIS_MNEMONIC_FNSTENV, 231 | ZYDIS_MNEMONIC_FNSTSW, 232 | ZYDIS_MNEMONIC_FPATAN, 233 | ZYDIS_MNEMONIC_FPREM, 234 | ZYDIS_MNEMONIC_FPREM1, 235 | ZYDIS_MNEMONIC_FPTAN, 236 | ZYDIS_MNEMONIC_FRNDINT, 237 | ZYDIS_MNEMONIC_FRSTOR, 238 | ZYDIS_MNEMONIC_FSCALE, 239 | ZYDIS_MNEMONIC_FSETPM287_NOP, 240 | ZYDIS_MNEMONIC_FSIN, 241 | ZYDIS_MNEMONIC_FSINCOS, 242 | ZYDIS_MNEMONIC_FSQRT, 243 | ZYDIS_MNEMONIC_FST, 244 | ZYDIS_MNEMONIC_FSTP, 245 | ZYDIS_MNEMONIC_FSTPNCE, 246 | ZYDIS_MNEMONIC_FSUB, 247 | ZYDIS_MNEMONIC_FSUBP, 248 | ZYDIS_MNEMONIC_FSUBR, 249 | ZYDIS_MNEMONIC_FSUBRP, 250 | ZYDIS_MNEMONIC_FTST, 251 | ZYDIS_MNEMONIC_FUCOM, 252 | ZYDIS_MNEMONIC_FUCOMI, 253 | ZYDIS_MNEMONIC_FUCOMIP, 254 | ZYDIS_MNEMONIC_FUCOMP, 255 | ZYDIS_MNEMONIC_FUCOMPP, 256 | ZYDIS_MNEMONIC_FWAIT, 257 | ZYDIS_MNEMONIC_FXAM, 258 | ZYDIS_MNEMONIC_FXCH, 259 | ZYDIS_MNEMONIC_FXRSTOR, 260 | ZYDIS_MNEMONIC_FXRSTOR64, 261 | ZYDIS_MNEMONIC_FXSAVE, 262 | ZYDIS_MNEMONIC_FXSAVE64, 263 | ZYDIS_MNEMONIC_FXTRACT, 264 | ZYDIS_MNEMONIC_FYL2X, 265 | ZYDIS_MNEMONIC_FYL2XP1, 266 | ZYDIS_MNEMONIC_GETSEC, 267 | ZYDIS_MNEMONIC_GF2P8AFFINEINVQB, 268 | ZYDIS_MNEMONIC_GF2P8AFFINEQB, 269 | ZYDIS_MNEMONIC_GF2P8MULB, 270 | ZYDIS_MNEMONIC_HADDPD, 271 | ZYDIS_MNEMONIC_HADDPS, 272 | ZYDIS_MNEMONIC_HLT, 273 | ZYDIS_MNEMONIC_HSUBPD, 274 | ZYDIS_MNEMONIC_HSUBPS, 275 | ZYDIS_MNEMONIC_IDIV, 276 | ZYDIS_MNEMONIC_IMUL, 277 | ZYDIS_MNEMONIC_IN, 278 | ZYDIS_MNEMONIC_INC, 279 | ZYDIS_MNEMONIC_INCSSPD, 280 | ZYDIS_MNEMONIC_INCSSPQ, 281 | ZYDIS_MNEMONIC_INSB, 282 | ZYDIS_MNEMONIC_INSD, 283 | ZYDIS_MNEMONIC_INSERTPS, 284 | ZYDIS_MNEMONIC_INSERTQ, 285 | ZYDIS_MNEMONIC_INSW, 286 | ZYDIS_MNEMONIC_INT, 287 | ZYDIS_MNEMONIC_INT1, 288 | ZYDIS_MNEMONIC_INT3, 289 | ZYDIS_MNEMONIC_INTO, 290 | ZYDIS_MNEMONIC_INVD, 291 | ZYDIS_MNEMONIC_INVEPT, 292 | ZYDIS_MNEMONIC_INVLPG, 293 | ZYDIS_MNEMONIC_INVLPGA, 294 | ZYDIS_MNEMONIC_INVPCID, 295 | ZYDIS_MNEMONIC_INVVPID, 296 | ZYDIS_MNEMONIC_IRET, 297 | ZYDIS_MNEMONIC_IRETD, 298 | ZYDIS_MNEMONIC_IRETQ, 299 | ZYDIS_MNEMONIC_JB, 300 | ZYDIS_MNEMONIC_JBE, 301 | ZYDIS_MNEMONIC_JCXZ, 302 | ZYDIS_MNEMONIC_JECXZ, 303 | ZYDIS_MNEMONIC_JKNZD, 304 | ZYDIS_MNEMONIC_JKZD, 305 | ZYDIS_MNEMONIC_JL, 306 | ZYDIS_MNEMONIC_JLE, 307 | ZYDIS_MNEMONIC_JMP, 308 | ZYDIS_MNEMONIC_JNB, 309 | ZYDIS_MNEMONIC_JNBE, 310 | ZYDIS_MNEMONIC_JNL, 311 | ZYDIS_MNEMONIC_JNLE, 312 | ZYDIS_MNEMONIC_JNO, 313 | ZYDIS_MNEMONIC_JNP, 314 | ZYDIS_MNEMONIC_JNS, 315 | ZYDIS_MNEMONIC_JNZ, 316 | ZYDIS_MNEMONIC_JO, 317 | ZYDIS_MNEMONIC_JP, 318 | ZYDIS_MNEMONIC_JRCXZ, 319 | ZYDIS_MNEMONIC_JS, 320 | ZYDIS_MNEMONIC_JZ, 321 | ZYDIS_MNEMONIC_KADDB, 322 | ZYDIS_MNEMONIC_KADDD, 323 | ZYDIS_MNEMONIC_KADDQ, 324 | ZYDIS_MNEMONIC_KADDW, 325 | ZYDIS_MNEMONIC_KAND, 326 | ZYDIS_MNEMONIC_KANDB, 327 | ZYDIS_MNEMONIC_KANDD, 328 | ZYDIS_MNEMONIC_KANDN, 329 | ZYDIS_MNEMONIC_KANDNB, 330 | ZYDIS_MNEMONIC_KANDND, 331 | ZYDIS_MNEMONIC_KANDNQ, 332 | ZYDIS_MNEMONIC_KANDNR, 333 | ZYDIS_MNEMONIC_KANDNW, 334 | ZYDIS_MNEMONIC_KANDQ, 335 | ZYDIS_MNEMONIC_KANDW, 336 | ZYDIS_MNEMONIC_KCONCATH, 337 | ZYDIS_MNEMONIC_KCONCATL, 338 | ZYDIS_MNEMONIC_KEXTRACT, 339 | ZYDIS_MNEMONIC_KMERGE2L1H, 340 | ZYDIS_MNEMONIC_KMERGE2L1L, 341 | ZYDIS_MNEMONIC_KMOV, 342 | ZYDIS_MNEMONIC_KMOVB, 343 | ZYDIS_MNEMONIC_KMOVD, 344 | ZYDIS_MNEMONIC_KMOVQ, 345 | ZYDIS_MNEMONIC_KMOVW, 346 | ZYDIS_MNEMONIC_KNOT, 347 | ZYDIS_MNEMONIC_KNOTB, 348 | ZYDIS_MNEMONIC_KNOTD, 349 | ZYDIS_MNEMONIC_KNOTQ, 350 | ZYDIS_MNEMONIC_KNOTW, 351 | ZYDIS_MNEMONIC_KOR, 352 | ZYDIS_MNEMONIC_KORB, 353 | ZYDIS_MNEMONIC_KORD, 354 | ZYDIS_MNEMONIC_KORQ, 355 | ZYDIS_MNEMONIC_KORTEST, 356 | ZYDIS_MNEMONIC_KORTESTB, 357 | ZYDIS_MNEMONIC_KORTESTD, 358 | ZYDIS_MNEMONIC_KORTESTQ, 359 | ZYDIS_MNEMONIC_KORTESTW, 360 | ZYDIS_MNEMONIC_KORW, 361 | ZYDIS_MNEMONIC_KSHIFTLB, 362 | ZYDIS_MNEMONIC_KSHIFTLD, 363 | ZYDIS_MNEMONIC_KSHIFTLQ, 364 | ZYDIS_MNEMONIC_KSHIFTLW, 365 | ZYDIS_MNEMONIC_KSHIFTRB, 366 | ZYDIS_MNEMONIC_KSHIFTRD, 367 | ZYDIS_MNEMONIC_KSHIFTRQ, 368 | ZYDIS_MNEMONIC_KSHIFTRW, 369 | ZYDIS_MNEMONIC_KTESTB, 370 | ZYDIS_MNEMONIC_KTESTD, 371 | ZYDIS_MNEMONIC_KTESTQ, 372 | ZYDIS_MNEMONIC_KTESTW, 373 | ZYDIS_MNEMONIC_KUNPCKBW, 374 | ZYDIS_MNEMONIC_KUNPCKDQ, 375 | ZYDIS_MNEMONIC_KUNPCKWD, 376 | ZYDIS_MNEMONIC_KXNOR, 377 | ZYDIS_MNEMONIC_KXNORB, 378 | ZYDIS_MNEMONIC_KXNORD, 379 | ZYDIS_MNEMONIC_KXNORQ, 380 | ZYDIS_MNEMONIC_KXNORW, 381 | ZYDIS_MNEMONIC_KXOR, 382 | ZYDIS_MNEMONIC_KXORB, 383 | ZYDIS_MNEMONIC_KXORD, 384 | ZYDIS_MNEMONIC_KXORQ, 385 | ZYDIS_MNEMONIC_KXORW, 386 | ZYDIS_MNEMONIC_LAHF, 387 | ZYDIS_MNEMONIC_LAR, 388 | ZYDIS_MNEMONIC_LDDQU, 389 | ZYDIS_MNEMONIC_LDMXCSR, 390 | ZYDIS_MNEMONIC_LDS, 391 | ZYDIS_MNEMONIC_LEA, 392 | ZYDIS_MNEMONIC_LEAVE, 393 | ZYDIS_MNEMONIC_LES, 394 | ZYDIS_MNEMONIC_LFENCE, 395 | ZYDIS_MNEMONIC_LFS, 396 | ZYDIS_MNEMONIC_LGDT, 397 | ZYDIS_MNEMONIC_LGS, 398 | ZYDIS_MNEMONIC_LIDT, 399 | ZYDIS_MNEMONIC_LLDT, 400 | ZYDIS_MNEMONIC_LLWPCB, 401 | ZYDIS_MNEMONIC_LMSW, 402 | ZYDIS_MNEMONIC_LODSB, 403 | ZYDIS_MNEMONIC_LODSD, 404 | ZYDIS_MNEMONIC_LODSQ, 405 | ZYDIS_MNEMONIC_LODSW, 406 | ZYDIS_MNEMONIC_LOOP, 407 | ZYDIS_MNEMONIC_LOOPE, 408 | ZYDIS_MNEMONIC_LOOPNE, 409 | ZYDIS_MNEMONIC_LSL, 410 | ZYDIS_MNEMONIC_LSS, 411 | ZYDIS_MNEMONIC_LTR, 412 | ZYDIS_MNEMONIC_LWPINS, 413 | ZYDIS_MNEMONIC_LWPVAL, 414 | ZYDIS_MNEMONIC_LZCNT, 415 | ZYDIS_MNEMONIC_MASKMOVDQU, 416 | ZYDIS_MNEMONIC_MASKMOVQ, 417 | ZYDIS_MNEMONIC_MAXPD, 418 | ZYDIS_MNEMONIC_MAXPS, 419 | ZYDIS_MNEMONIC_MAXSD, 420 | ZYDIS_MNEMONIC_MAXSS, 421 | ZYDIS_MNEMONIC_MFENCE, 422 | ZYDIS_MNEMONIC_MINPD, 423 | ZYDIS_MNEMONIC_MINPS, 424 | ZYDIS_MNEMONIC_MINSD, 425 | ZYDIS_MNEMONIC_MINSS, 426 | ZYDIS_MNEMONIC_MONITOR, 427 | ZYDIS_MNEMONIC_MONITORX, 428 | ZYDIS_MNEMONIC_MOV, 429 | ZYDIS_MNEMONIC_MOVAPD, 430 | ZYDIS_MNEMONIC_MOVAPS, 431 | ZYDIS_MNEMONIC_MOVBE, 432 | ZYDIS_MNEMONIC_MOVD, 433 | ZYDIS_MNEMONIC_MOVDDUP, 434 | ZYDIS_MNEMONIC_MOVDQ2Q, 435 | ZYDIS_MNEMONIC_MOVDQA, 436 | ZYDIS_MNEMONIC_MOVDQU, 437 | ZYDIS_MNEMONIC_MOVHLPS, 438 | ZYDIS_MNEMONIC_MOVHPD, 439 | ZYDIS_MNEMONIC_MOVHPS, 440 | ZYDIS_MNEMONIC_MOVLHPS, 441 | ZYDIS_MNEMONIC_MOVLPD, 442 | ZYDIS_MNEMONIC_MOVLPS, 443 | ZYDIS_MNEMONIC_MOVMSKPD, 444 | ZYDIS_MNEMONIC_MOVMSKPS, 445 | ZYDIS_MNEMONIC_MOVNTDQ, 446 | ZYDIS_MNEMONIC_MOVNTDQA, 447 | ZYDIS_MNEMONIC_MOVNTI, 448 | ZYDIS_MNEMONIC_MOVNTPD, 449 | ZYDIS_MNEMONIC_MOVNTPS, 450 | ZYDIS_MNEMONIC_MOVNTQ, 451 | ZYDIS_MNEMONIC_MOVNTSD, 452 | ZYDIS_MNEMONIC_MOVNTSS, 453 | ZYDIS_MNEMONIC_MOVQ, 454 | ZYDIS_MNEMONIC_MOVQ2DQ, 455 | ZYDIS_MNEMONIC_MOVSB, 456 | ZYDIS_MNEMONIC_MOVSD, 457 | ZYDIS_MNEMONIC_MOVSHDUP, 458 | ZYDIS_MNEMONIC_MOVSLDUP, 459 | ZYDIS_MNEMONIC_MOVSQ, 460 | ZYDIS_MNEMONIC_MOVSS, 461 | ZYDIS_MNEMONIC_MOVSW, 462 | ZYDIS_MNEMONIC_MOVSX, 463 | ZYDIS_MNEMONIC_MOVSXD, 464 | ZYDIS_MNEMONIC_MOVUPD, 465 | ZYDIS_MNEMONIC_MOVUPS, 466 | ZYDIS_MNEMONIC_MOVZX, 467 | ZYDIS_MNEMONIC_MPSADBW, 468 | ZYDIS_MNEMONIC_MUL, 469 | ZYDIS_MNEMONIC_MULPD, 470 | ZYDIS_MNEMONIC_MULPS, 471 | ZYDIS_MNEMONIC_MULSD, 472 | ZYDIS_MNEMONIC_MULSS, 473 | ZYDIS_MNEMONIC_MULX, 474 | ZYDIS_MNEMONIC_MWAIT, 475 | ZYDIS_MNEMONIC_MWAITX, 476 | ZYDIS_MNEMONIC_NEG, 477 | ZYDIS_MNEMONIC_NOP, 478 | ZYDIS_MNEMONIC_NOT, 479 | ZYDIS_MNEMONIC_OR, 480 | ZYDIS_MNEMONIC_ORPD, 481 | ZYDIS_MNEMONIC_ORPS, 482 | ZYDIS_MNEMONIC_OUT, 483 | ZYDIS_MNEMONIC_OUTSB, 484 | ZYDIS_MNEMONIC_OUTSD, 485 | ZYDIS_MNEMONIC_OUTSW, 486 | ZYDIS_MNEMONIC_PABSB, 487 | ZYDIS_MNEMONIC_PABSD, 488 | ZYDIS_MNEMONIC_PABSW, 489 | ZYDIS_MNEMONIC_PACKSSDW, 490 | ZYDIS_MNEMONIC_PACKSSWB, 491 | ZYDIS_MNEMONIC_PACKUSDW, 492 | ZYDIS_MNEMONIC_PACKUSWB, 493 | ZYDIS_MNEMONIC_PADDB, 494 | ZYDIS_MNEMONIC_PADDD, 495 | ZYDIS_MNEMONIC_PADDQ, 496 | ZYDIS_MNEMONIC_PADDSB, 497 | ZYDIS_MNEMONIC_PADDSW, 498 | ZYDIS_MNEMONIC_PADDUSB, 499 | ZYDIS_MNEMONIC_PADDUSW, 500 | ZYDIS_MNEMONIC_PADDW, 501 | ZYDIS_MNEMONIC_PALIGNR, 502 | ZYDIS_MNEMONIC_PAND, 503 | ZYDIS_MNEMONIC_PANDN, 504 | ZYDIS_MNEMONIC_PAUSE, 505 | ZYDIS_MNEMONIC_PAVGB, 506 | ZYDIS_MNEMONIC_PAVGUSB, 507 | ZYDIS_MNEMONIC_PAVGW, 508 | ZYDIS_MNEMONIC_PBLENDVB, 509 | ZYDIS_MNEMONIC_PBLENDW, 510 | ZYDIS_MNEMONIC_PCLMULQDQ, 511 | ZYDIS_MNEMONIC_PCMPEQB, 512 | ZYDIS_MNEMONIC_PCMPEQD, 513 | ZYDIS_MNEMONIC_PCMPEQQ, 514 | ZYDIS_MNEMONIC_PCMPEQW, 515 | ZYDIS_MNEMONIC_PCMPESTRI, 516 | ZYDIS_MNEMONIC_PCMPESTRM, 517 | ZYDIS_MNEMONIC_PCMPGTB, 518 | ZYDIS_MNEMONIC_PCMPGTD, 519 | ZYDIS_MNEMONIC_PCMPGTQ, 520 | ZYDIS_MNEMONIC_PCMPGTW, 521 | ZYDIS_MNEMONIC_PCMPISTRI, 522 | ZYDIS_MNEMONIC_PCMPISTRM, 523 | ZYDIS_MNEMONIC_PCONFIG, 524 | ZYDIS_MNEMONIC_PDEP, 525 | ZYDIS_MNEMONIC_PEXT, 526 | ZYDIS_MNEMONIC_PEXTRB, 527 | ZYDIS_MNEMONIC_PEXTRD, 528 | ZYDIS_MNEMONIC_PEXTRQ, 529 | ZYDIS_MNEMONIC_PEXTRW, 530 | ZYDIS_MNEMONIC_PF2ID, 531 | ZYDIS_MNEMONIC_PF2IW, 532 | ZYDIS_MNEMONIC_PFACC, 533 | ZYDIS_MNEMONIC_PFADD, 534 | ZYDIS_MNEMONIC_PFCMPEQ, 535 | ZYDIS_MNEMONIC_PFCMPGE, 536 | ZYDIS_MNEMONIC_PFCMPGT, 537 | ZYDIS_MNEMONIC_PFCPIT1, 538 | ZYDIS_MNEMONIC_PFMAX, 539 | ZYDIS_MNEMONIC_PFMIN, 540 | ZYDIS_MNEMONIC_PFMUL, 541 | ZYDIS_MNEMONIC_PFNACC, 542 | ZYDIS_MNEMONIC_PFPNACC, 543 | ZYDIS_MNEMONIC_PFRCP, 544 | ZYDIS_MNEMONIC_PFRCPIT2, 545 | ZYDIS_MNEMONIC_PFRSQIT1, 546 | ZYDIS_MNEMONIC_PFSQRT, 547 | ZYDIS_MNEMONIC_PFSUB, 548 | ZYDIS_MNEMONIC_PFSUBR, 549 | ZYDIS_MNEMONIC_PHADDD, 550 | ZYDIS_MNEMONIC_PHADDSW, 551 | ZYDIS_MNEMONIC_PHADDW, 552 | ZYDIS_MNEMONIC_PHMINPOSUW, 553 | ZYDIS_MNEMONIC_PHSUBD, 554 | ZYDIS_MNEMONIC_PHSUBSW, 555 | ZYDIS_MNEMONIC_PHSUBW, 556 | ZYDIS_MNEMONIC_PI2FD, 557 | ZYDIS_MNEMONIC_PI2FW, 558 | ZYDIS_MNEMONIC_PINSRB, 559 | ZYDIS_MNEMONIC_PINSRD, 560 | ZYDIS_MNEMONIC_PINSRQ, 561 | ZYDIS_MNEMONIC_PINSRW, 562 | ZYDIS_MNEMONIC_PMADDUBSW, 563 | ZYDIS_MNEMONIC_PMADDWD, 564 | ZYDIS_MNEMONIC_PMAXSB, 565 | ZYDIS_MNEMONIC_PMAXSD, 566 | ZYDIS_MNEMONIC_PMAXSW, 567 | ZYDIS_MNEMONIC_PMAXUB, 568 | ZYDIS_MNEMONIC_PMAXUD, 569 | ZYDIS_MNEMONIC_PMAXUW, 570 | ZYDIS_MNEMONIC_PMINSB, 571 | ZYDIS_MNEMONIC_PMINSD, 572 | ZYDIS_MNEMONIC_PMINSW, 573 | ZYDIS_MNEMONIC_PMINUB, 574 | ZYDIS_MNEMONIC_PMINUD, 575 | ZYDIS_MNEMONIC_PMINUW, 576 | ZYDIS_MNEMONIC_PMOVMSKB, 577 | ZYDIS_MNEMONIC_PMOVSXBD, 578 | ZYDIS_MNEMONIC_PMOVSXBQ, 579 | ZYDIS_MNEMONIC_PMOVSXBW, 580 | ZYDIS_MNEMONIC_PMOVSXDQ, 581 | ZYDIS_MNEMONIC_PMOVSXWD, 582 | ZYDIS_MNEMONIC_PMOVSXWQ, 583 | ZYDIS_MNEMONIC_PMOVZXBD, 584 | ZYDIS_MNEMONIC_PMOVZXBQ, 585 | ZYDIS_MNEMONIC_PMOVZXBW, 586 | ZYDIS_MNEMONIC_PMOVZXDQ, 587 | ZYDIS_MNEMONIC_PMOVZXWD, 588 | ZYDIS_MNEMONIC_PMOVZXWQ, 589 | ZYDIS_MNEMONIC_PMULDQ, 590 | ZYDIS_MNEMONIC_PMULHRSW, 591 | ZYDIS_MNEMONIC_PMULHRW, 592 | ZYDIS_MNEMONIC_PMULHUW, 593 | ZYDIS_MNEMONIC_PMULHW, 594 | ZYDIS_MNEMONIC_PMULLD, 595 | ZYDIS_MNEMONIC_PMULLW, 596 | ZYDIS_MNEMONIC_PMULUDQ, 597 | ZYDIS_MNEMONIC_POP, 598 | ZYDIS_MNEMONIC_POPA, 599 | ZYDIS_MNEMONIC_POPAD, 600 | ZYDIS_MNEMONIC_POPCNT, 601 | ZYDIS_MNEMONIC_POPF, 602 | ZYDIS_MNEMONIC_POPFD, 603 | ZYDIS_MNEMONIC_POPFQ, 604 | ZYDIS_MNEMONIC_POR, 605 | ZYDIS_MNEMONIC_PREFETCH, 606 | ZYDIS_MNEMONIC_PREFETCHNTA, 607 | ZYDIS_MNEMONIC_PREFETCHT0, 608 | ZYDIS_MNEMONIC_PREFETCHT1, 609 | ZYDIS_MNEMONIC_PREFETCHT2, 610 | ZYDIS_MNEMONIC_PREFETCHW, 611 | ZYDIS_MNEMONIC_PREFETCHWT1, 612 | ZYDIS_MNEMONIC_PSADBW, 613 | ZYDIS_MNEMONIC_PSHUFB, 614 | ZYDIS_MNEMONIC_PSHUFD, 615 | ZYDIS_MNEMONIC_PSHUFHW, 616 | ZYDIS_MNEMONIC_PSHUFLW, 617 | ZYDIS_MNEMONIC_PSHUFW, 618 | ZYDIS_MNEMONIC_PSIGNB, 619 | ZYDIS_MNEMONIC_PSIGND, 620 | ZYDIS_MNEMONIC_PSIGNW, 621 | ZYDIS_MNEMONIC_PSLLD, 622 | ZYDIS_MNEMONIC_PSLLDQ, 623 | ZYDIS_MNEMONIC_PSLLQ, 624 | ZYDIS_MNEMONIC_PSLLW, 625 | ZYDIS_MNEMONIC_PSRAD, 626 | ZYDIS_MNEMONIC_PSRAW, 627 | ZYDIS_MNEMONIC_PSRLD, 628 | ZYDIS_MNEMONIC_PSRLDQ, 629 | ZYDIS_MNEMONIC_PSRLQ, 630 | ZYDIS_MNEMONIC_PSRLW, 631 | ZYDIS_MNEMONIC_PSUBB, 632 | ZYDIS_MNEMONIC_PSUBD, 633 | ZYDIS_MNEMONIC_PSUBQ, 634 | ZYDIS_MNEMONIC_PSUBSB, 635 | ZYDIS_MNEMONIC_PSUBSW, 636 | ZYDIS_MNEMONIC_PSUBUSB, 637 | ZYDIS_MNEMONIC_PSUBUSW, 638 | ZYDIS_MNEMONIC_PSUBW, 639 | ZYDIS_MNEMONIC_PSWAPD, 640 | ZYDIS_MNEMONIC_PTEST, 641 | ZYDIS_MNEMONIC_PTWRITE, 642 | ZYDIS_MNEMONIC_PUNPCKHBW, 643 | ZYDIS_MNEMONIC_PUNPCKHDQ, 644 | ZYDIS_MNEMONIC_PUNPCKHQDQ, 645 | ZYDIS_MNEMONIC_PUNPCKHWD, 646 | ZYDIS_MNEMONIC_PUNPCKLBW, 647 | ZYDIS_MNEMONIC_PUNPCKLDQ, 648 | ZYDIS_MNEMONIC_PUNPCKLQDQ, 649 | ZYDIS_MNEMONIC_PUNPCKLWD, 650 | ZYDIS_MNEMONIC_PUSH, 651 | ZYDIS_MNEMONIC_PUSHA, 652 | ZYDIS_MNEMONIC_PUSHAD, 653 | ZYDIS_MNEMONIC_PUSHF, 654 | ZYDIS_MNEMONIC_PUSHFD, 655 | ZYDIS_MNEMONIC_PUSHFQ, 656 | ZYDIS_MNEMONIC_PXOR, 657 | ZYDIS_MNEMONIC_RCL, 658 | ZYDIS_MNEMONIC_RCPPS, 659 | ZYDIS_MNEMONIC_RCPSS, 660 | ZYDIS_MNEMONIC_RCR, 661 | ZYDIS_MNEMONIC_RDFSBASE, 662 | ZYDIS_MNEMONIC_RDGSBASE, 663 | ZYDIS_MNEMONIC_RDMSR, 664 | ZYDIS_MNEMONIC_RDPID, 665 | ZYDIS_MNEMONIC_RDPKRU, 666 | ZYDIS_MNEMONIC_RDPMC, 667 | ZYDIS_MNEMONIC_RDRAND, 668 | ZYDIS_MNEMONIC_RDSEED, 669 | ZYDIS_MNEMONIC_RDSSPD, 670 | ZYDIS_MNEMONIC_RDSSPQ, 671 | ZYDIS_MNEMONIC_RDTSC, 672 | ZYDIS_MNEMONIC_RDTSCP, 673 | ZYDIS_MNEMONIC_RET, 674 | ZYDIS_MNEMONIC_ROL, 675 | ZYDIS_MNEMONIC_ROR, 676 | ZYDIS_MNEMONIC_RORX, 677 | ZYDIS_MNEMONIC_ROUNDPD, 678 | ZYDIS_MNEMONIC_ROUNDPS, 679 | ZYDIS_MNEMONIC_ROUNDSD, 680 | ZYDIS_MNEMONIC_ROUNDSS, 681 | ZYDIS_MNEMONIC_RSM, 682 | ZYDIS_MNEMONIC_RSQRTPS, 683 | ZYDIS_MNEMONIC_RSQRTSS, 684 | ZYDIS_MNEMONIC_RSTORSSP, 685 | ZYDIS_MNEMONIC_SAHF, 686 | ZYDIS_MNEMONIC_SALC, 687 | ZYDIS_MNEMONIC_SAR, 688 | ZYDIS_MNEMONIC_SARX, 689 | ZYDIS_MNEMONIC_SAVEPREVSSP, 690 | ZYDIS_MNEMONIC_SBB, 691 | ZYDIS_MNEMONIC_SCASB, 692 | ZYDIS_MNEMONIC_SCASD, 693 | ZYDIS_MNEMONIC_SCASQ, 694 | ZYDIS_MNEMONIC_SCASW, 695 | ZYDIS_MNEMONIC_SETB, 696 | ZYDIS_MNEMONIC_SETBE, 697 | ZYDIS_MNEMONIC_SETL, 698 | ZYDIS_MNEMONIC_SETLE, 699 | ZYDIS_MNEMONIC_SETNB, 700 | ZYDIS_MNEMONIC_SETNBE, 701 | ZYDIS_MNEMONIC_SETNL, 702 | ZYDIS_MNEMONIC_SETNLE, 703 | ZYDIS_MNEMONIC_SETNO, 704 | ZYDIS_MNEMONIC_SETNP, 705 | ZYDIS_MNEMONIC_SETNS, 706 | ZYDIS_MNEMONIC_SETNZ, 707 | ZYDIS_MNEMONIC_SETO, 708 | ZYDIS_MNEMONIC_SETP, 709 | ZYDIS_MNEMONIC_SETS, 710 | ZYDIS_MNEMONIC_SETSSBSY, 711 | ZYDIS_MNEMONIC_SETZ, 712 | ZYDIS_MNEMONIC_SFENCE, 713 | ZYDIS_MNEMONIC_SGDT, 714 | ZYDIS_MNEMONIC_SHA1MSG1, 715 | ZYDIS_MNEMONIC_SHA1MSG2, 716 | ZYDIS_MNEMONIC_SHA1NEXTE, 717 | ZYDIS_MNEMONIC_SHA1RNDS4, 718 | ZYDIS_MNEMONIC_SHA256MSG1, 719 | ZYDIS_MNEMONIC_SHA256MSG2, 720 | ZYDIS_MNEMONIC_SHA256RNDS2, 721 | ZYDIS_MNEMONIC_SHL, 722 | ZYDIS_MNEMONIC_SHLD, 723 | ZYDIS_MNEMONIC_SHLX, 724 | ZYDIS_MNEMONIC_SHR, 725 | ZYDIS_MNEMONIC_SHRD, 726 | ZYDIS_MNEMONIC_SHRX, 727 | ZYDIS_MNEMONIC_SHUFPD, 728 | ZYDIS_MNEMONIC_SHUFPS, 729 | ZYDIS_MNEMONIC_SIDT, 730 | ZYDIS_MNEMONIC_SKINIT, 731 | ZYDIS_MNEMONIC_SLDT, 732 | ZYDIS_MNEMONIC_SLWPCB, 733 | ZYDIS_MNEMONIC_SMSW, 734 | ZYDIS_MNEMONIC_SPFLT, 735 | ZYDIS_MNEMONIC_SQRTPD, 736 | ZYDIS_MNEMONIC_SQRTPS, 737 | ZYDIS_MNEMONIC_SQRTSD, 738 | ZYDIS_MNEMONIC_SQRTSS, 739 | ZYDIS_MNEMONIC_STAC, 740 | ZYDIS_MNEMONIC_STC, 741 | ZYDIS_MNEMONIC_STD, 742 | ZYDIS_MNEMONIC_STGI, 743 | ZYDIS_MNEMONIC_STI, 744 | ZYDIS_MNEMONIC_STMXCSR, 745 | ZYDIS_MNEMONIC_STOSB, 746 | ZYDIS_MNEMONIC_STOSD, 747 | ZYDIS_MNEMONIC_STOSQ, 748 | ZYDIS_MNEMONIC_STOSW, 749 | ZYDIS_MNEMONIC_STR, 750 | ZYDIS_MNEMONIC_SUB, 751 | ZYDIS_MNEMONIC_SUBPD, 752 | ZYDIS_MNEMONIC_SUBPS, 753 | ZYDIS_MNEMONIC_SUBSD, 754 | ZYDIS_MNEMONIC_SUBSS, 755 | ZYDIS_MNEMONIC_SWAPGS, 756 | ZYDIS_MNEMONIC_SYSCALL, 757 | ZYDIS_MNEMONIC_SYSENTER, 758 | ZYDIS_MNEMONIC_SYSEXIT, 759 | ZYDIS_MNEMONIC_SYSRET, 760 | ZYDIS_MNEMONIC_T1MSKC, 761 | ZYDIS_MNEMONIC_TEST, 762 | ZYDIS_MNEMONIC_TZCNT, 763 | ZYDIS_MNEMONIC_TZCNTI, 764 | ZYDIS_MNEMONIC_TZMSK, 765 | ZYDIS_MNEMONIC_UCOMISD, 766 | ZYDIS_MNEMONIC_UCOMISS, 767 | ZYDIS_MNEMONIC_UD0, 768 | ZYDIS_MNEMONIC_UD1, 769 | ZYDIS_MNEMONIC_UD2, 770 | ZYDIS_MNEMONIC_UNPCKHPD, 771 | ZYDIS_MNEMONIC_UNPCKHPS, 772 | ZYDIS_MNEMONIC_UNPCKLPD, 773 | ZYDIS_MNEMONIC_UNPCKLPS, 774 | ZYDIS_MNEMONIC_V4FMADDPS, 775 | ZYDIS_MNEMONIC_V4FMADDSS, 776 | ZYDIS_MNEMONIC_V4FNMADDPS, 777 | ZYDIS_MNEMONIC_V4FNMADDSS, 778 | ZYDIS_MNEMONIC_VADDNPD, 779 | ZYDIS_MNEMONIC_VADDNPS, 780 | ZYDIS_MNEMONIC_VADDPD, 781 | ZYDIS_MNEMONIC_VADDPS, 782 | ZYDIS_MNEMONIC_VADDSD, 783 | ZYDIS_MNEMONIC_VADDSETSPS, 784 | ZYDIS_MNEMONIC_VADDSS, 785 | ZYDIS_MNEMONIC_VADDSUBPD, 786 | ZYDIS_MNEMONIC_VADDSUBPS, 787 | ZYDIS_MNEMONIC_VAESDEC, 788 | ZYDIS_MNEMONIC_VAESDECLAST, 789 | ZYDIS_MNEMONIC_VAESENC, 790 | ZYDIS_MNEMONIC_VAESENCLAST, 791 | ZYDIS_MNEMONIC_VAESIMC, 792 | ZYDIS_MNEMONIC_VAESKEYGENASSIST, 793 | ZYDIS_MNEMONIC_VALIGND, 794 | ZYDIS_MNEMONIC_VALIGNQ, 795 | ZYDIS_MNEMONIC_VANDNPD, 796 | ZYDIS_MNEMONIC_VANDNPS, 797 | ZYDIS_MNEMONIC_VANDPD, 798 | ZYDIS_MNEMONIC_VANDPS, 799 | ZYDIS_MNEMONIC_VBLENDMPD, 800 | ZYDIS_MNEMONIC_VBLENDMPS, 801 | ZYDIS_MNEMONIC_VBLENDPD, 802 | ZYDIS_MNEMONIC_VBLENDPS, 803 | ZYDIS_MNEMONIC_VBLENDVPD, 804 | ZYDIS_MNEMONIC_VBLENDVPS, 805 | ZYDIS_MNEMONIC_VBROADCASTF128, 806 | ZYDIS_MNEMONIC_VBROADCASTF32X2, 807 | ZYDIS_MNEMONIC_VBROADCASTF32X4, 808 | ZYDIS_MNEMONIC_VBROADCASTF32X8, 809 | ZYDIS_MNEMONIC_VBROADCASTF64X2, 810 | ZYDIS_MNEMONIC_VBROADCASTF64X4, 811 | ZYDIS_MNEMONIC_VBROADCASTI128, 812 | ZYDIS_MNEMONIC_VBROADCASTI32X2, 813 | ZYDIS_MNEMONIC_VBROADCASTI32X4, 814 | ZYDIS_MNEMONIC_VBROADCASTI32X8, 815 | ZYDIS_MNEMONIC_VBROADCASTI64X2, 816 | ZYDIS_MNEMONIC_VBROADCASTI64X4, 817 | ZYDIS_MNEMONIC_VBROADCASTSD, 818 | ZYDIS_MNEMONIC_VBROADCASTSS, 819 | ZYDIS_MNEMONIC_VCMPPD, 820 | ZYDIS_MNEMONIC_VCMPPS, 821 | ZYDIS_MNEMONIC_VCMPSD, 822 | ZYDIS_MNEMONIC_VCMPSS, 823 | ZYDIS_MNEMONIC_VCOMISD, 824 | ZYDIS_MNEMONIC_VCOMISS, 825 | ZYDIS_MNEMONIC_VCOMPRESSPD, 826 | ZYDIS_MNEMONIC_VCOMPRESSPS, 827 | ZYDIS_MNEMONIC_VCVTDQ2PD, 828 | ZYDIS_MNEMONIC_VCVTDQ2PS, 829 | ZYDIS_MNEMONIC_VCVTFXPNTDQ2PS, 830 | ZYDIS_MNEMONIC_VCVTFXPNTPD2DQ, 831 | ZYDIS_MNEMONIC_VCVTFXPNTPD2UDQ, 832 | ZYDIS_MNEMONIC_VCVTFXPNTPS2DQ, 833 | ZYDIS_MNEMONIC_VCVTFXPNTPS2UDQ, 834 | ZYDIS_MNEMONIC_VCVTFXPNTUDQ2PS, 835 | ZYDIS_MNEMONIC_VCVTPD2DQ, 836 | ZYDIS_MNEMONIC_VCVTPD2PS, 837 | ZYDIS_MNEMONIC_VCVTPD2QQ, 838 | ZYDIS_MNEMONIC_VCVTPD2UDQ, 839 | ZYDIS_MNEMONIC_VCVTPD2UQQ, 840 | ZYDIS_MNEMONIC_VCVTPH2PS, 841 | ZYDIS_MNEMONIC_VCVTPS2DQ, 842 | ZYDIS_MNEMONIC_VCVTPS2PD, 843 | ZYDIS_MNEMONIC_VCVTPS2PH, 844 | ZYDIS_MNEMONIC_VCVTPS2QQ, 845 | ZYDIS_MNEMONIC_VCVTPS2UDQ, 846 | ZYDIS_MNEMONIC_VCVTPS2UQQ, 847 | ZYDIS_MNEMONIC_VCVTQQ2PD, 848 | ZYDIS_MNEMONIC_VCVTQQ2PS, 849 | ZYDIS_MNEMONIC_VCVTSD2SI, 850 | ZYDIS_MNEMONIC_VCVTSD2SS, 851 | ZYDIS_MNEMONIC_VCVTSD2USI, 852 | ZYDIS_MNEMONIC_VCVTSI2SD, 853 | ZYDIS_MNEMONIC_VCVTSI2SS, 854 | ZYDIS_MNEMONIC_VCVTSS2SD, 855 | ZYDIS_MNEMONIC_VCVTSS2SI, 856 | ZYDIS_MNEMONIC_VCVTSS2USI, 857 | ZYDIS_MNEMONIC_VCVTTPD2DQ, 858 | ZYDIS_MNEMONIC_VCVTTPD2QQ, 859 | ZYDIS_MNEMONIC_VCVTTPD2UDQ, 860 | ZYDIS_MNEMONIC_VCVTTPD2UQQ, 861 | ZYDIS_MNEMONIC_VCVTTPS2DQ, 862 | ZYDIS_MNEMONIC_VCVTTPS2QQ, 863 | ZYDIS_MNEMONIC_VCVTTPS2UDQ, 864 | ZYDIS_MNEMONIC_VCVTTPS2UQQ, 865 | ZYDIS_MNEMONIC_VCVTTSD2SI, 866 | ZYDIS_MNEMONIC_VCVTTSD2USI, 867 | ZYDIS_MNEMONIC_VCVTTSS2SI, 868 | ZYDIS_MNEMONIC_VCVTTSS2USI, 869 | ZYDIS_MNEMONIC_VCVTUDQ2PD, 870 | ZYDIS_MNEMONIC_VCVTUDQ2PS, 871 | ZYDIS_MNEMONIC_VCVTUQQ2PD, 872 | ZYDIS_MNEMONIC_VCVTUQQ2PS, 873 | ZYDIS_MNEMONIC_VCVTUSI2SD, 874 | ZYDIS_MNEMONIC_VCVTUSI2SS, 875 | ZYDIS_MNEMONIC_VDBPSADBW, 876 | ZYDIS_MNEMONIC_VDIVPD, 877 | ZYDIS_MNEMONIC_VDIVPS, 878 | ZYDIS_MNEMONIC_VDIVSD, 879 | ZYDIS_MNEMONIC_VDIVSS, 880 | ZYDIS_MNEMONIC_VDPPD, 881 | ZYDIS_MNEMONIC_VDPPS, 882 | ZYDIS_MNEMONIC_VERR, 883 | ZYDIS_MNEMONIC_VERW, 884 | ZYDIS_MNEMONIC_VEXP223PS, 885 | ZYDIS_MNEMONIC_VEXP2PD, 886 | ZYDIS_MNEMONIC_VEXP2PS, 887 | ZYDIS_MNEMONIC_VEXPANDPD, 888 | ZYDIS_MNEMONIC_VEXPANDPS, 889 | ZYDIS_MNEMONIC_VEXTRACTF128, 890 | ZYDIS_MNEMONIC_VEXTRACTF32X4, 891 | ZYDIS_MNEMONIC_VEXTRACTF32X8, 892 | ZYDIS_MNEMONIC_VEXTRACTF64X2, 893 | ZYDIS_MNEMONIC_VEXTRACTF64X4, 894 | ZYDIS_MNEMONIC_VEXTRACTI128, 895 | ZYDIS_MNEMONIC_VEXTRACTI32X4, 896 | ZYDIS_MNEMONIC_VEXTRACTI32X8, 897 | ZYDIS_MNEMONIC_VEXTRACTI64X2, 898 | ZYDIS_MNEMONIC_VEXTRACTI64X4, 899 | ZYDIS_MNEMONIC_VEXTRACTPS, 900 | ZYDIS_MNEMONIC_VFIXUPIMMPD, 901 | ZYDIS_MNEMONIC_VFIXUPIMMPS, 902 | ZYDIS_MNEMONIC_VFIXUPIMMSD, 903 | ZYDIS_MNEMONIC_VFIXUPIMMSS, 904 | ZYDIS_MNEMONIC_VFIXUPNANPD, 905 | ZYDIS_MNEMONIC_VFIXUPNANPS, 906 | ZYDIS_MNEMONIC_VFMADD132PD, 907 | ZYDIS_MNEMONIC_VFMADD132PS, 908 | ZYDIS_MNEMONIC_VFMADD132SD, 909 | ZYDIS_MNEMONIC_VFMADD132SS, 910 | ZYDIS_MNEMONIC_VFMADD213PD, 911 | ZYDIS_MNEMONIC_VFMADD213PS, 912 | ZYDIS_MNEMONIC_VFMADD213SD, 913 | ZYDIS_MNEMONIC_VFMADD213SS, 914 | ZYDIS_MNEMONIC_VFMADD231PD, 915 | ZYDIS_MNEMONIC_VFMADD231PS, 916 | ZYDIS_MNEMONIC_VFMADD231SD, 917 | ZYDIS_MNEMONIC_VFMADD231SS, 918 | ZYDIS_MNEMONIC_VFMADD233PS, 919 | ZYDIS_MNEMONIC_VFMADDPD, 920 | ZYDIS_MNEMONIC_VFMADDPS, 921 | ZYDIS_MNEMONIC_VFMADDSD, 922 | ZYDIS_MNEMONIC_VFMADDSS, 923 | ZYDIS_MNEMONIC_VFMADDSUB132PD, 924 | ZYDIS_MNEMONIC_VFMADDSUB132PS, 925 | ZYDIS_MNEMONIC_VFMADDSUB213PD, 926 | ZYDIS_MNEMONIC_VFMADDSUB213PS, 927 | ZYDIS_MNEMONIC_VFMADDSUB231PD, 928 | ZYDIS_MNEMONIC_VFMADDSUB231PS, 929 | ZYDIS_MNEMONIC_VFMADDSUBPD, 930 | ZYDIS_MNEMONIC_VFMADDSUBPS, 931 | ZYDIS_MNEMONIC_VFMSUB132PD, 932 | ZYDIS_MNEMONIC_VFMSUB132PS, 933 | ZYDIS_MNEMONIC_VFMSUB132SD, 934 | ZYDIS_MNEMONIC_VFMSUB132SS, 935 | ZYDIS_MNEMONIC_VFMSUB213PD, 936 | ZYDIS_MNEMONIC_VFMSUB213PS, 937 | ZYDIS_MNEMONIC_VFMSUB213SD, 938 | ZYDIS_MNEMONIC_VFMSUB213SS, 939 | ZYDIS_MNEMONIC_VFMSUB231PD, 940 | ZYDIS_MNEMONIC_VFMSUB231PS, 941 | ZYDIS_MNEMONIC_VFMSUB231SD, 942 | ZYDIS_MNEMONIC_VFMSUB231SS, 943 | ZYDIS_MNEMONIC_VFMSUBADD132PD, 944 | ZYDIS_MNEMONIC_VFMSUBADD132PS, 945 | ZYDIS_MNEMONIC_VFMSUBADD213PD, 946 | ZYDIS_MNEMONIC_VFMSUBADD213PS, 947 | ZYDIS_MNEMONIC_VFMSUBADD231PD, 948 | ZYDIS_MNEMONIC_VFMSUBADD231PS, 949 | ZYDIS_MNEMONIC_VFMSUBADDPD, 950 | ZYDIS_MNEMONIC_VFMSUBADDPS, 951 | ZYDIS_MNEMONIC_VFMSUBPD, 952 | ZYDIS_MNEMONIC_VFMSUBPS, 953 | ZYDIS_MNEMONIC_VFMSUBSD, 954 | ZYDIS_MNEMONIC_VFMSUBSS, 955 | ZYDIS_MNEMONIC_VFNMADD132PD, 956 | ZYDIS_MNEMONIC_VFNMADD132PS, 957 | ZYDIS_MNEMONIC_VFNMADD132SD, 958 | ZYDIS_MNEMONIC_VFNMADD132SS, 959 | ZYDIS_MNEMONIC_VFNMADD213PD, 960 | ZYDIS_MNEMONIC_VFNMADD213PS, 961 | ZYDIS_MNEMONIC_VFNMADD213SD, 962 | ZYDIS_MNEMONIC_VFNMADD213SS, 963 | ZYDIS_MNEMONIC_VFNMADD231PD, 964 | ZYDIS_MNEMONIC_VFNMADD231PS, 965 | ZYDIS_MNEMONIC_VFNMADD231SD, 966 | ZYDIS_MNEMONIC_VFNMADD231SS, 967 | ZYDIS_MNEMONIC_VFNMADDPD, 968 | ZYDIS_MNEMONIC_VFNMADDPS, 969 | ZYDIS_MNEMONIC_VFNMADDSD, 970 | ZYDIS_MNEMONIC_VFNMADDSS, 971 | ZYDIS_MNEMONIC_VFNMSUB132PD, 972 | ZYDIS_MNEMONIC_VFNMSUB132PS, 973 | ZYDIS_MNEMONIC_VFNMSUB132SD, 974 | ZYDIS_MNEMONIC_VFNMSUB132SS, 975 | ZYDIS_MNEMONIC_VFNMSUB213PD, 976 | ZYDIS_MNEMONIC_VFNMSUB213PS, 977 | ZYDIS_MNEMONIC_VFNMSUB213SD, 978 | ZYDIS_MNEMONIC_VFNMSUB213SS, 979 | ZYDIS_MNEMONIC_VFNMSUB231PD, 980 | ZYDIS_MNEMONIC_VFNMSUB231PS, 981 | ZYDIS_MNEMONIC_VFNMSUB231SD, 982 | ZYDIS_MNEMONIC_VFNMSUB231SS, 983 | ZYDIS_MNEMONIC_VFNMSUBPD, 984 | ZYDIS_MNEMONIC_VFNMSUBPS, 985 | ZYDIS_MNEMONIC_VFNMSUBSD, 986 | ZYDIS_MNEMONIC_VFNMSUBSS, 987 | ZYDIS_MNEMONIC_VFPCLASSPD, 988 | ZYDIS_MNEMONIC_VFPCLASSPS, 989 | ZYDIS_MNEMONIC_VFPCLASSSD, 990 | ZYDIS_MNEMONIC_VFPCLASSSS, 991 | ZYDIS_MNEMONIC_VFRCZPD, 992 | ZYDIS_MNEMONIC_VFRCZPS, 993 | ZYDIS_MNEMONIC_VFRCZSD, 994 | ZYDIS_MNEMONIC_VFRCZSS, 995 | ZYDIS_MNEMONIC_VGATHERDPD, 996 | ZYDIS_MNEMONIC_VGATHERDPS, 997 | ZYDIS_MNEMONIC_VGATHERPF0DPD, 998 | ZYDIS_MNEMONIC_VGATHERPF0DPS, 999 | ZYDIS_MNEMONIC_VGATHERPF0HINTDPD, 1000 | ZYDIS_MNEMONIC_VGATHERPF0HINTDPS, 1001 | ZYDIS_MNEMONIC_VGATHERPF0QPD, 1002 | ZYDIS_MNEMONIC_VGATHERPF0QPS, 1003 | ZYDIS_MNEMONIC_VGATHERPF1DPD, 1004 | ZYDIS_MNEMONIC_VGATHERPF1DPS, 1005 | ZYDIS_MNEMONIC_VGATHERPF1QPD, 1006 | ZYDIS_MNEMONIC_VGATHERPF1QPS, 1007 | ZYDIS_MNEMONIC_VGATHERQPD, 1008 | ZYDIS_MNEMONIC_VGATHERQPS, 1009 | ZYDIS_MNEMONIC_VGETEXPPD, 1010 | ZYDIS_MNEMONIC_VGETEXPPS, 1011 | ZYDIS_MNEMONIC_VGETEXPSD, 1012 | ZYDIS_MNEMONIC_VGETEXPSS, 1013 | ZYDIS_MNEMONIC_VGETMANTPD, 1014 | ZYDIS_MNEMONIC_VGETMANTPS, 1015 | ZYDIS_MNEMONIC_VGETMANTSD, 1016 | ZYDIS_MNEMONIC_VGETMANTSS, 1017 | ZYDIS_MNEMONIC_VGF2P8AFFINEINVQB, 1018 | ZYDIS_MNEMONIC_VGF2P8AFFINEQB, 1019 | ZYDIS_MNEMONIC_VGF2P8MULB, 1020 | ZYDIS_MNEMONIC_VGMAXABSPS, 1021 | ZYDIS_MNEMONIC_VGMAXPD, 1022 | ZYDIS_MNEMONIC_VGMAXPS, 1023 | ZYDIS_MNEMONIC_VGMINPD, 1024 | ZYDIS_MNEMONIC_VGMINPS, 1025 | ZYDIS_MNEMONIC_VHADDPD, 1026 | ZYDIS_MNEMONIC_VHADDPS, 1027 | ZYDIS_MNEMONIC_VHSUBPD, 1028 | ZYDIS_MNEMONIC_VHSUBPS, 1029 | ZYDIS_MNEMONIC_VINSERTF128, 1030 | ZYDIS_MNEMONIC_VINSERTF32X4, 1031 | ZYDIS_MNEMONIC_VINSERTF32X8, 1032 | ZYDIS_MNEMONIC_VINSERTF64X2, 1033 | ZYDIS_MNEMONIC_VINSERTF64X4, 1034 | ZYDIS_MNEMONIC_VINSERTI128, 1035 | ZYDIS_MNEMONIC_VINSERTI32X4, 1036 | ZYDIS_MNEMONIC_VINSERTI32X8, 1037 | ZYDIS_MNEMONIC_VINSERTI64X2, 1038 | ZYDIS_MNEMONIC_VINSERTI64X4, 1039 | ZYDIS_MNEMONIC_VINSERTPS, 1040 | ZYDIS_MNEMONIC_VLDDQU, 1041 | ZYDIS_MNEMONIC_VLDMXCSR, 1042 | ZYDIS_MNEMONIC_VLOADUNPACKHD, 1043 | ZYDIS_MNEMONIC_VLOADUNPACKHPD, 1044 | ZYDIS_MNEMONIC_VLOADUNPACKHPS, 1045 | ZYDIS_MNEMONIC_VLOADUNPACKHQ, 1046 | ZYDIS_MNEMONIC_VLOADUNPACKLD, 1047 | ZYDIS_MNEMONIC_VLOADUNPACKLPD, 1048 | ZYDIS_MNEMONIC_VLOADUNPACKLPS, 1049 | ZYDIS_MNEMONIC_VLOADUNPACKLQ, 1050 | ZYDIS_MNEMONIC_VLOG2PS, 1051 | ZYDIS_MNEMONIC_VMASKMOVDQU, 1052 | ZYDIS_MNEMONIC_VMASKMOVPD, 1053 | ZYDIS_MNEMONIC_VMASKMOVPS, 1054 | ZYDIS_MNEMONIC_VMAXPD, 1055 | ZYDIS_MNEMONIC_VMAXPS, 1056 | ZYDIS_MNEMONIC_VMAXSD, 1057 | ZYDIS_MNEMONIC_VMAXSS, 1058 | ZYDIS_MNEMONIC_VMCALL, 1059 | ZYDIS_MNEMONIC_VMCLEAR, 1060 | ZYDIS_MNEMONIC_VMFUNC, 1061 | ZYDIS_MNEMONIC_VMINPD, 1062 | ZYDIS_MNEMONIC_VMINPS, 1063 | ZYDIS_MNEMONIC_VMINSD, 1064 | ZYDIS_MNEMONIC_VMINSS, 1065 | ZYDIS_MNEMONIC_VMLAUNCH, 1066 | ZYDIS_MNEMONIC_VMLOAD, 1067 | ZYDIS_MNEMONIC_VMMCALL, 1068 | ZYDIS_MNEMONIC_VMOVAPD, 1069 | ZYDIS_MNEMONIC_VMOVAPS, 1070 | ZYDIS_MNEMONIC_VMOVD, 1071 | ZYDIS_MNEMONIC_VMOVDDUP, 1072 | ZYDIS_MNEMONIC_VMOVDQA, 1073 | ZYDIS_MNEMONIC_VMOVDQA32, 1074 | ZYDIS_MNEMONIC_VMOVDQA64, 1075 | ZYDIS_MNEMONIC_VMOVDQU, 1076 | ZYDIS_MNEMONIC_VMOVDQU16, 1077 | ZYDIS_MNEMONIC_VMOVDQU32, 1078 | ZYDIS_MNEMONIC_VMOVDQU64, 1079 | ZYDIS_MNEMONIC_VMOVDQU8, 1080 | ZYDIS_MNEMONIC_VMOVHLPS, 1081 | ZYDIS_MNEMONIC_VMOVHPD, 1082 | ZYDIS_MNEMONIC_VMOVHPS, 1083 | ZYDIS_MNEMONIC_VMOVLHPS, 1084 | ZYDIS_MNEMONIC_VMOVLPD, 1085 | ZYDIS_MNEMONIC_VMOVLPS, 1086 | ZYDIS_MNEMONIC_VMOVMSKPD, 1087 | ZYDIS_MNEMONIC_VMOVMSKPS, 1088 | ZYDIS_MNEMONIC_VMOVNRAPD, 1089 | ZYDIS_MNEMONIC_VMOVNRAPS, 1090 | ZYDIS_MNEMONIC_VMOVNRNGOAPD, 1091 | ZYDIS_MNEMONIC_VMOVNRNGOAPS, 1092 | ZYDIS_MNEMONIC_VMOVNTDQ, 1093 | ZYDIS_MNEMONIC_VMOVNTDQA, 1094 | ZYDIS_MNEMONIC_VMOVNTPD, 1095 | ZYDIS_MNEMONIC_VMOVNTPS, 1096 | ZYDIS_MNEMONIC_VMOVQ, 1097 | ZYDIS_MNEMONIC_VMOVSD, 1098 | ZYDIS_MNEMONIC_VMOVSHDUP, 1099 | ZYDIS_MNEMONIC_VMOVSLDUP, 1100 | ZYDIS_MNEMONIC_VMOVSS, 1101 | ZYDIS_MNEMONIC_VMOVUPD, 1102 | ZYDIS_MNEMONIC_VMOVUPS, 1103 | ZYDIS_MNEMONIC_VMPSADBW, 1104 | ZYDIS_MNEMONIC_VMPTRLD, 1105 | ZYDIS_MNEMONIC_VMPTRST, 1106 | ZYDIS_MNEMONIC_VMREAD, 1107 | ZYDIS_MNEMONIC_VMRESUME, 1108 | ZYDIS_MNEMONIC_VMRUN, 1109 | ZYDIS_MNEMONIC_VMSAVE, 1110 | ZYDIS_MNEMONIC_VMULPD, 1111 | ZYDIS_MNEMONIC_VMULPS, 1112 | ZYDIS_MNEMONIC_VMULSD, 1113 | ZYDIS_MNEMONIC_VMULSS, 1114 | ZYDIS_MNEMONIC_VMWRITE, 1115 | ZYDIS_MNEMONIC_VMXOFF, 1116 | ZYDIS_MNEMONIC_VMXON, 1117 | ZYDIS_MNEMONIC_VORPD, 1118 | ZYDIS_MNEMONIC_VORPS, 1119 | ZYDIS_MNEMONIC_VP4DPWSSD, 1120 | ZYDIS_MNEMONIC_VP4DPWSSDS, 1121 | ZYDIS_MNEMONIC_VPABSB, 1122 | ZYDIS_MNEMONIC_VPABSD, 1123 | ZYDIS_MNEMONIC_VPABSQ, 1124 | ZYDIS_MNEMONIC_VPABSW, 1125 | ZYDIS_MNEMONIC_VPACKSSDW, 1126 | ZYDIS_MNEMONIC_VPACKSSWB, 1127 | ZYDIS_MNEMONIC_VPACKSTOREHD, 1128 | ZYDIS_MNEMONIC_VPACKSTOREHPD, 1129 | ZYDIS_MNEMONIC_VPACKSTOREHPS, 1130 | ZYDIS_MNEMONIC_VPACKSTOREHQ, 1131 | ZYDIS_MNEMONIC_VPACKSTORELD, 1132 | ZYDIS_MNEMONIC_VPACKSTORELPD, 1133 | ZYDIS_MNEMONIC_VPACKSTORELPS, 1134 | ZYDIS_MNEMONIC_VPACKSTORELQ, 1135 | ZYDIS_MNEMONIC_VPACKUSDW, 1136 | ZYDIS_MNEMONIC_VPACKUSWB, 1137 | ZYDIS_MNEMONIC_VPADCD, 1138 | ZYDIS_MNEMONIC_VPADDB, 1139 | ZYDIS_MNEMONIC_VPADDD, 1140 | ZYDIS_MNEMONIC_VPADDQ, 1141 | ZYDIS_MNEMONIC_VPADDSB, 1142 | ZYDIS_MNEMONIC_VPADDSETCD, 1143 | ZYDIS_MNEMONIC_VPADDSETSD, 1144 | ZYDIS_MNEMONIC_VPADDSW, 1145 | ZYDIS_MNEMONIC_VPADDUSB, 1146 | ZYDIS_MNEMONIC_VPADDUSW, 1147 | ZYDIS_MNEMONIC_VPADDW, 1148 | ZYDIS_MNEMONIC_VPALIGNR, 1149 | ZYDIS_MNEMONIC_VPAND, 1150 | ZYDIS_MNEMONIC_VPANDD, 1151 | ZYDIS_MNEMONIC_VPANDN, 1152 | ZYDIS_MNEMONIC_VPANDND, 1153 | ZYDIS_MNEMONIC_VPANDNQ, 1154 | ZYDIS_MNEMONIC_VPANDQ, 1155 | ZYDIS_MNEMONIC_VPAVGB, 1156 | ZYDIS_MNEMONIC_VPAVGW, 1157 | ZYDIS_MNEMONIC_VPBLENDD, 1158 | ZYDIS_MNEMONIC_VPBLENDMB, 1159 | ZYDIS_MNEMONIC_VPBLENDMD, 1160 | ZYDIS_MNEMONIC_VPBLENDMQ, 1161 | ZYDIS_MNEMONIC_VPBLENDMW, 1162 | ZYDIS_MNEMONIC_VPBLENDVB, 1163 | ZYDIS_MNEMONIC_VPBLENDW, 1164 | ZYDIS_MNEMONIC_VPBROADCASTB, 1165 | ZYDIS_MNEMONIC_VPBROADCASTD, 1166 | ZYDIS_MNEMONIC_VPBROADCASTMB2Q, 1167 | ZYDIS_MNEMONIC_VPBROADCASTMW2D, 1168 | ZYDIS_MNEMONIC_VPBROADCASTQ, 1169 | ZYDIS_MNEMONIC_VPBROADCASTW, 1170 | ZYDIS_MNEMONIC_VPCLMULQDQ, 1171 | ZYDIS_MNEMONIC_VPCMOV, 1172 | ZYDIS_MNEMONIC_VPCMPB, 1173 | ZYDIS_MNEMONIC_VPCMPD, 1174 | ZYDIS_MNEMONIC_VPCMPEQB, 1175 | ZYDIS_MNEMONIC_VPCMPEQD, 1176 | ZYDIS_MNEMONIC_VPCMPEQQ, 1177 | ZYDIS_MNEMONIC_VPCMPEQW, 1178 | ZYDIS_MNEMONIC_VPCMPESTRI, 1179 | ZYDIS_MNEMONIC_VPCMPESTRM, 1180 | ZYDIS_MNEMONIC_VPCMPGTB, 1181 | ZYDIS_MNEMONIC_VPCMPGTD, 1182 | ZYDIS_MNEMONIC_VPCMPGTQ, 1183 | ZYDIS_MNEMONIC_VPCMPGTW, 1184 | ZYDIS_MNEMONIC_VPCMPISTRI, 1185 | ZYDIS_MNEMONIC_VPCMPISTRM, 1186 | ZYDIS_MNEMONIC_VPCMPLTD, 1187 | ZYDIS_MNEMONIC_VPCMPQ, 1188 | ZYDIS_MNEMONIC_VPCMPUB, 1189 | ZYDIS_MNEMONIC_VPCMPUD, 1190 | ZYDIS_MNEMONIC_VPCMPUQ, 1191 | ZYDIS_MNEMONIC_VPCMPUW, 1192 | ZYDIS_MNEMONIC_VPCMPW, 1193 | ZYDIS_MNEMONIC_VPCOMB, 1194 | ZYDIS_MNEMONIC_VPCOMD, 1195 | ZYDIS_MNEMONIC_VPCOMPRESSB, 1196 | ZYDIS_MNEMONIC_VPCOMPRESSD, 1197 | ZYDIS_MNEMONIC_VPCOMPRESSQ, 1198 | ZYDIS_MNEMONIC_VPCOMPRESSW, 1199 | ZYDIS_MNEMONIC_VPCOMQ, 1200 | ZYDIS_MNEMONIC_VPCOMUB, 1201 | ZYDIS_MNEMONIC_VPCOMUD, 1202 | ZYDIS_MNEMONIC_VPCOMUQ, 1203 | ZYDIS_MNEMONIC_VPCOMUW, 1204 | ZYDIS_MNEMONIC_VPCOMW, 1205 | ZYDIS_MNEMONIC_VPCONFLICTD, 1206 | ZYDIS_MNEMONIC_VPCONFLICTQ, 1207 | ZYDIS_MNEMONIC_VPDPBUSD, 1208 | ZYDIS_MNEMONIC_VPDPBUSDS, 1209 | ZYDIS_MNEMONIC_VPDPWSSD, 1210 | ZYDIS_MNEMONIC_VPDPWSSDS, 1211 | ZYDIS_MNEMONIC_VPERM2F128, 1212 | ZYDIS_MNEMONIC_VPERM2I128, 1213 | ZYDIS_MNEMONIC_VPERMB, 1214 | ZYDIS_MNEMONIC_VPERMD, 1215 | ZYDIS_MNEMONIC_VPERMF32X4, 1216 | ZYDIS_MNEMONIC_VPERMI2B, 1217 | ZYDIS_MNEMONIC_VPERMI2D, 1218 | ZYDIS_MNEMONIC_VPERMI2PD, 1219 | ZYDIS_MNEMONIC_VPERMI2PS, 1220 | ZYDIS_MNEMONIC_VPERMI2Q, 1221 | ZYDIS_MNEMONIC_VPERMI2W, 1222 | ZYDIS_MNEMONIC_VPERMIL2PD, 1223 | ZYDIS_MNEMONIC_VPERMIL2PS, 1224 | ZYDIS_MNEMONIC_VPERMILPD, 1225 | ZYDIS_MNEMONIC_VPERMILPS, 1226 | ZYDIS_MNEMONIC_VPERMPD, 1227 | ZYDIS_MNEMONIC_VPERMPS, 1228 | ZYDIS_MNEMONIC_VPERMQ, 1229 | ZYDIS_MNEMONIC_VPERMT2B, 1230 | ZYDIS_MNEMONIC_VPERMT2D, 1231 | ZYDIS_MNEMONIC_VPERMT2PD, 1232 | ZYDIS_MNEMONIC_VPERMT2PS, 1233 | ZYDIS_MNEMONIC_VPERMT2Q, 1234 | ZYDIS_MNEMONIC_VPERMT2W, 1235 | ZYDIS_MNEMONIC_VPERMW, 1236 | ZYDIS_MNEMONIC_VPEXPANDB, 1237 | ZYDIS_MNEMONIC_VPEXPANDD, 1238 | ZYDIS_MNEMONIC_VPEXPANDQ, 1239 | ZYDIS_MNEMONIC_VPEXPANDW, 1240 | ZYDIS_MNEMONIC_VPEXTRB, 1241 | ZYDIS_MNEMONIC_VPEXTRD, 1242 | ZYDIS_MNEMONIC_VPEXTRQ, 1243 | ZYDIS_MNEMONIC_VPEXTRW, 1244 | ZYDIS_MNEMONIC_VPGATHERDD, 1245 | ZYDIS_MNEMONIC_VPGATHERDQ, 1246 | ZYDIS_MNEMONIC_VPGATHERQD, 1247 | ZYDIS_MNEMONIC_VPGATHERQQ, 1248 | ZYDIS_MNEMONIC_VPHADDBD, 1249 | ZYDIS_MNEMONIC_VPHADDBQ, 1250 | ZYDIS_MNEMONIC_VPHADDBW, 1251 | ZYDIS_MNEMONIC_VPHADDD, 1252 | ZYDIS_MNEMONIC_VPHADDDQ, 1253 | ZYDIS_MNEMONIC_VPHADDSW, 1254 | ZYDIS_MNEMONIC_VPHADDUBD, 1255 | ZYDIS_MNEMONIC_VPHADDUBQ, 1256 | ZYDIS_MNEMONIC_VPHADDUBW, 1257 | ZYDIS_MNEMONIC_VPHADDUDQ, 1258 | ZYDIS_MNEMONIC_VPHADDUWD, 1259 | ZYDIS_MNEMONIC_VPHADDUWQ, 1260 | ZYDIS_MNEMONIC_VPHADDW, 1261 | ZYDIS_MNEMONIC_VPHADDWD, 1262 | ZYDIS_MNEMONIC_VPHADDWQ, 1263 | ZYDIS_MNEMONIC_VPHMINPOSUW, 1264 | ZYDIS_MNEMONIC_VPHSUBBW, 1265 | ZYDIS_MNEMONIC_VPHSUBD, 1266 | ZYDIS_MNEMONIC_VPHSUBDQ, 1267 | ZYDIS_MNEMONIC_VPHSUBSW, 1268 | ZYDIS_MNEMONIC_VPHSUBW, 1269 | ZYDIS_MNEMONIC_VPHSUBWD, 1270 | ZYDIS_MNEMONIC_VPINSRB, 1271 | ZYDIS_MNEMONIC_VPINSRD, 1272 | ZYDIS_MNEMONIC_VPINSRQ, 1273 | ZYDIS_MNEMONIC_VPINSRW, 1274 | ZYDIS_MNEMONIC_VPLZCNTD, 1275 | ZYDIS_MNEMONIC_VPLZCNTQ, 1276 | ZYDIS_MNEMONIC_VPMACSDD, 1277 | ZYDIS_MNEMONIC_VPMACSDQH, 1278 | ZYDIS_MNEMONIC_VPMACSDQL, 1279 | ZYDIS_MNEMONIC_VPMACSSDD, 1280 | ZYDIS_MNEMONIC_VPMACSSDQH, 1281 | ZYDIS_MNEMONIC_VPMACSSDQL, 1282 | ZYDIS_MNEMONIC_VPMACSSWD, 1283 | ZYDIS_MNEMONIC_VPMACSSWW, 1284 | ZYDIS_MNEMONIC_VPMACSWD, 1285 | ZYDIS_MNEMONIC_VPMACSWW, 1286 | ZYDIS_MNEMONIC_VPMADCSSWD, 1287 | ZYDIS_MNEMONIC_VPMADCSWD, 1288 | ZYDIS_MNEMONIC_VPMADD231D, 1289 | ZYDIS_MNEMONIC_VPMADD233D, 1290 | ZYDIS_MNEMONIC_VPMADD52HUQ, 1291 | ZYDIS_MNEMONIC_VPMADD52LUQ, 1292 | ZYDIS_MNEMONIC_VPMADDUBSW, 1293 | ZYDIS_MNEMONIC_VPMADDWD, 1294 | ZYDIS_MNEMONIC_VPMASKMOVD, 1295 | ZYDIS_MNEMONIC_VPMASKMOVQ, 1296 | ZYDIS_MNEMONIC_VPMAXSB, 1297 | ZYDIS_MNEMONIC_VPMAXSD, 1298 | ZYDIS_MNEMONIC_VPMAXSQ, 1299 | ZYDIS_MNEMONIC_VPMAXSW, 1300 | ZYDIS_MNEMONIC_VPMAXUB, 1301 | ZYDIS_MNEMONIC_VPMAXUD, 1302 | ZYDIS_MNEMONIC_VPMAXUQ, 1303 | ZYDIS_MNEMONIC_VPMAXUW, 1304 | ZYDIS_MNEMONIC_VPMINSB, 1305 | ZYDIS_MNEMONIC_VPMINSD, 1306 | ZYDIS_MNEMONIC_VPMINSQ, 1307 | ZYDIS_MNEMONIC_VPMINSW, 1308 | ZYDIS_MNEMONIC_VPMINUB, 1309 | ZYDIS_MNEMONIC_VPMINUD, 1310 | ZYDIS_MNEMONIC_VPMINUQ, 1311 | ZYDIS_MNEMONIC_VPMINUW, 1312 | ZYDIS_MNEMONIC_VPMOVB2M, 1313 | ZYDIS_MNEMONIC_VPMOVD2M, 1314 | ZYDIS_MNEMONIC_VPMOVDB, 1315 | ZYDIS_MNEMONIC_VPMOVDW, 1316 | ZYDIS_MNEMONIC_VPMOVM2B, 1317 | ZYDIS_MNEMONIC_VPMOVM2D, 1318 | ZYDIS_MNEMONIC_VPMOVM2Q, 1319 | ZYDIS_MNEMONIC_VPMOVM2W, 1320 | ZYDIS_MNEMONIC_VPMOVMSKB, 1321 | ZYDIS_MNEMONIC_VPMOVQ2M, 1322 | ZYDIS_MNEMONIC_VPMOVQB, 1323 | ZYDIS_MNEMONIC_VPMOVQD, 1324 | ZYDIS_MNEMONIC_VPMOVQW, 1325 | ZYDIS_MNEMONIC_VPMOVSDB, 1326 | ZYDIS_MNEMONIC_VPMOVSDW, 1327 | ZYDIS_MNEMONIC_VPMOVSQB, 1328 | ZYDIS_MNEMONIC_VPMOVSQD, 1329 | ZYDIS_MNEMONIC_VPMOVSQW, 1330 | ZYDIS_MNEMONIC_VPMOVSWB, 1331 | ZYDIS_MNEMONIC_VPMOVSXBD, 1332 | ZYDIS_MNEMONIC_VPMOVSXBQ, 1333 | ZYDIS_MNEMONIC_VPMOVSXBW, 1334 | ZYDIS_MNEMONIC_VPMOVSXDQ, 1335 | ZYDIS_MNEMONIC_VPMOVSXWD, 1336 | ZYDIS_MNEMONIC_VPMOVSXWQ, 1337 | ZYDIS_MNEMONIC_VPMOVUSDB, 1338 | ZYDIS_MNEMONIC_VPMOVUSDW, 1339 | ZYDIS_MNEMONIC_VPMOVUSQB, 1340 | ZYDIS_MNEMONIC_VPMOVUSQD, 1341 | ZYDIS_MNEMONIC_VPMOVUSQW, 1342 | ZYDIS_MNEMONIC_VPMOVUSWB, 1343 | ZYDIS_MNEMONIC_VPMOVW2M, 1344 | ZYDIS_MNEMONIC_VPMOVWB, 1345 | ZYDIS_MNEMONIC_VPMOVZXBD, 1346 | ZYDIS_MNEMONIC_VPMOVZXBQ, 1347 | ZYDIS_MNEMONIC_VPMOVZXBW, 1348 | ZYDIS_MNEMONIC_VPMOVZXDQ, 1349 | ZYDIS_MNEMONIC_VPMOVZXWD, 1350 | ZYDIS_MNEMONIC_VPMOVZXWQ, 1351 | ZYDIS_MNEMONIC_VPMULDQ, 1352 | ZYDIS_MNEMONIC_VPMULHD, 1353 | ZYDIS_MNEMONIC_VPMULHRSW, 1354 | ZYDIS_MNEMONIC_VPMULHUD, 1355 | ZYDIS_MNEMONIC_VPMULHUW, 1356 | ZYDIS_MNEMONIC_VPMULHW, 1357 | ZYDIS_MNEMONIC_VPMULLD, 1358 | ZYDIS_MNEMONIC_VPMULLQ, 1359 | ZYDIS_MNEMONIC_VPMULLW, 1360 | ZYDIS_MNEMONIC_VPMULTISHIFTQB, 1361 | ZYDIS_MNEMONIC_VPMULUDQ, 1362 | ZYDIS_MNEMONIC_VPOPCNTB, 1363 | ZYDIS_MNEMONIC_VPOPCNTD, 1364 | ZYDIS_MNEMONIC_VPOPCNTQ, 1365 | ZYDIS_MNEMONIC_VPOPCNTW, 1366 | ZYDIS_MNEMONIC_VPOR, 1367 | ZYDIS_MNEMONIC_VPORD, 1368 | ZYDIS_MNEMONIC_VPORQ, 1369 | ZYDIS_MNEMONIC_VPPERM, 1370 | ZYDIS_MNEMONIC_VPREFETCH0, 1371 | ZYDIS_MNEMONIC_VPREFETCH1, 1372 | ZYDIS_MNEMONIC_VPREFETCH2, 1373 | ZYDIS_MNEMONIC_VPREFETCHE0, 1374 | ZYDIS_MNEMONIC_VPREFETCHE1, 1375 | ZYDIS_MNEMONIC_VPREFETCHE2, 1376 | ZYDIS_MNEMONIC_VPREFETCHENTA, 1377 | ZYDIS_MNEMONIC_VPREFETCHNTA, 1378 | ZYDIS_MNEMONIC_VPROLD, 1379 | ZYDIS_MNEMONIC_VPROLQ, 1380 | ZYDIS_MNEMONIC_VPROLVD, 1381 | ZYDIS_MNEMONIC_VPROLVQ, 1382 | ZYDIS_MNEMONIC_VPRORD, 1383 | ZYDIS_MNEMONIC_VPRORQ, 1384 | ZYDIS_MNEMONIC_VPRORVD, 1385 | ZYDIS_MNEMONIC_VPRORVQ, 1386 | ZYDIS_MNEMONIC_VPROTB, 1387 | ZYDIS_MNEMONIC_VPROTD, 1388 | ZYDIS_MNEMONIC_VPROTQ, 1389 | ZYDIS_MNEMONIC_VPROTW, 1390 | ZYDIS_MNEMONIC_VPSADBW, 1391 | ZYDIS_MNEMONIC_VPSBBD, 1392 | ZYDIS_MNEMONIC_VPSBBRD, 1393 | ZYDIS_MNEMONIC_VPSCATTERDD, 1394 | ZYDIS_MNEMONIC_VPSCATTERDQ, 1395 | ZYDIS_MNEMONIC_VPSCATTERQD, 1396 | ZYDIS_MNEMONIC_VPSCATTERQQ, 1397 | ZYDIS_MNEMONIC_VPSHAB, 1398 | ZYDIS_MNEMONIC_VPSHAD, 1399 | ZYDIS_MNEMONIC_VPSHAQ, 1400 | ZYDIS_MNEMONIC_VPSHAW, 1401 | ZYDIS_MNEMONIC_VPSHLB, 1402 | ZYDIS_MNEMONIC_VPSHLD, 1403 | ZYDIS_MNEMONIC_VPSHLDD, 1404 | ZYDIS_MNEMONIC_VPSHLDQ, 1405 | ZYDIS_MNEMONIC_VPSHLDVD, 1406 | ZYDIS_MNEMONIC_VPSHLDVQ, 1407 | ZYDIS_MNEMONIC_VPSHLDVW, 1408 | ZYDIS_MNEMONIC_VPSHLDW, 1409 | ZYDIS_MNEMONIC_VPSHLQ, 1410 | ZYDIS_MNEMONIC_VPSHLW, 1411 | ZYDIS_MNEMONIC_VPSHRDD, 1412 | ZYDIS_MNEMONIC_VPSHRDQ, 1413 | ZYDIS_MNEMONIC_VPSHRDVD, 1414 | ZYDIS_MNEMONIC_VPSHRDVQ, 1415 | ZYDIS_MNEMONIC_VPSHRDVW, 1416 | ZYDIS_MNEMONIC_VPSHRDW, 1417 | ZYDIS_MNEMONIC_VPSHUFB, 1418 | ZYDIS_MNEMONIC_VPSHUFBITQMB, 1419 | ZYDIS_MNEMONIC_VPSHUFD, 1420 | ZYDIS_MNEMONIC_VPSHUFHW, 1421 | ZYDIS_MNEMONIC_VPSHUFLW, 1422 | ZYDIS_MNEMONIC_VPSIGNB, 1423 | ZYDIS_MNEMONIC_VPSIGND, 1424 | ZYDIS_MNEMONIC_VPSIGNW, 1425 | ZYDIS_MNEMONIC_VPSLLD, 1426 | ZYDIS_MNEMONIC_VPSLLDQ, 1427 | ZYDIS_MNEMONIC_VPSLLQ, 1428 | ZYDIS_MNEMONIC_VPSLLVD, 1429 | ZYDIS_MNEMONIC_VPSLLVQ, 1430 | ZYDIS_MNEMONIC_VPSLLVW, 1431 | ZYDIS_MNEMONIC_VPSLLW, 1432 | ZYDIS_MNEMONIC_VPSRAD, 1433 | ZYDIS_MNEMONIC_VPSRAQ, 1434 | ZYDIS_MNEMONIC_VPSRAVD, 1435 | ZYDIS_MNEMONIC_VPSRAVQ, 1436 | ZYDIS_MNEMONIC_VPSRAVW, 1437 | ZYDIS_MNEMONIC_VPSRAW, 1438 | ZYDIS_MNEMONIC_VPSRLD, 1439 | ZYDIS_MNEMONIC_VPSRLDQ, 1440 | ZYDIS_MNEMONIC_VPSRLQ, 1441 | ZYDIS_MNEMONIC_VPSRLVD, 1442 | ZYDIS_MNEMONIC_VPSRLVQ, 1443 | ZYDIS_MNEMONIC_VPSRLVW, 1444 | ZYDIS_MNEMONIC_VPSRLW, 1445 | ZYDIS_MNEMONIC_VPSUBB, 1446 | ZYDIS_MNEMONIC_VPSUBD, 1447 | ZYDIS_MNEMONIC_VPSUBQ, 1448 | ZYDIS_MNEMONIC_VPSUBRD, 1449 | ZYDIS_MNEMONIC_VPSUBRSETBD, 1450 | ZYDIS_MNEMONIC_VPSUBSB, 1451 | ZYDIS_MNEMONIC_VPSUBSETBD, 1452 | ZYDIS_MNEMONIC_VPSUBSW, 1453 | ZYDIS_MNEMONIC_VPSUBUSB, 1454 | ZYDIS_MNEMONIC_VPSUBUSW, 1455 | ZYDIS_MNEMONIC_VPSUBW, 1456 | ZYDIS_MNEMONIC_VPTERNLOGD, 1457 | ZYDIS_MNEMONIC_VPTERNLOGQ, 1458 | ZYDIS_MNEMONIC_VPTEST, 1459 | ZYDIS_MNEMONIC_VPTESTMB, 1460 | ZYDIS_MNEMONIC_VPTESTMD, 1461 | ZYDIS_MNEMONIC_VPTESTMQ, 1462 | ZYDIS_MNEMONIC_VPTESTMW, 1463 | ZYDIS_MNEMONIC_VPTESTNMB, 1464 | ZYDIS_MNEMONIC_VPTESTNMD, 1465 | ZYDIS_MNEMONIC_VPTESTNMQ, 1466 | ZYDIS_MNEMONIC_VPTESTNMW, 1467 | ZYDIS_MNEMONIC_VPUNPCKHBW, 1468 | ZYDIS_MNEMONIC_VPUNPCKHDQ, 1469 | ZYDIS_MNEMONIC_VPUNPCKHQDQ, 1470 | ZYDIS_MNEMONIC_VPUNPCKHWD, 1471 | ZYDIS_MNEMONIC_VPUNPCKLBW, 1472 | ZYDIS_MNEMONIC_VPUNPCKLDQ, 1473 | ZYDIS_MNEMONIC_VPUNPCKLQDQ, 1474 | ZYDIS_MNEMONIC_VPUNPCKLWD, 1475 | ZYDIS_MNEMONIC_VPXOR, 1476 | ZYDIS_MNEMONIC_VPXORD, 1477 | ZYDIS_MNEMONIC_VPXORQ, 1478 | ZYDIS_MNEMONIC_VRANGEPD, 1479 | ZYDIS_MNEMONIC_VRANGEPS, 1480 | ZYDIS_MNEMONIC_VRANGESD, 1481 | ZYDIS_MNEMONIC_VRANGESS, 1482 | ZYDIS_MNEMONIC_VRCP14PD, 1483 | ZYDIS_MNEMONIC_VRCP14PS, 1484 | ZYDIS_MNEMONIC_VRCP14SD, 1485 | ZYDIS_MNEMONIC_VRCP14SS, 1486 | ZYDIS_MNEMONIC_VRCP23PS, 1487 | ZYDIS_MNEMONIC_VRCP28PD, 1488 | ZYDIS_MNEMONIC_VRCP28PS, 1489 | ZYDIS_MNEMONIC_VRCP28SD, 1490 | ZYDIS_MNEMONIC_VRCP28SS, 1491 | ZYDIS_MNEMONIC_VRCPPS, 1492 | ZYDIS_MNEMONIC_VRCPSS, 1493 | ZYDIS_MNEMONIC_VREDUCEPD, 1494 | ZYDIS_MNEMONIC_VREDUCEPS, 1495 | ZYDIS_MNEMONIC_VREDUCESD, 1496 | ZYDIS_MNEMONIC_VREDUCESS, 1497 | ZYDIS_MNEMONIC_VRNDFXPNTPD, 1498 | ZYDIS_MNEMONIC_VRNDFXPNTPS, 1499 | ZYDIS_MNEMONIC_VRNDSCALEPD, 1500 | ZYDIS_MNEMONIC_VRNDSCALEPS, 1501 | ZYDIS_MNEMONIC_VRNDSCALESD, 1502 | ZYDIS_MNEMONIC_VRNDSCALESS, 1503 | ZYDIS_MNEMONIC_VROUNDPD, 1504 | ZYDIS_MNEMONIC_VROUNDPS, 1505 | ZYDIS_MNEMONIC_VROUNDSD, 1506 | ZYDIS_MNEMONIC_VROUNDSS, 1507 | ZYDIS_MNEMONIC_VRSQRT14PD, 1508 | ZYDIS_MNEMONIC_VRSQRT14PS, 1509 | ZYDIS_MNEMONIC_VRSQRT14SD, 1510 | ZYDIS_MNEMONIC_VRSQRT14SS, 1511 | ZYDIS_MNEMONIC_VRSQRT23PS, 1512 | ZYDIS_MNEMONIC_VRSQRT28PD, 1513 | ZYDIS_MNEMONIC_VRSQRT28PS, 1514 | ZYDIS_MNEMONIC_VRSQRT28SD, 1515 | ZYDIS_MNEMONIC_VRSQRT28SS, 1516 | ZYDIS_MNEMONIC_VRSQRTPS, 1517 | ZYDIS_MNEMONIC_VRSQRTSS, 1518 | ZYDIS_MNEMONIC_VSCALEFPD, 1519 | ZYDIS_MNEMONIC_VSCALEFPS, 1520 | ZYDIS_MNEMONIC_VSCALEFSD, 1521 | ZYDIS_MNEMONIC_VSCALEFSS, 1522 | ZYDIS_MNEMONIC_VSCALEPS, 1523 | ZYDIS_MNEMONIC_VSCATTERDPD, 1524 | ZYDIS_MNEMONIC_VSCATTERDPS, 1525 | ZYDIS_MNEMONIC_VSCATTERPF0DPD, 1526 | ZYDIS_MNEMONIC_VSCATTERPF0DPS, 1527 | ZYDIS_MNEMONIC_VSCATTERPF0HINTDPD, 1528 | ZYDIS_MNEMONIC_VSCATTERPF0HINTDPS, 1529 | ZYDIS_MNEMONIC_VSCATTERPF0QPD, 1530 | ZYDIS_MNEMONIC_VSCATTERPF0QPS, 1531 | ZYDIS_MNEMONIC_VSCATTERPF1DPD, 1532 | ZYDIS_MNEMONIC_VSCATTERPF1DPS, 1533 | ZYDIS_MNEMONIC_VSCATTERPF1QPD, 1534 | ZYDIS_MNEMONIC_VSCATTERPF1QPS, 1535 | ZYDIS_MNEMONIC_VSCATTERQPD, 1536 | ZYDIS_MNEMONIC_VSCATTERQPS, 1537 | ZYDIS_MNEMONIC_VSHUFF32X4, 1538 | ZYDIS_MNEMONIC_VSHUFF64X2, 1539 | ZYDIS_MNEMONIC_VSHUFI32X4, 1540 | ZYDIS_MNEMONIC_VSHUFI64X2, 1541 | ZYDIS_MNEMONIC_VSHUFPD, 1542 | ZYDIS_MNEMONIC_VSHUFPS, 1543 | ZYDIS_MNEMONIC_VSQRTPD, 1544 | ZYDIS_MNEMONIC_VSQRTPS, 1545 | ZYDIS_MNEMONIC_VSQRTSD, 1546 | ZYDIS_MNEMONIC_VSQRTSS, 1547 | ZYDIS_MNEMONIC_VSTMXCSR, 1548 | ZYDIS_MNEMONIC_VSUBPD, 1549 | ZYDIS_MNEMONIC_VSUBPS, 1550 | ZYDIS_MNEMONIC_VSUBRPD, 1551 | ZYDIS_MNEMONIC_VSUBRPS, 1552 | ZYDIS_MNEMONIC_VSUBSD, 1553 | ZYDIS_MNEMONIC_VSUBSS, 1554 | ZYDIS_MNEMONIC_VTESTPD, 1555 | ZYDIS_MNEMONIC_VTESTPS, 1556 | ZYDIS_MNEMONIC_VUCOMISD, 1557 | ZYDIS_MNEMONIC_VUCOMISS, 1558 | ZYDIS_MNEMONIC_VUNPCKHPD, 1559 | ZYDIS_MNEMONIC_VUNPCKHPS, 1560 | ZYDIS_MNEMONIC_VUNPCKLPD, 1561 | ZYDIS_MNEMONIC_VUNPCKLPS, 1562 | ZYDIS_MNEMONIC_VXORPD, 1563 | ZYDIS_MNEMONIC_VXORPS, 1564 | ZYDIS_MNEMONIC_VZEROALL, 1565 | ZYDIS_MNEMONIC_VZEROUPPER, 1566 | ZYDIS_MNEMONIC_WBINVD, 1567 | ZYDIS_MNEMONIC_WRFSBASE, 1568 | ZYDIS_MNEMONIC_WRGSBASE, 1569 | ZYDIS_MNEMONIC_WRMSR, 1570 | ZYDIS_MNEMONIC_WRPKRU, 1571 | ZYDIS_MNEMONIC_WRSSD, 1572 | ZYDIS_MNEMONIC_WRSSQ, 1573 | ZYDIS_MNEMONIC_WRUSSD, 1574 | ZYDIS_MNEMONIC_WRUSSQ, 1575 | ZYDIS_MNEMONIC_XABORT, 1576 | ZYDIS_MNEMONIC_XADD, 1577 | ZYDIS_MNEMONIC_XBEGIN, 1578 | ZYDIS_MNEMONIC_XCHG, 1579 | ZYDIS_MNEMONIC_XEND, 1580 | ZYDIS_MNEMONIC_XGETBV, 1581 | ZYDIS_MNEMONIC_XLAT, 1582 | ZYDIS_MNEMONIC_XOR, 1583 | ZYDIS_MNEMONIC_XORPD, 1584 | ZYDIS_MNEMONIC_XORPS, 1585 | ZYDIS_MNEMONIC_XRSTOR, 1586 | ZYDIS_MNEMONIC_XRSTOR64, 1587 | ZYDIS_MNEMONIC_XRSTORS, 1588 | ZYDIS_MNEMONIC_XRSTORS64, 1589 | ZYDIS_MNEMONIC_XSAVE, 1590 | ZYDIS_MNEMONIC_XSAVE64, 1591 | ZYDIS_MNEMONIC_XSAVEC, 1592 | ZYDIS_MNEMONIC_XSAVEC64, 1593 | ZYDIS_MNEMONIC_XSAVEOPT, 1594 | ZYDIS_MNEMONIC_XSAVEOPT64, 1595 | ZYDIS_MNEMONIC_XSAVES, 1596 | ZYDIS_MNEMONIC_XSAVES64, 1597 | ZYDIS_MNEMONIC_XSETBV, 1598 | ZYDIS_MNEMONIC_XTEST, 1599 | 1600 | /** 1601 | * @brief Maximum value of this enum. 1602 | */ 1603 | ZYDIS_MNEMONIC_MAX_VALUE = ZYDIS_MNEMONIC_XTEST, 1604 | /** 1605 | * @brief Minimum amount of bits required to store a value of this enum. 1606 | */ 1607 | ZYDIS_MNEMONIC_MIN_BITS = 0x000B 1608 | }; 1609 | ]] 1610 | -------------------------------------------------------------------------------- /lj2zydis/ffi/EnumRegister.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | /** 7 | * @brief Defines the `ZydisRegister` datatype. 8 | */ 9 | typedef ZydisU8 ZydisRegister; 10 | 11 | /** 12 | * @brief Values that represent `ZydisRegister` elements. 13 | */ 14 | enum ZydisRegisters 15 | { 16 | ZYDIS_REGISTER_NONE, 17 | 18 | // General purpose registers 8-bit 19 | ZYDIS_REGISTER_AL, 20 | ZYDIS_REGISTER_CL, 21 | ZYDIS_REGISTER_DL, 22 | ZYDIS_REGISTER_BL, 23 | ZYDIS_REGISTER_AH, 24 | ZYDIS_REGISTER_CH, 25 | ZYDIS_REGISTER_DH, 26 | ZYDIS_REGISTER_BH, 27 | ZYDIS_REGISTER_SPL, 28 | ZYDIS_REGISTER_BPL, 29 | ZYDIS_REGISTER_SIL, 30 | ZYDIS_REGISTER_DIL, 31 | ZYDIS_REGISTER_R8B, 32 | ZYDIS_REGISTER_R9B, 33 | ZYDIS_REGISTER_R10B, 34 | ZYDIS_REGISTER_R11B, 35 | ZYDIS_REGISTER_R12B, 36 | ZYDIS_REGISTER_R13B, 37 | ZYDIS_REGISTER_R14B, 38 | ZYDIS_REGISTER_R15B, 39 | // General purpose registers 16-bit 40 | ZYDIS_REGISTER_AX, 41 | ZYDIS_REGISTER_CX, 42 | ZYDIS_REGISTER_DX, 43 | ZYDIS_REGISTER_BX, 44 | ZYDIS_REGISTER_SP, 45 | ZYDIS_REGISTER_BP, 46 | ZYDIS_REGISTER_SI, 47 | ZYDIS_REGISTER_DI, 48 | ZYDIS_REGISTER_R8W, 49 | ZYDIS_REGISTER_R9W, 50 | ZYDIS_REGISTER_R10W, 51 | ZYDIS_REGISTER_R11W, 52 | ZYDIS_REGISTER_R12W, 53 | ZYDIS_REGISTER_R13W, 54 | ZYDIS_REGISTER_R14W, 55 | ZYDIS_REGISTER_R15W, 56 | // General purpose registers 32-bit 57 | ZYDIS_REGISTER_EAX, 58 | ZYDIS_REGISTER_ECX, 59 | ZYDIS_REGISTER_EDX, 60 | ZYDIS_REGISTER_EBX, 61 | ZYDIS_REGISTER_ESP, 62 | ZYDIS_REGISTER_EBP, 63 | ZYDIS_REGISTER_ESI, 64 | ZYDIS_REGISTER_EDI, 65 | ZYDIS_REGISTER_R8D, 66 | ZYDIS_REGISTER_R9D, 67 | ZYDIS_REGISTER_R10D, 68 | ZYDIS_REGISTER_R11D, 69 | ZYDIS_REGISTER_R12D, 70 | ZYDIS_REGISTER_R13D, 71 | ZYDIS_REGISTER_R14D, 72 | ZYDIS_REGISTER_R15D, 73 | // General purpose registers 64-bit 74 | ZYDIS_REGISTER_RAX, 75 | ZYDIS_REGISTER_RCX, 76 | ZYDIS_REGISTER_RDX, 77 | ZYDIS_REGISTER_RBX, 78 | ZYDIS_REGISTER_RSP, 79 | ZYDIS_REGISTER_RBP, 80 | ZYDIS_REGISTER_RSI, 81 | ZYDIS_REGISTER_RDI, 82 | ZYDIS_REGISTER_R8, 83 | ZYDIS_REGISTER_R9, 84 | ZYDIS_REGISTER_R10, 85 | ZYDIS_REGISTER_R11, 86 | ZYDIS_REGISTER_R12, 87 | ZYDIS_REGISTER_R13, 88 | ZYDIS_REGISTER_R14, 89 | ZYDIS_REGISTER_R15, 90 | // Floating point legacy registers 91 | ZYDIS_REGISTER_ST0, 92 | ZYDIS_REGISTER_ST1, 93 | ZYDIS_REGISTER_ST2, 94 | ZYDIS_REGISTER_ST3, 95 | ZYDIS_REGISTER_ST4, 96 | ZYDIS_REGISTER_ST5, 97 | ZYDIS_REGISTER_ST6, 98 | ZYDIS_REGISTER_ST7, 99 | // Floating point multimedia registers 100 | ZYDIS_REGISTER_MM0, 101 | ZYDIS_REGISTER_MM1, 102 | ZYDIS_REGISTER_MM2, 103 | ZYDIS_REGISTER_MM3, 104 | ZYDIS_REGISTER_MM4, 105 | ZYDIS_REGISTER_MM5, 106 | ZYDIS_REGISTER_MM6, 107 | ZYDIS_REGISTER_MM7, 108 | // Floating point vector registers 128-bit 109 | ZYDIS_REGISTER_XMM0, 110 | ZYDIS_REGISTER_XMM1, 111 | ZYDIS_REGISTER_XMM2, 112 | ZYDIS_REGISTER_XMM3, 113 | ZYDIS_REGISTER_XMM4, 114 | ZYDIS_REGISTER_XMM5, 115 | ZYDIS_REGISTER_XMM6, 116 | ZYDIS_REGISTER_XMM7, 117 | ZYDIS_REGISTER_XMM8, 118 | ZYDIS_REGISTER_XMM9, 119 | ZYDIS_REGISTER_XMM10, 120 | ZYDIS_REGISTER_XMM11, 121 | ZYDIS_REGISTER_XMM12, 122 | ZYDIS_REGISTER_XMM13, 123 | ZYDIS_REGISTER_XMM14, 124 | ZYDIS_REGISTER_XMM15, 125 | ZYDIS_REGISTER_XMM16, 126 | ZYDIS_REGISTER_XMM17, 127 | ZYDIS_REGISTER_XMM18, 128 | ZYDIS_REGISTER_XMM19, 129 | ZYDIS_REGISTER_XMM20, 130 | ZYDIS_REGISTER_XMM21, 131 | ZYDIS_REGISTER_XMM22, 132 | ZYDIS_REGISTER_XMM23, 133 | ZYDIS_REGISTER_XMM24, 134 | ZYDIS_REGISTER_XMM25, 135 | ZYDIS_REGISTER_XMM26, 136 | ZYDIS_REGISTER_XMM27, 137 | ZYDIS_REGISTER_XMM28, 138 | ZYDIS_REGISTER_XMM29, 139 | ZYDIS_REGISTER_XMM30, 140 | ZYDIS_REGISTER_XMM31, 141 | // Floating point vector registers 256-bit 142 | ZYDIS_REGISTER_YMM0, 143 | ZYDIS_REGISTER_YMM1, 144 | ZYDIS_REGISTER_YMM2, 145 | ZYDIS_REGISTER_YMM3, 146 | ZYDIS_REGISTER_YMM4, 147 | ZYDIS_REGISTER_YMM5, 148 | ZYDIS_REGISTER_YMM6, 149 | ZYDIS_REGISTER_YMM7, 150 | ZYDIS_REGISTER_YMM8, 151 | ZYDIS_REGISTER_YMM9, 152 | ZYDIS_REGISTER_YMM10, 153 | ZYDIS_REGISTER_YMM11, 154 | ZYDIS_REGISTER_YMM12, 155 | ZYDIS_REGISTER_YMM13, 156 | ZYDIS_REGISTER_YMM14, 157 | ZYDIS_REGISTER_YMM15, 158 | ZYDIS_REGISTER_YMM16, 159 | ZYDIS_REGISTER_YMM17, 160 | ZYDIS_REGISTER_YMM18, 161 | ZYDIS_REGISTER_YMM19, 162 | ZYDIS_REGISTER_YMM20, 163 | ZYDIS_REGISTER_YMM21, 164 | ZYDIS_REGISTER_YMM22, 165 | ZYDIS_REGISTER_YMM23, 166 | ZYDIS_REGISTER_YMM24, 167 | ZYDIS_REGISTER_YMM25, 168 | ZYDIS_REGISTER_YMM26, 169 | ZYDIS_REGISTER_YMM27, 170 | ZYDIS_REGISTER_YMM28, 171 | ZYDIS_REGISTER_YMM29, 172 | ZYDIS_REGISTER_YMM30, 173 | ZYDIS_REGISTER_YMM31, 174 | // Floating point vector registers 512-bit 175 | ZYDIS_REGISTER_ZMM0, 176 | ZYDIS_REGISTER_ZMM1, 177 | ZYDIS_REGISTER_ZMM2, 178 | ZYDIS_REGISTER_ZMM3, 179 | ZYDIS_REGISTER_ZMM4, 180 | ZYDIS_REGISTER_ZMM5, 181 | ZYDIS_REGISTER_ZMM6, 182 | ZYDIS_REGISTER_ZMM7, 183 | ZYDIS_REGISTER_ZMM8, 184 | ZYDIS_REGISTER_ZMM9, 185 | ZYDIS_REGISTER_ZMM10, 186 | ZYDIS_REGISTER_ZMM11, 187 | ZYDIS_REGISTER_ZMM12, 188 | ZYDIS_REGISTER_ZMM13, 189 | ZYDIS_REGISTER_ZMM14, 190 | ZYDIS_REGISTER_ZMM15, 191 | ZYDIS_REGISTER_ZMM16, 192 | ZYDIS_REGISTER_ZMM17, 193 | ZYDIS_REGISTER_ZMM18, 194 | ZYDIS_REGISTER_ZMM19, 195 | ZYDIS_REGISTER_ZMM20, 196 | ZYDIS_REGISTER_ZMM21, 197 | ZYDIS_REGISTER_ZMM22, 198 | ZYDIS_REGISTER_ZMM23, 199 | ZYDIS_REGISTER_ZMM24, 200 | ZYDIS_REGISTER_ZMM25, 201 | ZYDIS_REGISTER_ZMM26, 202 | ZYDIS_REGISTER_ZMM27, 203 | ZYDIS_REGISTER_ZMM28, 204 | ZYDIS_REGISTER_ZMM29, 205 | ZYDIS_REGISTER_ZMM30, 206 | ZYDIS_REGISTER_ZMM31, 207 | // Flags registers 208 | ZYDIS_REGISTER_FLAGS, 209 | ZYDIS_REGISTER_EFLAGS, 210 | ZYDIS_REGISTER_RFLAGS, 211 | // Instruction-pointer registers 212 | ZYDIS_REGISTER_IP, 213 | ZYDIS_REGISTER_EIP, 214 | ZYDIS_REGISTER_RIP, 215 | // Segment registers 216 | ZYDIS_REGISTER_ES, 217 | ZYDIS_REGISTER_CS, 218 | ZYDIS_REGISTER_SS, 219 | ZYDIS_REGISTER_DS, 220 | ZYDIS_REGISTER_FS, 221 | ZYDIS_REGISTER_GS, 222 | // Table registers 223 | ZYDIS_REGISTER_GDTR, 224 | ZYDIS_REGISTER_LDTR, 225 | ZYDIS_REGISTER_IDTR, 226 | ZYDIS_REGISTER_TR, 227 | // Test registers 228 | ZYDIS_REGISTER_TR0, 229 | ZYDIS_REGISTER_TR1, 230 | ZYDIS_REGISTER_TR2, 231 | ZYDIS_REGISTER_TR3, 232 | ZYDIS_REGISTER_TR4, 233 | ZYDIS_REGISTER_TR5, 234 | ZYDIS_REGISTER_TR6, 235 | ZYDIS_REGISTER_TR7, 236 | // Control registers 237 | ZYDIS_REGISTER_CR0, 238 | ZYDIS_REGISTER_CR1, 239 | ZYDIS_REGISTER_CR2, 240 | ZYDIS_REGISTER_CR3, 241 | ZYDIS_REGISTER_CR4, 242 | ZYDIS_REGISTER_CR5, 243 | ZYDIS_REGISTER_CR6, 244 | ZYDIS_REGISTER_CR7, 245 | ZYDIS_REGISTER_CR8, 246 | ZYDIS_REGISTER_CR9, 247 | ZYDIS_REGISTER_CR10, 248 | ZYDIS_REGISTER_CR11, 249 | ZYDIS_REGISTER_CR12, 250 | ZYDIS_REGISTER_CR13, 251 | ZYDIS_REGISTER_CR14, 252 | ZYDIS_REGISTER_CR15, 253 | // Debug registers 254 | ZYDIS_REGISTER_DR0, 255 | ZYDIS_REGISTER_DR1, 256 | ZYDIS_REGISTER_DR2, 257 | ZYDIS_REGISTER_DR3, 258 | ZYDIS_REGISTER_DR4, 259 | ZYDIS_REGISTER_DR5, 260 | ZYDIS_REGISTER_DR6, 261 | ZYDIS_REGISTER_DR7, 262 | ZYDIS_REGISTER_DR8, 263 | ZYDIS_REGISTER_DR9, 264 | ZYDIS_REGISTER_DR10, 265 | ZYDIS_REGISTER_DR11, 266 | ZYDIS_REGISTER_DR12, 267 | ZYDIS_REGISTER_DR13, 268 | ZYDIS_REGISTER_DR14, 269 | ZYDIS_REGISTER_DR15, 270 | // Mask registers 271 | ZYDIS_REGISTER_K0, 272 | ZYDIS_REGISTER_K1, 273 | ZYDIS_REGISTER_K2, 274 | ZYDIS_REGISTER_K3, 275 | ZYDIS_REGISTER_K4, 276 | ZYDIS_REGISTER_K5, 277 | ZYDIS_REGISTER_K6, 278 | ZYDIS_REGISTER_K7, 279 | // Bound registers 280 | ZYDIS_REGISTER_BND0, 281 | ZYDIS_REGISTER_BND1, 282 | ZYDIS_REGISTER_BND2, 283 | ZYDIS_REGISTER_BND3, 284 | ZYDIS_REGISTER_BNDCFG, 285 | ZYDIS_REGISTER_BNDSTATUS, 286 | // Uncategorized 287 | ZYDIS_REGISTER_MXCSR, 288 | ZYDIS_REGISTER_PKRU, 289 | ZYDIS_REGISTER_XCR0, 290 | 291 | 292 | ZYDIS_REGISTER_MAX_VALUE = ZYDIS_REGISTER_XCR0, 293 | 294 | ZYDIS_REGISTER_MIN_BITS = 0x0008 295 | }; 296 | ]] 297 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Formatter.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.DecoderTypes") 4 | require("lj2zydis.ffi.Status") 5 | require("lj2zydis.ffi.String") 6 | 7 | 8 | ffi.cdef[[ 9 | typedef ZydisU8 ZydisFormatterStyle; 10 | 11 | 12 | enum ZydisFormatterStyles 13 | { 14 | ZYDIS_FORMATTER_STYLE_INTEL, 15 | ZYDIS_FORMATTER_STYLE_MAX_VALUE = ZYDIS_FORMATTER_STYLE_INTEL 16 | }; 17 | ]] 18 | 19 | ffi.cdef[[ 20 | typedef ZydisU8 ZydisFormatterProperty; 21 | 22 | enum ZydisFormatterProperties 23 | { 24 | ZYDIS_FORMATTER_PROP_UPPERCASE, 25 | ZYDIS_FORMATTER_PROP_FORCE_MEMSEG, 26 | ZYDIS_FORMATTER_PROP_FORCE_MEMSIZE, 27 | ZYDIS_FORMATTER_PROP_ADDR_FORMAT, 28 | ZYDIS_FORMATTER_PROP_DISP_FORMAT, 29 | ZYDIS_FORMATTER_PROP_IMM_FORMAT, 30 | ZYDIS_FORMATTER_PROP_HEX_UPPERCASE, 31 | ZYDIS_FORMATTER_PROP_HEX_PREFIX, 32 | ZYDIS_FORMATTER_PROP_HEX_SUFFIX, 33 | ZYDIS_FORMATTER_PROP_HEX_PADDING_ADDR, 34 | ZYDIS_FORMATTER_PROP_HEX_PADDING_DISP, 35 | ZYDIS_FORMATTER_PROP_HEX_PADDING_IMM, 36 | 37 | ZYDIS_FORMATTER_PROP_MAX_VALUE = ZYDIS_FORMATTER_PROP_HEX_PADDING_IMM 38 | }; 39 | ]] 40 | 41 | ffi.cdef[[ 42 | 43 | enum ZydisAddressFormat 44 | { 45 | ZYDIS_ADDR_FORMAT_ABSOLUTE, 46 | ZYDIS_ADDR_FORMAT_RELATIVE_SIGNED, 47 | ZYDIS_ADDR_FORMAT_RELATIVE_UNSIGNED, 48 | 49 | ZYDIS_ADDR_FORMAT_MAX_VALUE = ZYDIS_ADDR_FORMAT_RELATIVE_UNSIGNED 50 | }; 51 | ]] 52 | 53 | 54 | ffi.cdef[[ 55 | 56 | enum ZydisDisplacementFormat 57 | { 58 | ZYDIS_DISP_FORMAT_HEX_SIGNED, 59 | ZYDIS_DISP_FORMAT_HEX_UNSIGNED, 60 | 61 | ZYDIS_DISP_FORMAT_MAX_VALUE = ZYDIS_DISP_FORMAT_HEX_UNSIGNED 62 | }; 63 | ]] 64 | 65 | ffi.cdef[[ 66 | 67 | enum ZydisImmediateFormat 68 | { 69 | ZYDIS_IMM_FORMAT_HEX_AUTO, 70 | ZYDIS_IMM_FORMAT_HEX_SIGNED, 71 | ZYDIS_IMM_FORMAT_HEX_UNSIGNED, 72 | 73 | ZYDIS_IMM_FORMAT_MAX_VALUE = ZYDIS_IMM_FORMAT_HEX_UNSIGNED 74 | }; 75 | ]] 76 | 77 | ffi.cdef[[ 78 | 79 | typedef ZydisU8 ZydisFormatterHookType; 80 | 81 | enum ZydisFormatterHookTypes 82 | { 83 | ZYDIS_FORMATTER_HOOK_PRE_INSTRUCTION, 84 | ZYDIS_FORMATTER_HOOK_POST_INSTRUCTION, 85 | ZYDIS_FORMATTER_HOOK_PRE_OPERAND, 86 | ZYDIS_FORMATTER_HOOK_POST_OPERAND, 87 | ZYDIS_FORMATTER_HOOK_FORMAT_INSTRUCTION, 88 | ZYDIS_FORMATTER_HOOK_FORMAT_OPERAND_REG, 89 | ZYDIS_FORMATTER_HOOK_FORMAT_OPERAND_MEM, 90 | ZYDIS_FORMATTER_HOOK_FORMAT_OPERAND_PTR, 91 | ZYDIS_FORMATTER_HOOK_FORMAT_OPERAND_IMM, 92 | ZYDIS_FORMATTER_HOOK_PRINT_MNEMONIC, 93 | ZYDIS_FORMATTER_HOOK_PRINT_REGISTER, 94 | ZYDIS_FORMATTER_HOOK_PRINT_ADDRESS, 95 | ZYDIS_FORMATTER_HOOK_PRINT_DISP, 96 | ZYDIS_FORMATTER_HOOK_PRINT_IMM, 97 | ZYDIS_FORMATTER_HOOK_PRINT_MEMSIZE, 98 | ZYDIS_FORMATTER_HOOK_PRINT_PREFIXES, 99 | ZYDIS_FORMATTER_HOOK_PRINT_DECORATOR, 100 | 101 | ZYDIS_FORMATTER_HOOK_MAX_VALUE = ZYDIS_FORMATTER_HOOK_PRINT_DECORATOR 102 | }; 103 | ]] 104 | 105 | ffi.cdef[[ 106 | 107 | typedef ZydisU8 ZydisDecoratorType; 108 | 109 | enum ZydisDecoratorTypes 110 | { 111 | ZYDIS_DECORATOR_TYPE_INVALID, 112 | ZYDIS_DECORATOR_TYPE_MASK, 113 | ZYDIS_DECORATOR_TYPE_BC, 114 | ZYDIS_DECORATOR_TYPE_RC, 115 | ZYDIS_DECORATOR_TYPE_SAE, 116 | ZYDIS_DECORATOR_TYPE_SWIZZLE, 117 | ZYDIS_DECORATOR_TYPE_CONVERSION, 118 | ZYDIS_DECORATOR_TYPE_EH, 119 | 120 | ZYDIS_DECORATOR_TYPE_MAX_VALUE = ZYDIS_DECORATOR_TYPE_EH 121 | }; 122 | ]] 123 | 124 | ffi.cdef[[ 125 | typedef struct ZydisFormatter_ ZydisFormatter; 126 | 127 | 128 | typedef ZydisStatus (*ZydisFormatterFunc)(const ZydisFormatter* formatter, 129 | ZydisString* string, const ZydisDecodedInstruction* instruction, void* userData); 130 | 131 | 132 | typedef ZydisStatus (*ZydisFormatterOperandFunc)(const ZydisFormatter* formatter, 133 | ZydisString* string, const ZydisDecodedInstruction* instruction, 134 | const ZydisDecodedOperand* operand, void* userData); 135 | 136 | 137 | typedef ZydisStatus (*ZydisFormatterRegisterFunc)(const ZydisFormatter* formatter, 138 | ZydisString* string, const ZydisDecodedInstruction* instruction, 139 | const ZydisDecodedOperand* operand, ZydisRegister reg, void* userData); 140 | 141 | 142 | typedef ZydisStatus (*ZydisFormatterAddressFunc)(const ZydisFormatter* formatter, 143 | ZydisString* string, const ZydisDecodedInstruction* instruction, 144 | const ZydisDecodedOperand* operand, ZydisU64 address, void* userData); 145 | 146 | 147 | typedef ZydisStatus (*ZydisFormatterDecoratorFunc)(const ZydisFormatter* formatter, 148 | ZydisString* string, const ZydisDecodedInstruction* instruction, 149 | const ZydisDecodedOperand* operand, ZydisDecoratorType decorator, void* userData); 150 | ]] 151 | 152 | ffi.cdef[[ 153 | 154 | struct ZydisFormatter_ 155 | { 156 | ZydisLetterCase letterCase; 157 | ZydisBool forceMemorySegment; 158 | ZydisBool forceMemorySize; 159 | ZydisU8 formatAddress; 160 | ZydisU8 formatDisp; 161 | ZydisU8 formatImm; 162 | ZydisBool hexUppercase; 163 | ZydisString* hexPrefix; 164 | ZydisString hexPrefixData; 165 | ZydisString* hexSuffix; 166 | ZydisString hexSuffixData; 167 | ZydisU8 hexPaddingAddress; 168 | ZydisU8 hexPaddingDisp; 169 | ZydisU8 hexPaddingImm; 170 | ZydisFormatterFunc funcPreInstruction; 171 | ZydisFormatterFunc funcPostInstruction; 172 | ZydisFormatterOperandFunc funcPreOperand; 173 | ZydisFormatterOperandFunc funcPostOperand; 174 | ZydisFormatterFunc funcFormatInstruction; 175 | ZydisFormatterOperandFunc funcFormatOperandReg; 176 | ZydisFormatterOperandFunc funcFormatOperandMem; 177 | ZydisFormatterOperandFunc funcFormatOperandPtr; 178 | ZydisFormatterOperandFunc funcFormatOperandImm; 179 | ZydisFormatterFunc funcPrintMnemonic; 180 | ZydisFormatterRegisterFunc funcPrintRegister; 181 | ZydisFormatterAddressFunc funcPrintAddress; 182 | ZydisFormatterOperandFunc funcPrintDisp; 183 | ZydisFormatterOperandFunc funcPrintImm; 184 | ZydisFormatterOperandFunc funcPrintMemSize; 185 | ZydisFormatterFunc funcPrintPrefixes; 186 | ZydisFormatterDecoratorFunc funcPrintDecorator; 187 | }; 188 | ]] 189 | 190 | 191 | ffi.cdef[[ 192 | ZydisStatus ZydisFormatterInit(ZydisFormatter* formatter, ZydisFormatterStyle style); 193 | 194 | 195 | ZydisStatus ZydisFormatterSetProperty(ZydisFormatter* formatter, 196 | ZydisFormatterProperty property, ZydisUPointer value); 197 | 198 | 199 | ZydisStatus ZydisFormatterSetHook(ZydisFormatter* formatter, 200 | ZydisFormatterHookType hook, const void** callback); 201 | 202 | 203 | ZydisStatus ZydisFormatterFormatInstruction(const ZydisFormatter* formatter, 204 | const ZydisDecodedInstruction* instruction, char* buffer, ZydisUSize bufferLen); 205 | 206 | 207 | ZydisStatus ZydisFormatterFormatInstructionEx(const ZydisFormatter* formatter, 208 | const ZydisDecodedInstruction* instruction, char* buffer, ZydisUSize bufferLen, void* userData); 209 | 210 | 211 | ZydisStatus ZydisFormatterFormatOperand(const ZydisFormatter* formatter, 212 | const ZydisDecodedInstruction* instruction, ZydisU8 index, char* buffer, ZydisUSize bufferLen); 213 | 214 | 215 | ZydisStatus ZydisFormatterFormatOperandEx(const ZydisFormatter* formatter, 216 | const ZydisDecodedInstruction* instruction, ZydisU8 index, char* buffer, ZydisUSize bufferLen, 217 | void* userData); 218 | ]] 219 | 220 | 221 | 222 | -------------------------------------------------------------------------------- /lj2zydis/ffi/MetaInfo.lua: -------------------------------------------------------------------------------- 1 | 2 | local ffi = require("ffi") 3 | 4 | 5 | require("lj2zydis.ffi.CommonTypes") 6 | 7 | require("lj2zydis.ffi.EnumInstructionCategory") 8 | require("lj2zydis.ffi.EnumISASet") 9 | require("lj2zydis.ffi.EnumISAExt") 10 | 11 | ffi.cdef[[ 12 | const char* ZydisCategoryGetString(ZydisInstructionCategory category); 13 | const char* ZydisISASetGetString(ZydisISASet isaSet); 14 | const char* ZydisISAExtGetString(ZydisISAExt isaExt); 15 | ]] 16 | 17 | 18 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Mnemonic.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | require("lj2zydis.ffi.String") 5 | require("lj2zydis.ffi.EnumMnemonic") 6 | 7 | 8 | ffi.cdef[[ 9 | const char* ZydisMnemonicGetString(ZydisMnemonic mnemonic); 10 | const ZydisStaticString* ZydisMnemonicGetStaticString(ZydisMnemonic mnemonic); 11 | ]] 12 | 13 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Register.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.String") 4 | require("lj2zydis.ffi.CommonTypes") 5 | require("lj2zydis.ffi.EnumRegister") 6 | 7 | 8 | ffi.cdef[[ 9 | typedef ZydisU8 ZydisRegisterClass; 10 | 11 | enum ZydisRegisterClasses 12 | { 13 | ZYDIS_REGCLASS_INVALID, 14 | ZYDIS_REGCLASS_GPR8, 15 | ZYDIS_REGCLASS_GPR16, 16 | ZYDIS_REGCLASS_GPR32, 17 | ZYDIS_REGCLASS_GPR64, 18 | ZYDIS_REGCLASS_X87, 19 | ZYDIS_REGCLASS_MMX, 20 | ZYDIS_REGCLASS_XMM, 21 | ZYDIS_REGCLASS_YMM, 22 | ZYDIS_REGCLASS_ZMM, 23 | ZYDIS_REGCLASS_FLAGS, 24 | ZYDIS_REGCLASS_IP, 25 | ZYDIS_REGCLASS_SEGMENT, 26 | ZYDIS_REGCLASS_TEST, 27 | ZYDIS_REGCLASS_CONTROL, 28 | ZYDIS_REGCLASS_DEBUG, 29 | ZYDIS_REGCLASS_MASK, 30 | ZYDIS_REGCLASS_BOUND, 31 | 32 | ZYDIS_REGCLASS_MAX_VALUE = ZYDIS_REGCLASS_BOUND 33 | }; 34 | ]] 35 | 36 | ffi.cdef[[ 37 | typedef ZydisU16 ZydisRegisterWidth; 38 | ]] 39 | 40 | ffi.cdef[[ 41 | ZydisRegister ZydisRegisterEncode(ZydisRegisterClass registerClass, ZydisU8 id); 42 | ZydisI16 ZydisRegisterGetId(ZydisRegister reg); 43 | ZydisRegisterClass ZydisRegisterGetClass(ZydisRegister reg); 44 | ZydisRegisterWidth ZydisRegisterGetWidth(ZydisRegister reg); 45 | ZydisRegisterWidth ZydisRegisterGetWidth64(ZydisRegister reg); 46 | const char* ZydisRegisterGetString(ZydisRegister reg); 47 | const ZydisStaticString* ZydisRegisterGetStaticString(ZydisRegister reg); 48 | 49 | ]] 50 | -------------------------------------------------------------------------------- /lj2zydis/ffi/SharedTypes.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | static const int ZYDIS_MAX_INSTRUCTION_LENGTH = 15; 7 | static const int ZYDIS_MAX_OPERAND_COUNT = 10; 8 | ]] 9 | 10 | ffi.cdef[[ 11 | typedef ZydisU8 ZydisMachineMode; 12 | 13 | enum ZydisMachineModes 14 | { 15 | ZYDIS_MACHINE_MODE_INVALID, 16 | ZYDIS_MACHINE_MODE_LONG_64, 17 | ZYDIS_MACHINE_MODE_LONG_COMPAT_32, 18 | ZYDIS_MACHINE_MODE_LONG_COMPAT_16, 19 | ZYDIS_MACHINE_MODE_LEGACY_32, 20 | ZYDIS_MACHINE_MODE_LEGACY_16, 21 | ZYDIS_MACHINE_MODE_REAL_16, 22 | 23 | ZYDIS_MACHINE_MODE_MAX_VALUE = ZYDIS_MACHINE_MODE_REAL_16 24 | }; 25 | ]] 26 | 27 | ffi.cdef[[ 28 | typedef ZydisU8 ZydisAddressWidth; 29 | 30 | enum ZydisAddressWidths 31 | { 32 | ZYDIS_ADDRESS_WIDTH_INVALID = 0, 33 | ZYDIS_ADDRESS_WIDTH_16 = 16, 34 | ZYDIS_ADDRESS_WIDTH_32 = 32, 35 | ZYDIS_ADDRESS_WIDTH_64 = 64, 36 | 37 | ZYDIS_ADDRESS_WIDTH_MAX_VALUE = ZYDIS_ADDRESS_WIDTH_64 38 | }; 39 | ]] 40 | 41 | ffi.cdef[[ 42 | typedef ZydisU8 ZydisElementType; 43 | 44 | 45 | enum ZydisElementTypes 46 | { 47 | ZYDIS_ELEMENT_TYPE_INVALID, 48 | ZYDIS_ELEMENT_TYPE_STRUCT, 49 | ZYDIS_ELEMENT_TYPE_UINT, 50 | ZYDIS_ELEMENT_TYPE_INT, 51 | ZYDIS_ELEMENT_TYPE_FLOAT16, 52 | ZYDIS_ELEMENT_TYPE_FLOAT32, 53 | ZYDIS_ELEMENT_TYPE_FLOAT64, 54 | ZYDIS_ELEMENT_TYPE_FLOAT80, 55 | ZYDIS_ELEMENT_TYPE_LONGBCD, 56 | 57 | 58 | ZYDIS_ELEMENT_TYPE_MAX_VALUE = ZYDIS_ELEMENT_TYPE_LONGBCD 59 | }; 60 | ]] 61 | 62 | ffi.cdef[[ 63 | typedef ZydisU16 ZydisElementSize; 64 | ]] 65 | 66 | ffi.cdef[[ 67 | typedef ZydisU8 ZydisOperandType; 68 | 69 | enum ZydisOperandTypes 70 | { 71 | ZYDIS_OPERAND_TYPE_UNUSED, 72 | ZYDIS_OPERAND_TYPE_REGISTER, 73 | ZYDIS_OPERAND_TYPE_MEMORY, 74 | ZYDIS_OPERAND_TYPE_POINTER, 75 | ZYDIS_OPERAND_TYPE_IMMEDIATE, 76 | 77 | ZYDIS_OPERAND_TYPE_MAX_VALUE = ZYDIS_OPERAND_TYPE_IMMEDIATE 78 | }; 79 | ]] 80 | 81 | ffi.cdef[[ 82 | typedef ZydisU8 ZydisOperandEncoding; 83 | 84 | enum ZydisOperandEncodings 85 | { 86 | ZYDIS_OPERAND_ENCODING_NONE, 87 | ZYDIS_OPERAND_ENCODING_MODRM_REG, 88 | ZYDIS_OPERAND_ENCODING_MODRM_RM, 89 | ZYDIS_OPERAND_ENCODING_OPCODE, 90 | ZYDIS_OPERAND_ENCODING_NDSNDD, 91 | ZYDIS_OPERAND_ENCODING_IS4, 92 | ZYDIS_OPERAND_ENCODING_MASK, 93 | ZYDIS_OPERAND_ENCODING_DISP8, 94 | ZYDIS_OPERAND_ENCODING_DISP16, 95 | ZYDIS_OPERAND_ENCODING_DISP32, 96 | ZYDIS_OPERAND_ENCODING_DISP64, 97 | ZYDIS_OPERAND_ENCODING_DISP16_32_64, 98 | ZYDIS_OPERAND_ENCODING_DISP32_32_64, 99 | ZYDIS_OPERAND_ENCODING_DISP16_32_32, 100 | ZYDIS_OPERAND_ENCODING_UIMM8, 101 | ZYDIS_OPERAND_ENCODING_UIMM16, 102 | ZYDIS_OPERAND_ENCODING_UIMM32, 103 | ZYDIS_OPERAND_ENCODING_UIMM64, 104 | ZYDIS_OPERAND_ENCODING_UIMM16_32_64, 105 | ZYDIS_OPERAND_ENCODING_UIMM32_32_64, 106 | ZYDIS_OPERAND_ENCODING_UIMM16_32_32, 107 | ZYDIS_OPERAND_ENCODING_SIMM8, 108 | ZYDIS_OPERAND_ENCODING_SIMM16, 109 | ZYDIS_OPERAND_ENCODING_SIMM32, 110 | ZYDIS_OPERAND_ENCODING_SIMM64, 111 | ZYDIS_OPERAND_ENCODING_SIMM16_32_64, 112 | ZYDIS_OPERAND_ENCODING_SIMM32_32_64, 113 | ZYDIS_OPERAND_ENCODING_SIMM16_32_32, 114 | ZYDIS_OPERAND_ENCODING_JIMM8, 115 | ZYDIS_OPERAND_ENCODING_JIMM16, 116 | ZYDIS_OPERAND_ENCODING_JIMM32, 117 | ZYDIS_OPERAND_ENCODING_JIMM64, 118 | ZYDIS_OPERAND_ENCODING_JIMM16_32_64, 119 | ZYDIS_OPERAND_ENCODING_JIMM32_32_64, 120 | ZYDIS_OPERAND_ENCODING_JIMM16_32_32, 121 | 122 | 123 | ZYDIS_OPERAND_ENCODING_MAX_VALUE = ZYDIS_OPERAND_ENCODING_JIMM16_32_32 124 | }; 125 | ]] 126 | 127 | ffi.cdef[[ 128 | typedef ZydisU8 ZydisOperandVisibility; 129 | 130 | 131 | enum ZydisOperandVisibilities 132 | { 133 | ZYDIS_OPERAND_VISIBILITY_INVALID, 134 | ZYDIS_OPERAND_VISIBILITY_EXPLICIT, 135 | ZYDIS_OPERAND_VISIBILITY_IMPLICIT, 136 | ZYDIS_OPERAND_VISIBILITY_HIDDEN, 137 | 138 | 139 | ZYDIS_OPERAND_VISIBILITY_MAX_VALUE = ZYDIS_OPERAND_VISIBILITY_HIDDEN 140 | }; 141 | ]] 142 | 143 | ffi.cdef[[ 144 | typedef ZydisU8 ZydisOperandAction; 145 | 146 | 147 | enum ZydisOperandActions 148 | { 149 | ZYDIS_OPERAND_ACTION_INVALID, 150 | ZYDIS_OPERAND_ACTION_READ, 151 | ZYDIS_OPERAND_ACTION_WRITE, 152 | ZYDIS_OPERAND_ACTION_READWRITE, 153 | ZYDIS_OPERAND_ACTION_CONDREAD, 154 | ZYDIS_OPERAND_ACTION_CONDWRITE, 155 | ZYDIS_OPERAND_ACTION_READ_CONDWRITE, 156 | ZYDIS_OPERAND_ACTION_CONDREAD_WRITE, 157 | 158 | /** 159 | * @brief Mask combining all writing access flags. 160 | */ 161 | ZYDIS_OPERAND_ACTION_MASK_WRITE = ZYDIS_OPERAND_ACTION_WRITE | 162 | ZYDIS_OPERAND_ACTION_READWRITE | ZYDIS_OPERAND_ACTION_CONDWRITE | 163 | ZYDIS_OPERAND_ACTION_READ_CONDWRITE | ZYDIS_OPERAND_ACTION_CONDREAD_WRITE, 164 | /** 165 | * @brief Mask combining all reading access flags. 166 | */ 167 | ZYDIS_OPERAND_ACTION_MASK_READ = ZYDIS_OPERAND_ACTION_READ | ZYDIS_OPERAND_ACTION_READWRITE | 168 | ZYDIS_OPERAND_ACTION_CONDREAD | ZYDIS_OPERAND_ACTION_READ_CONDWRITE | 169 | ZYDIS_OPERAND_ACTION_CONDREAD_WRITE, 170 | 171 | /** 172 | * @brief Maximum value of this enum. 173 | */ 174 | ZYDIS_OPERAND_ACTION_MAX_VALUE = ZYDIS_OPERAND_ACTION_CONDREAD_WRITE 175 | }; 176 | ]] 177 | 178 | ffi.cdef[[ 179 | typedef ZydisU8 ZydisInstructionEncoding; 180 | 181 | 182 | enum ZydisInstructionEncodings 183 | { 184 | ZYDIS_INSTRUCTION_ENCODING_INVALID, 185 | ZYDIS_INSTRUCTION_ENCODING_DEFAULT, 186 | ZYDIS_INSTRUCTION_ENCODING_3DNOW, 187 | ZYDIS_INSTRUCTION_ENCODING_XOP, 188 | ZYDIS_INSTRUCTION_ENCODING_VEX, 189 | ZYDIS_INSTRUCTION_ENCODING_EVEX, 190 | ZYDIS_INSTRUCTION_ENCODING_MVEX, 191 | 192 | 193 | ZYDIS_INSTRUCTION_ENCODING_MAX_VALUE = ZYDIS_INSTRUCTION_ENCODING_MVEX 194 | }; 195 | ]] 196 | 197 | ffi.cdef[[ 198 | typedef ZydisU8 ZydisOpcodeMap; 199 | 200 | enum ZydisOpcodeMaps 201 | { 202 | ZYDIS_OPCODE_MAP_DEFAULT, 203 | ZYDIS_OPCODE_MAP_0F, 204 | ZYDIS_OPCODE_MAP_0F38, 205 | ZYDIS_OPCODE_MAP_0F3A, 206 | ZYDIS_OPCODE_MAP_0F0F, 207 | ZYDIS_OPCODE_MAP_XOP8, 208 | ZYDIS_OPCODE_MAP_XOP9, 209 | ZYDIS_OPCODE_MAP_XOPA, 210 | 211 | ZYDIS_OPCODE_MAP_MAX_VALUE = ZYDIS_OPCODE_MAP_XOPA 212 | }; 213 | ]] 214 | 215 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Status.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | 5 | ffi.cdef[[ 6 | typedef ZydisU32 ZydisStatus; 7 | ]] 8 | 9 | local ZydisStatusCodes = { 10 | ZYDIS_STATUS_SUCCESS = 0x00000000, 11 | ZYDIS_STATUS_INVALID_PARAMETER = 1, 12 | ZYDIS_STATUS_INVALID_OPERATION = 2, 13 | ZYDIS_STATUS_INSUFFICIENT_BUFFER_SIZE = 3, 14 | 15 | -- Decoder 16 | ZYDIS_STATUS_NO_MORE_DATA = 4, 17 | ZYDIS_STATUS_DECODING_ERROR = 5, 18 | ZYDIS_STATUS_INSTRUCTION_TOO_LONG = 6, 19 | ZYDIS_STATUS_BAD_REGISTER = 7, 20 | ZYDIS_STATUS_ILLEGAL_LOCK = 8, 21 | ZYDIS_STATUS_ILLEGAL_LEGACY_PFX = 9, 22 | ZYDIS_STATUS_ILLEGAL_REX = 10, 23 | ZYDIS_STATUS_INVALID_MAP = 11, 24 | ZYDIS_STATUS_MALFORMED_EVEX = 12, 25 | ZYDIS_STATUS_MALFORMED_MVEX = 13, 26 | ZYDIS_STATUS_INVALID_MASK = 14, 27 | 28 | 29 | -- Formatter 30 | ZYDIS_STATUS_SKIP_OPERAND = 15, 31 | 32 | -- Encoder 33 | ZYDIS_STATUS_IMPOSSIBLE_INSTRUCTION = 16, 34 | 35 | -- Misc 36 | ZYDIS_STATUS_USER = 0x10000000 37 | }; 38 | -------------------------------------------------------------------------------- /lj2zydis/ffi/String.lua: -------------------------------------------------------------------------------- 1 | 2 | local ffi = require("ffi") 3 | 4 | 5 | require("lj2zydis.ffi.CommonTypes") 6 | require("lj2zydis.ffi.Status") 7 | --require("lj2zydis.LibC.h> 8 | 9 | 10 | ffi.cdef[[ 11 | 12 | typedef struct ZydisString_ 13 | { 14 | char* buffer; 15 | ZydisUSize length; 16 | ZydisUSize capacity; 17 | } ZydisString; 18 | ]] 19 | 20 | --#pragma pack(push, 1) 21 | 22 | ffi.cdef[[ 23 | typedef struct ZydisStaticString_ 24 | { 25 | const char* buffer; 26 | ZydisU8 length; 27 | } ZydisStaticString __attribute__((__packed__)); 28 | ]] 29 | --]]..(ffi.arch == "x64" and [[__attribute__((__packed__));]] or [[;]])) 30 | --#pragma pack(pop) 31 | 32 | ffi.cdef[[ 33 | 34 | typedef ZydisU8 ZydisLetterCase; 35 | 36 | 37 | enum ZydisLetterCases 38 | { 39 | ZYDIS_LETTER_CASE_DEFAULT, 40 | ZYDIS_LETTER_CASE_LOWER, 41 | ZYDIS_LETTER_CASE_UPPER, 42 | ZYDIS_LETTER_CASE_MAX_VALUE = ZYDIS_LETTER_CASE_UPPER 43 | }; 44 | ]] 45 | 46 | 47 | --[[ 48 | 49 | #define ZYDIS_MAKE_STRING(string) \ 50 | { (char*)string, sizeof(string) - 1, sizeof(string) - 1 } 51 | 52 | 53 | #define ZYDIS_MAKE_STATIC_STRING(string) \ 54 | { string, sizeof(string) - 1 } 55 | --]] 56 | 57 | ffi.cdef[[ 58 | ZydisStatus ZydisStringInit(ZydisString* string, char* text); 59 | ZydisStatus ZydisStringFinalize(ZydisString* string); 60 | ZydisStatus ZydisStringAppend(ZydisString* string, const ZydisString* text); 61 | ZydisStatus ZydisStringAppendEx(ZydisString* string, const ZydisString* text,ZydisLetterCase letterCase); 62 | 63 | ZydisStatus ZydisStringAppendC(ZydisString* string, const char* text); 64 | 65 | ZydisStatus ZydisStringAppendExC(ZydisString* string, const char* text, 66 | ZydisLetterCase letterCase); 67 | 68 | ZydisStatus ZydisStringAppendStatic(ZydisString* string, 69 | const ZydisStaticString* text, ZydisLetterCase letterCase); 70 | 71 | ZydisStatus ZydisStringAppendExStatic(ZydisString* string, 72 | const ZydisStaticString* text, ZydisLetterCase letterCase); 73 | 74 | ZydisStatus ZydisStringAppendDecU(ZydisString* string, ZydisU64 value, 75 | ZydisU8 paddingLength); 76 | 77 | ZydisStatus ZydisStringAppendDecS(ZydisString* string, ZydisI64 value, 78 | ZydisU8 paddingLength); 79 | 80 | ZydisStatus ZydisStringAppendHexU(ZydisString* string, ZydisU64 value, 81 | ZydisU8 paddingLength, ZydisBool uppercase, const ZydisString* prefix, 82 | const ZydisString* suffix); 83 | 84 | ZydisStatus ZydisStringAppendHexS(ZydisString* string, ZydisI64 value, 85 | ZydisU8 paddingLength, ZydisBool uppercase, const ZydisString* prefix, 86 | const ZydisString* suffix); 87 | ]] 88 | 89 | -------------------------------------------------------------------------------- /lj2zydis/ffi/Utils.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.Status") 4 | require("lj2zydis.ffi.DecoderTypes") 5 | 6 | ffi.cdef[[ 7 | 8 | ZydisStatus ZydisCalcAbsoluteAddress(const ZydisDecodedInstruction* instruction, 9 | const ZydisDecodedOperand* operand, ZydisU64* address); 10 | 11 | ZydisStatus ZydisGetAccessedFlagsByAction(const ZydisDecodedInstruction* instruction, 12 | ZydisCPUFlagAction action, ZydisCPUFlagMask* flags); 13 | ]] 14 | 15 | -------------------------------------------------------------------------------- /lj2zydis/namespace.lua: -------------------------------------------------------------------------------- 1 | local function namespace(res) 2 | res = res or {} 3 | setmetatable(res, {__index= _G}) 4 | setfenv(2, res) 5 | return res 6 | end 7 | 8 | return namespace 9 | -------------------------------------------------------------------------------- /lj2zydis/zydis.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | require("lj2zydis.ffi.CommonTypes") 4 | require("lj2zydis.ffi.Decoder") 5 | require("lj2zydis.ffi.DecoderTypes") 6 | require("lj2zydis.ffi.Formatter") 7 | require("lj2zydis.ffi.MetaInfo") 8 | require("lj2zydis.ffi.Mnemonic") 9 | require("lj2zydis.ffi.Register") 10 | require("lj2zydis.ffi.SharedTypes") 11 | require("lj2zydis.ffi.Status") 12 | require("lj2zydis.ffi.String") 13 | require("lj2zydis.ffi.Utils") 14 | 15 | 16 | ffi.cdef[[ 17 | typedef ZydisU8 ZydisFeature; 18 | 19 | enum ZydisFeatures 20 | { 21 | ZYDIS_FEATURE_EVEX, 22 | ZYDIS_FEATURE_MVEX, 23 | }; 24 | ]] 25 | 26 | 27 | 28 | ffi.cdef[[ 29 | ZydisBool ZydisIsFeatureEnabled(ZydisFeature feature); 30 | ZydisU64 ZydisGetVersion(void); 31 | ]] 32 | 33 | 34 | local ZydisLib = ffi.load("zydis"); 35 | 36 | 37 | 38 | 39 | 40 | 41 | local exports = { 42 | Lib = ZydisLib; 43 | 44 | ZYDIS_VERSION = 0x0002000000020000ULL; 45 | 46 | ZydisGetVersion = ZydisLib.ZydisGetVersion; 47 | 48 | -- Decoder 49 | ZydisDecoder = ffi.typeof("ZydisDecoder"); 50 | ZydisDecoderInit = ZydisLib.ZydisDecoderInit; 51 | ZydisDecoderEnableMode = ZydisLib.ZydisDecoderEnableMode; 52 | ZydisDecoderDecodeBuffer = ZydisLib.ZydisDecoderDecodeBuffer; 53 | 54 | -- Formatter 55 | ZydisFormatter = ffi.typeof("ZydisFormatter"); 56 | ZydisFormatterInit = ZydisLib.ZydisFormatterInit; 57 | ZydisFormatterSetProperty = ZydisLib.ZydisFormatterSetProperty; 58 | ZydisFormatterSetHook = ZydisLib.ZydisFormatterSetHook; 59 | ZydisFormatterFormatInstruction = ZydisLib.ZydisFormatterFormatInstruction; 60 | ZydisFormatterFormatInstructionEx = ZydisLib.ZydisFormatterFormatInstructionEx; 61 | ZydisFormatterFormatOperand = ZydisLib.ZydisFormatterFormatOperand; 62 | ZydisFormatterFormatOperandEx = ZydisLib.ZydisFormatterFormatOperandEx; 63 | } 64 | 65 | return exports -------------------------------------------------------------------------------- /testy/DOSExample.lua: -------------------------------------------------------------------------------- 1 | package.path = "../?.lua;"..package.path 2 | 3 | local ffi = require("ffi") 4 | local bit = require("bit") 5 | 6 | local zydis = require("lj2zydis.zydis") 7 | 8 | local sizeOfCode = 64; 9 | local data = ffi.new("uint8_t[64]", 10 | { 11 | 0x0E,0x1F,0xBA,0x0E,0x00,0xB4,0x09,0xCD,0x21,0xB8,0x01,0x4C,0xCD,0x21,0x54,0x68, 12 | 0x69,0x73,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,0x63,0x61,0x6E,0x6E,0x6F, 13 | 0x74,0x20,0x62,0x65,0x20,0x72,0x75,0x6E,0x20,0x69,0x6E,0x20,0x44,0x4F,0x53,0x20, 14 | 0x6D,0x6F,0x64,0x65,0x2E,0x0D,0x0D,0x0A,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 15 | }); 16 | 17 | 18 | 19 | local function main() 20 | 21 | local decoder = ffi.new("ZydisDecoder"); 22 | -- in order to decode the DOS stub at the beginning of a PE 23 | -- formatted file, ZYDIS_ADDRESS_WIDTH_16 must be used 24 | local err = zydis.ZydisDecoderInit(decoder, ffi.C.ZYDIS_MACHINE_MODE_LEGACY_32, ffi.C.ZYDIS_ADDRESS_WIDTH_16) 25 | 26 | 27 | local formatter = ffi.new("ZydisFormatter"); 28 | local err = zydis.ZydisFormatterInit(formatter, ffi.C.ZYDIS_FORMATTER_STYLE_INTEL) 29 | 30 | local offset = 0 31 | local length = sizeOfCode; 32 | local instructionPointer = 0x0000000000000000ULL; 33 | local instruction = ffi.new("ZydisDecodedInstruction"); 34 | local buffer = ffi.new("uint8_t[256]"); 35 | 36 | while (zydis.ZydisDecoderDecodeBuffer( 37 | decoder, data + offset, length - offset, 38 | instructionPointer, instruction) == 0) do 39 | 40 | -- Print current instruction pointer. 41 | io.write(string.format("0x%s ", bit.tohex(instructionPointer))); 42 | 43 | -- Format & print the binary instruction 44 | -- structure to human readable format. 45 | zydis.ZydisFormatterFormatInstruction(formatter, instruction, buffer, 256); 46 | print(ffi.string(buffer)); 47 | 48 | offset = offset+instruction.length; 49 | instructionPointer = instructionPointer + instruction.length; 50 | end 51 | 52 | print("DONE") 53 | return true; 54 | end 55 | 56 | main() 57 | -------------------------------------------------------------------------------- /testy/README.md: -------------------------------------------------------------------------------- 1 | DOSExample.lua - Disassemble a typical DOS stub that is found at the beginning of every .dll and .exe file on Windows. 2 | 3 | WebExample.lua - Disassemble the code that is found on the web site of the Zydis project https://github.com/zyantific/zydis 4 | 5 | test_ZydisDecoder.lua - Shows using the 'classes' ZydisDecoder and ZydisFormatter 6 | -------------------------------------------------------------------------------- /testy/WebExample.lua: -------------------------------------------------------------------------------- 1 | package.path = "../?.lua;"..package.path 2 | 3 | local ffi = require("ffi") 4 | local bit = require("bit") 5 | 6 | local zydis = require("lj2zydis.zydis") 7 | 8 | local sizeOfCode = 25; 9 | local data = ffi.new("uint8_t[25]", 10 | { 11 | 0x51, 0x8D, 0x45, 0xFF, 0x50, 0xFF, 0x75, 0x0C, 0xFF, 0x75, 12 | 0x08, 0xFF, 0x15, 0xA0, 0xA5, 0x48, 0x76, 0x85, 0xC0, 0x0F, 13 | 0x88, 0xFC, 0xDA, 0x02, 0x00 14 | }); 15 | 16 | --[[ 17 | 007FFFFFFF400000 push rcx 18 | 007FFFFFFF400001 lea eax, [rbp-0x01] 19 | 007FFFFFFF400004 push rax 20 | 007FFFFFFF400005 push qword ptr [rbp+0x0C] 21 | 007FFFFFFF400008 push qword ptr [rbp+0x08] 22 | 007FFFFFFF40000B call [0x008000007588A5B1] 23 | 007FFFFFFF400011 test eax, eax 24 | 007FFFFFFF400013 js 0x007FFFFFFF42DB15 25 | ]] 26 | 27 | 28 | local function main() 29 | 30 | local decoder = zydis.ZydisDecoder(ffi.C.ZYDIS_MACHINE_MODE_LONG_64, ffi.C.ZYDIS_ADDRESS_WIDTH_64); -- ffi.new("ZydisDecoder"); 31 | local formatter = zydis.ZydisFormatter(); 32 | 33 | local offset = 0 34 | local length = sizeOfCode; 35 | local instructionPointer = 0x007FFFFFFF400000ULL; 36 | local instruction = ffi.new("ZydisDecodedInstruction"); 37 | local buffer = ffi.new("uint8_t[256]"); 38 | 39 | while (decoder:DecodeBuffer(data + offset, length - offset,instructionPointer, instruction)) do 40 | -- Print current instruction pointer. 41 | io.write(string.format("0x%s ", bit.tohex(instructionPointer))); 42 | 43 | -- Format & print the binary instruction 44 | -- structure to human readable format. 45 | formatter:FormatInstruction(instruction, buffer, 256); 46 | print(ffi.string(buffer)); 47 | 48 | offset = offset+instruction.length; 49 | instructionPointer = instructionPointer + instruction.length; 50 | end 51 | 52 | return true; 53 | end 54 | 55 | main() 56 | -------------------------------------------------------------------------------- /testy/ZydisEnums.lua: -------------------------------------------------------------------------------- 1 | return { 2 | operandTypes = 3 | { 4 | [0] = "UNUSED", 5 | "REGISTER", 6 | "MEMORY", 7 | "POINTER", 8 | "IMMEDIATE" 9 | }; 10 | 11 | operandVisibilities = 12 | { 13 | [0] = "INVALID", 14 | "EXPLICIT", 15 | "IMPLICIT", 16 | "HIDDEN" 17 | }; 18 | 19 | operandActions = 20 | { 21 | [0] = "INV", 22 | "R", 23 | "W", 24 | "RW", 25 | "CR", 26 | "CW", 27 | "RCW", 28 | "CRW" 29 | }; 30 | 31 | elementTypes = 32 | { 33 | [0] = "INVALID", 34 | "STRUCT", 35 | "UINT", 36 | "INT", 37 | "FLOAT16", 38 | "FLOAT32", 39 | "FLOAT64", 40 | "FLOAT80", 41 | "LONGBCD" 42 | }; 43 | 44 | operandEncodings = 45 | { 46 | [0] = "NONE", 47 | "MODRM_REG", 48 | "MODRM_RM", 49 | "OPCODE", 50 | "NDSNDD", 51 | "IS4", 52 | "MASK", 53 | "DISP8", 54 | "DISP16", 55 | "DISP32", 56 | "DISP64", 57 | "DISP16_32_64", 58 | "DISP32_32_64", 59 | "DISP16_32_32", 60 | "UIMM8", 61 | "UIMM16", 62 | "UIMM32", 63 | "UIMM64", 64 | "UIMM16_32_64", 65 | "UIMM32_32_64", 66 | "UIMM16_32_32", 67 | "SIMM8", 68 | "SIMM16", 69 | "SIMM32", 70 | "SIMM64", 71 | "SIMM16_32_64", 72 | "SIMM32_32_64", 73 | "SIMM16_32_32", 74 | "JIMM8", 75 | "JIMM16", 76 | "JIMM32", 77 | "JIMM64", 78 | "JIMM16_32_64", 79 | "JIMM32_32_64", 80 | "JIMM16_32_32" 81 | }; 82 | 83 | memopTypes = 84 | { 85 | [0] = "INVALID", 86 | "MEM", 87 | "AGEN", 88 | "MIB" 89 | }; 90 | 91 | StatusStrings = 92 | { 93 | [0] = "SUCCESS", 94 | "INVALID_PARAMETER", 95 | "INVALID_OPERATION", 96 | "INSUFFICIENT_BUFFER_SIZE", 97 | "NO_MORE_DATA", 98 | "DECODING_ERROR", 99 | "INSTRUCTION_TOO_LONG", 100 | "BAD_REGISTER", 101 | "ILLEGAL_LOCK", 102 | "ILLEGAL_LEGACY_PFX", 103 | "ILLEGAL_REX", 104 | "INVALID_MAP", 105 | "MALFORMED_EVEX", 106 | "MALFORMED_MVEX", 107 | "INVALID_MASK", 108 | "IMPOSSIBLE_INSTRUCTION", 109 | "INSUFFICIENT_BUFFER_SIZE" 110 | }; 111 | 112 | flagNames = 113 | { 114 | [0] = "CF", 115 | "PF", 116 | "AF", 117 | "ZF", 118 | "SF", 119 | "TF", 120 | "IF", 121 | "DF", 122 | "OF", 123 | "IOPL", 124 | "NT", 125 | "RF", 126 | "VM", 127 | "AC", 128 | "VIF", 129 | "VIP", 130 | "ID", 131 | "C0", 132 | "C1", 133 | "C2", 134 | "C3" 135 | }; 136 | 137 | flagActions = 138 | { 139 | [0] = " ", 140 | "T ", 141 | "T_M", 142 | "M ", 143 | "0 ", 144 | "1 ", 145 | "U " 146 | }; 147 | 148 | broadcastStrings = 149 | { 150 | [0] = "NONE", 151 | "1_TO_2", 152 | "1_TO_4", 153 | "1_TO_8", 154 | "1_TO_16", 155 | "1_TO_32", 156 | "1_TO_64", 157 | "2_TO_4", 158 | "2_TO_8", 159 | "2_TO_16", 160 | "4_TO_8", 161 | "4_TO_16", 162 | "8_TO_16" 163 | }; 164 | 165 | maskModeStrings = 166 | { 167 | [0] = "NONE", 168 | "MERGE", 169 | "ZERO" 170 | }; 171 | 172 | roundingModeStrings = 173 | { 174 | [0] = "DEFAULT", 175 | "RN", 176 | "RD", 177 | "RU", 178 | "RZ" 179 | }; 180 | 181 | swizzleModeStrings = 182 | { 183 | [0] = "NONE", 184 | "DCBA", 185 | "CDAB", 186 | "BADC", 187 | "DACB", 188 | "AAAA", 189 | "BBBB", 190 | "CCCC", 191 | "DDDD" 192 | }; 193 | 194 | conversionModeStrings = 195 | { 196 | [0] = "NONE", 197 | "FLOAT16", 198 | "SINT8", 199 | "UINT8", 200 | "SINT16", 201 | "UINT16" 202 | }; 203 | 204 | opcodeMapStrings = 205 | { 206 | [0] = "DEFAULT", 207 | "0F", 208 | "0F38", 209 | "0F3A", 210 | "0F0F", 211 | "XOP8", 212 | "XOP9", 213 | "XOPA" 214 | }; 215 | 216 | instructionEncodingStrings = 217 | { 218 | [0] = "", 219 | "DEFAULT", 220 | "3DNOW", 221 | "XOP", 222 | "VEX", 223 | "EVEX", 224 | "MVEX" 225 | }; 226 | 227 | exceptionClassStrings = 228 | { 229 | [0] = "NONE", 230 | "SSE1", 231 | "SSE2", 232 | "SSE3", 233 | "SSE4", 234 | "SSE5", 235 | "SSE7", 236 | "AVX1", 237 | "AVX2", 238 | "AVX3", 239 | "AVX4", 240 | "AVX5", 241 | "AVX6", 242 | "AVX7", 243 | "AVX8", 244 | "AVX11", 245 | "AVX12", 246 | "E1", 247 | "E1NF", 248 | "E2", 249 | "E2NF", 250 | "E3", 251 | "E3NF", 252 | "E4", 253 | "E4NF", 254 | "E5", 255 | "E5NF", 256 | "E6", 257 | "E6NF", 258 | "E7NM", 259 | "E7NM128", 260 | "E9NF", 261 | "E10", 262 | "E10NF", 263 | "E11", 264 | "E11NF", 265 | "E12", 266 | "E12NP", 267 | "K20", 268 | "K21" 269 | }; 270 | 271 | } 272 | -------------------------------------------------------------------------------- /testy/ZydisInfo.lua: -------------------------------------------------------------------------------- 1 | 2 | --[[ 3 | @file 4 | @brief Disassembles a given hex-buffer and prints detailed information about the decoded 5 | instruction, the operands and additional attributes. 6 | --]] 7 | 8 | package.path = "../?.lua;"..package.path 9 | 10 | local ffi = require("ffi") 11 | local bit = require("bit") 12 | 13 | local namespace = require("lj2zydis.namespace")() 14 | 15 | local zydis = require("lj2zydis.zydis") 16 | local ZydisEnum = require("ZydisEnum") 17 | 18 | enum.inject(zydis, namespace) 19 | enum.inject(ZydisEnums, namespace) 20 | 21 | 22 | 23 | --[[ 24 | /* ============================================================================================== */ 25 | /* Helper functions */ 26 | /* ============================================================================================== */ 27 | --]] 28 | 29 | local function ZydisFormatStatus(status) 30 | return StatusStrings[status]; 31 | end 32 | 33 | --[[ 34 | Print functions 35 | --]] 36 | local function fputs(str, outplace) 37 | io.write(str); 38 | return true; 39 | end 40 | 41 | local function printf(fmt, ...) 42 | io.write(string.format(fmt,...)) 43 | return true; 44 | end 45 | 46 | local function printOperands(instruction) 47 | 48 | fputs("== [ OPERANDS ] =====================================================", stdout); 49 | fputs("=======================================\n", stdout); 50 | fputs("## TYPE VISIBILITY ACTION ENCODING SIZE NELEM ELEMSZ", stdout); 51 | fputs(" ELEMTYPE VALUE\n", stdout); 52 | fputs("-- --------- ---------- ------ ------------ ---- ----- ------", stdout); 53 | fputs(" -------- ---------------------------\n", stdout); 54 | local immId = 0; 55 | local i = 0; 56 | while (i < instruction.operandCount) do 57 | 58 | 59 | printf("%2d %9s %10s %6s %12s %5d %4d %6d %8s", 60 | i, 61 | operandTypes[instruction.operands[i].type], 62 | operandVisibilities[instruction.operands[i].visibility], 63 | operandActions[instruction.operands[i].action], 64 | operandEncodings[instruction.operands[i].encoding], 65 | instruction.operands[i].size, 66 | instruction.operands[i].elementCount, 67 | instruction.operands[i].elementSize, 68 | elementTypes[instruction.operands[i].elementType]); 69 | --[[ 70 | local kind = instruction.operands[i].type 71 | if kind == ZYDIS_OPERAND_TYPE_REGISTER then 72 | printf(" %27s", ZydisRegisterGetString(instruction.operands[i].reg.value)); 73 | elseif kind == ZYDIS_OPERAND_TYPE_MEMORY then 74 | printf(" TYPE =%20s\n", memopTypes[instruction.operands[i].mem.type]); 75 | printf(" %84s =%20s\n", 76 | "SEG ", ZydisRegisterGetString(instruction.operands[i].mem.segment)); 77 | printf(" %84s =%20s\n", 78 | "BASE ", ZydisRegisterGetString(instruction.operands[i].mem.base)); 79 | printf(" %84s =%20s\n", 80 | "INDEX", ZydisRegisterGetString(instruction.operands[i].mem.index)); 81 | printf(" %84s =%20d\n", "SCALE", instruction.operands[i].mem.scale); 82 | printf(" %84s = 0x%016"PRIX64, 83 | "DISP ", instruction.operands[i].mem.disp.value); 84 | 85 | elseif kind == ZYDIS_OPERAND_TYPE_POINTER then 86 | -- do nothing break; 87 | elseif kind == ZYDIS_OPERAND_TYPE_IMMEDIATE then 88 | if (instruction.operands[i].imm.isSigned ~= 0) then 89 | 90 | printf(" (%s %s %2d) 0x%016", 91 | instruction.operands[i].imm.isSigned ? "S" : "U", 92 | instruction.operands[i].imm.isRelative ? "R" : "_", 93 | instruction.raw.imm[immId].size, 94 | instruction.operands[i].imm.value.s); 95 | else 96 | printf(" SIGN =%20s\n", instruction.operands[i].imm.isSigned ? "Y" : "N"); 97 | printf(" %84s =%20s\n", 98 | "REL ", instruction.operands[i].imm.isRelative ? "Y" : "N"); 99 | printf(" %84s = %2d\n", 100 | "SIZE ", instruction.raw.imm[immId].size); 101 | printf(" %84s = 0x%016", 102 | "VALUE", instruction.operands[i].imm.value.u); 103 | end 104 | immId = immId + 1; 105 | 106 | else 107 | -- ZYDIS_UNREACHABLE; 108 | end 109 | --]] 110 | puts(""); 111 | i = i+1; 112 | end 113 | 114 | fputs("-- --------- ---------- ------ ------------ ---- ----- ------", stdout); 115 | fputs(" -------- ---------------------------\n", stdout); 116 | end 117 | 118 | 119 | local function printFlags(instruction) 120 | 121 | 122 | 123 | fputs("== [ FLAGS ] =====================================================", stdout); 124 | fputs("=======================================\n", stdout); 125 | printf(" ACTIONS: "); 126 | local c = 0; 127 | 128 | 129 | for (ZydisCPUFlag i = 0; i < ZYDIS_ARRAY_SIZE(instruction.accessedFlags); ++i) 130 | { 131 | if (instruction.accessedFlags[i].action != ZYDIS_CPUFLAG_ACTION_NONE) 132 | { 133 | if (c && (c % 8 == 0)) 134 | { 135 | printf("\n "); 136 | } 137 | ++c; 138 | printf("[%-4s: %s] ", flagNames[i], flagActions[instruction.accessedFlags[i].action]); 139 | } 140 | } 141 | if c > 0 then 142 | puts("") 143 | else 144 | puts("none") 145 | end 146 | 147 | 148 | ZydisCPUFlagMask flags, temp; 149 | ZydisGetAccessedFlagsByAction(instruction, ZYDIS_CPUFLAG_ACTION_TESTED, &flags); 150 | printf(" READ: 0x%08" PRIX32 "\n", flags); 151 | ZydisGetAccessedFlagsByAction(instruction, ZYDIS_CPUFLAG_ACTION_MODIFIED, &flags); 152 | ZydisGetAccessedFlagsByAction(instruction, ZYDIS_CPUFLAG_ACTION_SET_0, &temp); 153 | flags |= temp; 154 | ZydisGetAccessedFlagsByAction(instruction, ZYDIS_CPUFLAG_ACTION_SET_1, &temp); 155 | flags |= temp; 156 | printf(" WRITTEN: 0x%08" PRIX32 "\n", flags); 157 | ZydisGetAccessedFlagsByAction(instruction, ZYDIS_CPUFLAG_ACTION_UNDEFINED, &flags); 158 | printf(" UNDEFINED: 0x%08" PRIX32 "\n", flags); 159 | end 160 | 161 | --[=[ 162 | local function printAVXInfo(instruction) 163 | 164 | 165 | 166 | fputs("== [ AVX ] =====================================================", stdout); 167 | fputs("=======================================\n", stdout); 168 | 169 | printf(" VECTORLEN: %03d\n", instruction.avx.vectorLength); 170 | printf(" BROADCAST: %s%s", broadcastStrings[instruction.avx.broadcast.mode], 171 | instruction.avx.broadcast.isStatic ? " (static)" : ""); 172 | 173 | switch (instruction.encoding) 174 | { 175 | case ZYDIS_INSTRUCTION_ENCODING_EVEX: 176 | printf("\n ROUNDING: %s", roundingModeStrings[instruction.avx.rounding.mode]); 177 | printf("\n SAE: %s", instruction.avx.hasSAE ? "Y" : "N"); 178 | printf("\n MASK: %s [%5s]%s", ZydisRegisterGetString(instruction.avx.mask.reg), 179 | maskModeStrings[instruction.avx.mask.mode], 180 | instruction.avx.mask.isControlMask ? " (control-mask)" : ""); 181 | break; 182 | case ZYDIS_INSTRUCTION_ENCODING_MVEX: 183 | printf("\n ROUNDING: %s", roundingModeStrings[instruction.avx.rounding.mode]); 184 | printf("\n SAE: %s", instruction.avx.hasSAE ? "Y" : "N"); 185 | printf("\n MASK: %s [MERGE]", ZydisRegisterGetString(instruction.avx.mask.reg)); 186 | printf("\n EH: %s", instruction.avx.hasEvictionHint ? "Y" : "N"); 187 | printf("\n SWIZZLE: %s", swizzleModeStrings[instruction.avx.swizzle.mode]); 188 | printf("\n CONVERT: %s", conversionModeStrings[instruction.avx.conversion.mode]); 189 | break; 190 | default: 191 | break; 192 | } 193 | puts(""); 194 | } 195 | --]=] 196 | 197 | local function printInstruction(instruction) 198 | 199 | 200 | local attributeMap = 201 | { 202 | [0] = { ZYDIS_ATTRIB_HAS_MODRM, "HAS_MODRM" }, 203 | { ZYDIS_ATTRIB_HAS_SIB, "HAS_SIB" }, 204 | { ZYDIS_ATTRIB_HAS_REX, "HAS_REX" }, 205 | { ZYDIS_ATTRIB_HAS_XOP, "HAS_XOP" }, 206 | { ZYDIS_ATTRIB_HAS_VEX, "HAS_VEX" }, 207 | { ZYDIS_ATTRIB_HAS_EVEX, "HAS_EVEX" }, 208 | { ZYDIS_ATTRIB_HAS_MVEX, "HAS_MVEX" }, 209 | { ZYDIS_ATTRIB_IS_RELATIVE, "IS_RELATIVE" }, 210 | { ZYDIS_ATTRIB_IS_PRIVILEGED, "IS_PRIVILEGED" }, 211 | { ZYDIS_ATTRIB_IS_FAR_BRANCH, "IS_FAR_BRANCH" }, 212 | { ZYDIS_ATTRIB_ACCEPTS_LOCK, "ACCEPTS_LOCK" }, 213 | { ZYDIS_ATTRIB_ACCEPTS_REP, "ACCEPTS_REP" }, 214 | { ZYDIS_ATTRIB_ACCEPTS_REPE, "ACCEPTS_REPE" }, 215 | { ZYDIS_ATTRIB_ACCEPTS_REPZ, "ACCEPTS_REPZ" }, 216 | { ZYDIS_ATTRIB_ACCEPTS_REPNE, "ACCEPTS_REPNE" }, 217 | { ZYDIS_ATTRIB_ACCEPTS_REPNZ, "ACCEPTS_REPNZ" }, 218 | { ZYDIS_ATTRIB_ACCEPTS_BOUND, "ACCEPTS_BOUND" }, 219 | { ZYDIS_ATTRIB_ACCEPTS_XACQUIRE, "ACCEPTS_XACQUIRE" }, 220 | { ZYDIS_ATTRIB_ACCEPTS_XRELEASE, "ACCEPTS_XRELEASE" }, 221 | { ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK, "ACCEPTS_HLE_WITHOUT_LOCK" }, 222 | { ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS, "ACCEPTS_BRANCH_HINTS" }, 223 | { ZYDIS_ATTRIB_ACCEPTS_SEGMENT, "ACCEPTS_SEGMENT" }, 224 | { ZYDIS_ATTRIB_HAS_LOCK, "HAS_LOCK" }, 225 | { ZYDIS_ATTRIB_HAS_REP, "HAS_REP" }, 226 | { ZYDIS_ATTRIB_HAS_REPE, "HAS_REPE" }, 227 | { ZYDIS_ATTRIB_HAS_REPZ, "HAS_REPZ" }, 228 | { ZYDIS_ATTRIB_HAS_REPNE, "HAS_REPNE" }, 229 | { ZYDIS_ATTRIB_HAS_REPNZ, "HAS_REPNZ" }, 230 | { ZYDIS_ATTRIB_HAS_BOUND, "HAS_BOUND" }, 231 | { ZYDIS_ATTRIB_HAS_XACQUIRE, "HAS_XACQUIRE" }, 232 | { ZYDIS_ATTRIB_HAS_XRELEASE, "HAS_XRELEASE" }, 233 | { ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN, "HAS_BRANCH_NOT_TAKEN" }, 234 | { ZYDIS_ATTRIB_HAS_BRANCH_TAKEN, "HAS_BRANCH_TAKEN" }, 235 | { ZYDIS_ATTRIB_HAS_SEGMENT, "HAS_SEGMENT" }, 236 | { ZYDIS_ATTRIB_HAS_SEGMENT_CS, "HAS_SEGMENT_CS" }, 237 | { ZYDIS_ATTRIB_HAS_SEGMENT_SS, "HAS_SEGMENT_SS" }, 238 | { ZYDIS_ATTRIB_HAS_SEGMENT_DS, "HAS_SEGMENT_DS" }, 239 | { ZYDIS_ATTRIB_HAS_SEGMENT_ES, "HAS_SEGMENT_ES" }, 240 | { ZYDIS_ATTRIB_HAS_SEGMENT_FS, "HAS_SEGMENT_FS" }, 241 | { ZYDIS_ATTRIB_HAS_SEGMENT_GS, "HAS_SEGMENT_GS" }, 242 | { ZYDIS_ATTRIB_HAS_OPERANDSIZE, "HAS_OPERANDSIZE" }, 243 | { ZYDIS_ATTRIB_HAS_ADDRESSSIZE, "HAS_ADDRESSSIZE" } 244 | }; 245 | 246 | fputs("== [ BASIC ] =====================================================", stdout); 247 | fputs("=======================================\n", stdout); 248 | printf(" MNEMONIC: %s [ENC: %s, MAP: %s, OPC: %02X]\n", 249 | ZydisMnemonicGetString(instruction.mnemonic), 250 | instructionEncodingStrings[instruction.encoding], 251 | opcodeMapStrings[instruction.opcodeMap], 252 | instruction.opcode); 253 | printf(" LENGTH: %2d\n", instruction.length); 254 | printf(" SSZ: %2d\n", instruction.stackWidth); 255 | printf(" EOSZ: %2d\n", instruction.operandWidth); 256 | printf(" EASZ: %2d\n", instruction.addressWidth); 257 | printf(" CATEGORY: %s\n", ZydisCategoryGetString(instruction.meta.category)); 258 | printf(" ISA-SET: %s\n", ZydisISASetGetString(instruction.meta.isaSet)); 259 | printf(" ISA-EXT: %s\n", ZydisISAExtGetString(instruction.meta.isaExt)); 260 | printf(" EXCEPTIONS: %s\n", exceptionClassStrings[instruction.meta.exceptionClass]); 261 | 262 | if (instruction.attributes) 263 | { 264 | fputs (" ATTRIBUTES: ", stdout); 265 | for (size_t i = 0; i < ZYDIS_ARRAY_SIZE(attributeMap); ++i) 266 | { 267 | if (instruction.attributes & attributeMap[i].attrMask) 268 | { 269 | printf("%s ", attributeMap[i].str); 270 | } 271 | } 272 | fputs("\n", stdout); 273 | } 274 | 275 | if (instruction.operandCount > 0) 276 | { 277 | puts(""); 278 | printOperands(instruction); 279 | } 280 | 281 | if (ZydisRegisterGetClass( 282 | instruction.operands[instruction.operandCount - 1].reg.value) == ZYDIS_REGCLASS_FLAGS) 283 | { 284 | puts(""); 285 | printFlags(instruction); 286 | } 287 | 288 | if ((instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_XOP) || 289 | (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_VEX) || 290 | (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) || 291 | (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX)) 292 | { 293 | puts(""); 294 | printAVXInfo(instruction); 295 | } 296 | 297 | ZydisStatus status; 298 | ZydisFormatter formatter; 299 | if (!ZYDIS_SUCCESS((status = ZydisFormatterInit(&formatter, ZYDIS_FORMATTER_STYLE_INTEL))) || 300 | !ZYDIS_SUCCESS((status = ZydisFormatterSetProperty(&formatter, 301 | ZYDIS_FORMATTER_PROP_FORCE_MEMSEG, ZYDIS_TRUE))) || 302 | !ZYDIS_SUCCESS((status = ZydisFormatterSetProperty(&formatter, 303 | ZYDIS_FORMATTER_PROP_FORCE_MEMSIZE, ZYDIS_TRUE)))) 304 | { 305 | fputs("Failed to initialize instruction-formatter\n", stderr); 306 | exit(status); 307 | } 308 | char buffer[256]; 309 | ZydisFormatterFormatInstruction(&formatter, instruction, &buffer[0], sizeof(buffer)); 310 | fputs("\n== [ DISASM ] =====================================================", stdout); 311 | fputs("=======================================\n", stdout); 312 | printf(" %s\n", &buffer[0]); 313 | } 314 | 315 | 316 | --[[ 317 | /* ============================================================================================== */ 318 | /* Entry point */ 319 | /* ============================================================================================== */ 320 | --]] 321 | local argv = {...} 322 | local argc = select('#', ...) 323 | local function main() 324 | print(argc, argv, argv[1]) 325 | 326 | if (ZydisGetVersion() ~= ZYDIS_VERSION) then 327 | 328 | fputs("Invalid zydis version\n", stderr); 329 | return ZYDIS_STATUS_INVALID_OPERATION; 330 | end 331 | 332 | if argc < 2 then 333 | 334 | fputs("Usage: ZydisInfo -[real|16|32|64] [hexbytes]\n", stderr); 335 | return ZYDIS_STATUS_INVALID_PARAMETER; 336 | end 337 | --[=[ 338 | ZydisDecoder decoder; 339 | if (!strcmp(argv[1], "-real")) 340 | { 341 | ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_REAL_16, ZYDIS_ADDRESS_WIDTH_16); 342 | } else 343 | if (!strcmp(argv[1], "-16")) 344 | { 345 | ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_COMPAT_16, ZYDIS_ADDRESS_WIDTH_16); 346 | } else 347 | if (!strcmp(argv[1], "-32")) 348 | { 349 | ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_COMPAT_32, ZYDIS_ADDRESS_WIDTH_32); 350 | } else 351 | if (!strcmp(argv[1], "-64")) 352 | { 353 | ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_ADDRESS_WIDTH_64); 354 | } else 355 | { 356 | fputs("Usage: ZydisInfo -[real|16|32|64] [hexbytes]\n", stderr); 357 | return ZYDIS_STATUS_INVALID_PARAMETER; 358 | } 359 | 360 | uint8_t data[ZYDIS_MAX_INSTRUCTION_LENGTH]; 361 | uint8_t length = 0; 362 | for (uint8_t i = 0; i < argc - 2; ++i) 363 | { 364 | if (length == ZYDIS_MAX_INSTRUCTION_LENGTH) 365 | { 366 | fprintf(stderr, "Maximum number of %d bytes exceeded", ZYDIS_MAX_INSTRUCTION_LENGTH); 367 | return ZYDIS_STATUS_INVALID_PARAMETER; 368 | } 369 | const size_t len = strlen(argv[i + 2]); 370 | if (len % 2) 371 | { 372 | fputs("Even number of hex nibbles expected", stderr); 373 | return ZYDIS_STATUS_INVALID_PARAMETER; 374 | } 375 | for (uint8_t j = 0; j < len / 2; ++j) 376 | { 377 | unsigned value; 378 | if (!sscanf(&argv[i + 2][j * 2], "%02x", &value)) 379 | { 380 | fputs("Invalid hex value", stderr); 381 | return ZYDIS_STATUS_INVALID_PARAMETER; 382 | } 383 | data[length] = (uint8_t)value; 384 | ++length; 385 | } 386 | } 387 | 388 | ZydisDecodedInstruction instruction; 389 | const ZydisStatus status = ZydisDecoderDecodeBuffer(&decoder, &data, length, 0, &instruction); 390 | if (!ZYDIS_SUCCESS(status)) 391 | { 392 | if (status >= ZYDIS_STATUS_USER) 393 | { 394 | fprintf(stderr, 395 | "Could not decode instruction: User defined status code 0x%" PRIx32, status); 396 | } else 397 | { 398 | fprintf(stderr, "Could not decode instruction: %s", ZydisFormatStatus(status)); 399 | } 400 | return status; 401 | } 402 | 403 | printInstruction(instruction); 404 | --]=] 405 | return true; 406 | end 407 | 408 | main() -------------------------------------------------------------------------------- /testy/test_ZydisDecoder.lua: -------------------------------------------------------------------------------- 1 | package.path = "../?.lua;"..package.path 2 | 3 | local ffi = require("ffi") 4 | local bit = require("bit") 5 | 6 | local zydis = require("lj2zydis.zydis") 7 | local ZydisFormatter = require("lj2zydis.ZydisFormatter") 8 | local ZydisDecoder = require("lj2zydis.ZydisDecoder") 9 | 10 | 11 | local sizeOfCode = 25; 12 | local data = ffi.new("uint8_t[25]", 13 | { 14 | 0x51, 0x8D, 0x45, 0xFF, 0x50, 0xFF, 0x75, 0x0C, 0xFF, 0x75, 15 | 0x08, 0xFF, 0x15, 0xA0, 0xA5, 0x48, 0x76, 0x85, 0xC0, 0x0F, 16 | 0x88, 0xFC, 0xDA, 0x02, 0x00 17 | }); 18 | 19 | --[[ 20 | 007FFFFFFF400000 push rcx 21 | 007FFFFFFF400001 lea eax, [rbp-0x01] 22 | 007FFFFFFF400004 push rax 23 | 007FFFFFFF400005 push qword ptr [rbp+0x0C] 24 | 007FFFFFFF400008 push qword ptr [rbp+0x08] 25 | 007FFFFFFF40000B call [0x008000007588A5B1] 26 | 007FFFFFFF400011 test eax, eax 27 | 007FFFFFFF400013 js 0x007FFFFFFF42DB15 28 | ]] 29 | 30 | 31 | local function main() 32 | 33 | local decoder = ZydisDecoder(ffi.C.ZYDIS_MACHINE_MODE_LONG_64, ffi.C.ZYDIS_ADDRESS_WIDTH_64); 34 | local formatter = ZydisFormatter(); 35 | 36 | local offset = 0 37 | local length = sizeOfCode; 38 | local instructionPointer = 0x007FFFFFFF400000ULL; 39 | local instruction = ffi.new("ZydisDecodedInstruction"); 40 | local buffer = ffi.new("uint8_t[256]"); 41 | 42 | while (decoder:DecodeBuffer(data + offset, length - offset,instructionPointer, instruction)) do 43 | -- Print current instruction pointer. 44 | io.write(string.format("0x%s ", bit.tohex(instructionPointer))); 45 | 46 | -- Format & print the binary instruction 47 | -- structure to human readable format. 48 | formatter:FormatInstruction(instruction, buffer, 256); 49 | print(ffi.string(buffer)); 50 | 51 | offset = offset+instruction.length; 52 | instructionPointer = instructionPointer + instruction.length; 53 | end 54 | 55 | return true; 56 | end 57 | 58 | main() 59 | -------------------------------------------------------------------------------- /testy/test_basic.lua: -------------------------------------------------------------------------------- 1 | package.path = "../?.lua;"..package.path 2 | 3 | local ffi = require("ffi") 4 | local bit = require("bit") 5 | 6 | local zydis = require("lj2zydis.zydis") 7 | 8 | print("Version: ",bit.tohex(zydis.ZydisGetVersion())) --------------------------------------------------------------------------------