DecoderTypes.h

Go to the documentation of this file.

/***************************************************************************************************
 
 Zyan Disassembler Library (Zydis)
 
 Original Author : Florian Bernd
 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 
***************************************************************************************************/
 
#ifndef ZYDIS_INSTRUCTIONINFO_H
#define ZYDIS_INSTRUCTIONINFO_H
 
#include <Zydis/CommonTypes.h>
#include <Zydis/MetaInfo.h>
#include <Zydis/Mnemonic.h>
#include <Zydis/Register.h>
#include <Zydis/SharedTypes.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ============================================================================================== */
/* Decoded operand */
/* ============================================================================================== */
 
/* ---------------------------------------------------------------------------------------------- */
/* Memory type */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisMemoryOperandType;
 
enum ZydisMemoryOperandTypes
{
 ZYDIS_MEMOP_TYPE_INVALID,
 ZYDIS_MEMOP_TYPE_MEM,
 ZYDIS_MEMOP_TYPE_AGEN,
 ZYDIS_MEMOP_TYPE_MIB,
 
 ZYDIS_MEMOP_TYPE_MAX_VALUE = ZYDIS_MEMOP_TYPE_MIB
};
 
/* ---------------------------------------------------------------------------------------------- */
/* Decoded operand */
/* ---------------------------------------------------------------------------------------------- */
 
typedef struct ZydisDecodedOperand_
{
 ZydisU8 id;
 ZydisOperandType type;
 ZydisOperandVisibility visibility;
 ZydisOperandAction action;
 ZydisOperandEncoding encoding;
 ZydisU16 size;
 ZydisElementType elementType;
 ZydisElementSize elementSize;
 ZydisU16 elementCount;
 struct
 {
 ZydisRegister value;
 // TODO: AVX512_4VNNIW MULTISOURCE registers
 } reg;
 struct
 {
 ZydisMemoryOperandType type;
 ZydisRegister segment;
 ZydisRegister base;
 ZydisRegister index;
 ZydisU8 scale;
 struct
 {
 ZydisBool hasDisplacement;
 ZydisI64 value;
 } disp;
 } mem;
 struct
 {
 ZydisU16 segment;
 ZydisU32 offset;
 } ptr;
 struct
 {
 ZydisBool isSigned;
 ZydisBool isRelative;
   union
 {
 ZydisU64 u;
 ZydisI64 s;
 } value;
 } imm;
} ZydisDecodedOperand;
 
/* ---------------------------------------------------------------------------------------------- */
 
/* ============================================================================================== */
/* Decoded instruction */
/* ============================================================================================== */
 
/* ---------------------------------------------------------------------------------------------- */
/* Instruction attributes */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU64 ZydisInstructionAttributes;
 
#define ZYDIS_ATTRIB_HAS_MODRM 0x0000000000000001 // (1 << 0)
#define ZYDIS_ATTRIB_HAS_SIB 0x0000000000000002 // (1 << 1)
#define ZYDIS_ATTRIB_HAS_REX 0x0000000000000004 // (1 << 2)
#define ZYDIS_ATTRIB_HAS_XOP 0x0000000000000008 // (1 << 3)
#define ZYDIS_ATTRIB_HAS_VEX 0x0000000000000010 // (1 << 4)
#define ZYDIS_ATTRIB_HAS_EVEX 0x0000000000000020 // (1 << 5)
#define ZYDIS_ATTRIB_HAS_MVEX 0x0000000000000040 // (1 << 6)
#define ZYDIS_ATTRIB_IS_RELATIVE 0x0000000000000080 // (1 << 7)
#define ZYDIS_ATTRIB_IS_PRIVILEGED 0x0000000000000100 // (1 << 8)
 
#define ZYDIS_ATTRIB_IS_FAR_BRANCH 0x0000001000000000 // (1 << 36) // TODO: rebase
 
#define ZYDIS_ATTRIB_ACCEPTS_LOCK 0x0000000000000200 // (1 << 9)
#define ZYDIS_ATTRIB_ACCEPTS_REP 0x0000000000000400 // (1 << 10)
#define ZYDIS_ATTRIB_ACCEPTS_REPE 0x0000000000000800 // (1 << 11)
#define ZYDIS_ATTRIB_ACCEPTS_REPZ 0x0000000000000800 // (1 << 11)
#define ZYDIS_ATTRIB_ACCEPTS_REPNE 0x0000000000001000 // (1 << 12)
#define ZYDIS_ATTRIB_ACCEPTS_REPNZ 0x0000000000001000 // (1 << 12)
#define ZYDIS_ATTRIB_ACCEPTS_BOUND 0x0000000000002000 // (1 << 13)
#define ZYDIS_ATTRIB_ACCEPTS_XACQUIRE 0x0000000000004000 // (1 << 14)
#define ZYDIS_ATTRIB_ACCEPTS_XRELEASE 0x0000000000008000 // (1 << 15)
#define ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK 0x0000000000010000 // (1 << 16)
#define ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS 0x0000000000020000 // (1 << 17)
#define ZYDIS_ATTRIB_ACCEPTS_SEGMENT 0x0000000000040000 // (1 << 18)
#define ZYDIS_ATTRIB_HAS_LOCK 0x0000000000080000 // (1 << 19)
#define ZYDIS_ATTRIB_HAS_REP 0x0000000000100000 // (1 << 20)
#define ZYDIS_ATTRIB_HAS_REPE 0x0000000000200000 // (1 << 21)
#define ZYDIS_ATTRIB_HAS_REPZ 0x0000000000200000 // (1 << 21)
#define ZYDIS_ATTRIB_HAS_REPNE 0x0000000000400000 // (1 << 22)
#define ZYDIS_ATTRIB_HAS_REPNZ 0x0000000000400000 // (1 << 22)
#define ZYDIS_ATTRIB_HAS_BOUND 0x0000000000800000 // (1 << 23)
#define ZYDIS_ATTRIB_HAS_XACQUIRE 0x0000000001000000 // (1 << 24)
#define ZYDIS_ATTRIB_HAS_XRELEASE 0x0000000002000000 // (1 << 25)
#define ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN 0x0000000004000000 // (1 << 26)
#define ZYDIS_ATTRIB_HAS_BRANCH_TAKEN 0x0000000008000000 // (1 << 27)
#define ZYDIS_ATTRIB_HAS_SEGMENT 0x00000003F0000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_CS 0x0000000010000000 // (1 << 28)
#define ZYDIS_ATTRIB_HAS_SEGMENT_SS 0x0000000020000000 // (1 << 29)
#define ZYDIS_ATTRIB_HAS_SEGMENT_DS 0x0000000040000000 // (1 << 30)
#define ZYDIS_ATTRIB_HAS_SEGMENT_ES 0x0000000080000000 // (1 << 31)
#define ZYDIS_ATTRIB_HAS_SEGMENT_FS 0x0000000100000000 // (1 << 32)
#define ZYDIS_ATTRIB_HAS_SEGMENT_GS 0x0000000200000000 // (1 << 33)
#define ZYDIS_ATTRIB_HAS_OPERANDSIZE 0x0000000400000000 // (1 << 34) // TODO: rename
#define ZYDIS_ATTRIB_HAS_ADDRESSSIZE 0x0000000800000000 // (1 << 35) // TODO: rename
 
/* ---------------------------------------------------------------------------------------------- */
/* R/E/FLAGS info */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisCPUFlag;
 
typedef ZydisU32 ZydisCPUFlagMask;
 
enum ZydisCPUFlags
{
 ZYDIS_CPUFLAG_CF,
 ZYDIS_CPUFLAG_PF,
 ZYDIS_CPUFLAG_AF,
 ZYDIS_CPUFLAG_ZF,
 ZYDIS_CPUFLAG_SF,
 ZYDIS_CPUFLAG_TF,
 ZYDIS_CPUFLAG_IF,
 ZYDIS_CPUFLAG_DF,
 ZYDIS_CPUFLAG_OF,
 ZYDIS_CPUFLAG_IOPL,
 ZYDIS_CPUFLAG_NT,
 ZYDIS_CPUFLAG_RF,
 ZYDIS_CPUFLAG_VM,
 ZYDIS_CPUFLAG_AC,
 ZYDIS_CPUFLAG_VIF,
 ZYDIS_CPUFLAG_VIP,
 ZYDIS_CPUFLAG_ID,
 ZYDIS_CPUFLAG_C0,
 ZYDIS_CPUFLAG_C1,
 ZYDIS_CPUFLAG_C2,
 ZYDIS_CPUFLAG_C3,
 
 ZYDIS_CPUFLAG_MAX_VALUE = ZYDIS_CPUFLAG_C3
};
 
typedef ZydisU8 ZydisCPUFlagAction;
 
enum ZydisCPUFlagActions
{
 ZYDIS_CPUFLAG_ACTION_NONE,
 ZYDIS_CPUFLAG_ACTION_TESTED,
 ZYDIS_CPUFLAG_ACTION_MODIFIED,
 ZYDIS_CPUFLAG_ACTION_SET_0,
 ZYDIS_CPUFLAG_ACTION_SET_1,
 ZYDIS_CPUFLAG_ACTION_UNDEFINED,
 
 ZYDIS_CPUFLAG_ACTION_MAX_VALUE = ZYDIS_CPUFLAG_ACTION_UNDEFINED
};
 
/* ---------------------------------------------------------------------------------------------- */
/* SSE/AVX exception-class */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisExceptionClass;
 
enum ZydisExceptionClasses
{
 ZYDIS_EXCEPTION_CLASS_NONE,
 // TODO: FP Exceptions
 ZYDIS_EXCEPTION_CLASS_SSE1,
 ZYDIS_EXCEPTION_CLASS_SSE2,
 ZYDIS_EXCEPTION_CLASS_SSE3,
 ZYDIS_EXCEPTION_CLASS_SSE4,
 ZYDIS_EXCEPTION_CLASS_SSE5,
 ZYDIS_EXCEPTION_CLASS_SSE7,
 ZYDIS_EXCEPTION_CLASS_AVX1,
 ZYDIS_EXCEPTION_CLASS_AVX2,
 ZYDIS_EXCEPTION_CLASS_AVX3,
 ZYDIS_EXCEPTION_CLASS_AVX4,
 ZYDIS_EXCEPTION_CLASS_AVX5,
 ZYDIS_EXCEPTION_CLASS_AVX6,
 ZYDIS_EXCEPTION_CLASS_AVX7,
 ZYDIS_EXCEPTION_CLASS_AVX8,
 ZYDIS_EXCEPTION_CLASS_AVX11,
 ZYDIS_EXCEPTION_CLASS_AVX12,
 ZYDIS_EXCEPTION_CLASS_E1,
 ZYDIS_EXCEPTION_CLASS_E1NF,
 ZYDIS_EXCEPTION_CLASS_E2,
 ZYDIS_EXCEPTION_CLASS_E2NF,
 ZYDIS_EXCEPTION_CLASS_E3,
 ZYDIS_EXCEPTION_CLASS_E3NF,
 ZYDIS_EXCEPTION_CLASS_E4,
 ZYDIS_EXCEPTION_CLASS_E4NF,
 ZYDIS_EXCEPTION_CLASS_E5,
 ZYDIS_EXCEPTION_CLASS_E5NF,
 ZYDIS_EXCEPTION_CLASS_E6,
 ZYDIS_EXCEPTION_CLASS_E6NF,
 ZYDIS_EXCEPTION_CLASS_E7NM,
 ZYDIS_EXCEPTION_CLASS_E7NM128,
 ZYDIS_EXCEPTION_CLASS_E9NF,
 ZYDIS_EXCEPTION_CLASS_E10,
 ZYDIS_EXCEPTION_CLASS_E10NF,
 ZYDIS_EXCEPTION_CLASS_E11,
 ZYDIS_EXCEPTION_CLASS_E11NF,
 ZYDIS_EXCEPTION_CLASS_E12,
 ZYDIS_EXCEPTION_CLASS_E12NP,
 ZYDIS_EXCEPTION_CLASS_K20,
 ZYDIS_EXCEPTION_CLASS_K21,
 
 ZYDIS_EXCEPTION_CLASS_MAX_VALUE = ZYDIS_EXCEPTION_CLASS_K21
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX vector-length */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU16 ZydisVectorLength;
 
enum ZydisVectorLengths
{
 ZYDIS_VECTOR_LENGTH_INVALID = 0,
 ZYDIS_VECTOR_LENGTH_128 = 128,
 ZYDIS_VECTOR_LENGTH_256 = 256,
 ZYDIS_VECTOR_LENGTH_512 = 512,
 
 ZYDIS_VECTOR_LENGTH_MAX_VALUE = ZYDIS_VECTOR_LENGTH_512
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX mask mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisMaskMode;
 
enum ZydisMaskModes
{
 ZYDIS_MASK_MODE_INVALID,
 
 // TODO: Add `ZYDIS_MASK_MODE_DISABLED` for for `EVEX`/`MVEX` instructions with `K0` mask
 // TODO: Add `ZYDIS_MASK_MODE_CONTROL` and `ZYDIS_MASK_MODE_CONTROL_ZERO` as replacement for
 // the `isControlMask` field
 
 ZYDIS_MASK_MODE_MERGE,
 ZYDIS_MASK_MODE_ZERO,
 
 ZYDIS_MASK_MODE_MAX_VALUE = ZYDIS_MASK_MODE_ZERO
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX broadcast-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisBroadcastMode;
 
enum ZydisBroadcastModes
{
 ZYDIS_BROADCAST_MODE_INVALID,
 ZYDIS_BROADCAST_MODE_1_TO_2,
 ZYDIS_BROADCAST_MODE_1_TO_4,
 ZYDIS_BROADCAST_MODE_1_TO_8,
 ZYDIS_BROADCAST_MODE_1_TO_16,
 ZYDIS_BROADCAST_MODE_1_TO_32,
 ZYDIS_BROADCAST_MODE_1_TO_64,
 ZYDIS_BROADCAST_MODE_2_TO_4,
 ZYDIS_BROADCAST_MODE_2_TO_8,
 ZYDIS_BROADCAST_MODE_2_TO_16,
 ZYDIS_BROADCAST_MODE_4_TO_8,
 ZYDIS_BROADCAST_MODE_4_TO_16,
 ZYDIS_BROADCAST_MODE_8_TO_16,
 
 ZYDIS_BROADCAST_MODE_MAX_VALUE = ZYDIS_BROADCAST_MODE_8_TO_16
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX rounding-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisRoundingMode;
 
enum ZydisRoundingModes
{
 ZYDIS_ROUNDING_MODE_INVALID,
 ZYDIS_ROUNDING_MODE_RN,
 ZYDIS_ROUNDING_MODE_RD,
 ZYDIS_ROUNDING_MODE_RU,
 ZYDIS_ROUNDING_MODE_RZ,
 
 ZYDIS_ROUNDING_MODE_MAX_VALUE = ZYDIS_ROUNDING_MODE_RZ
};
 
/* ---------------------------------------------------------------------------------------------- */
/* KNC swizzle-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisSwizzleMode;
 
enum ZydisSwizzleModes
{
 ZYDIS_SWIZZLE_MODE_INVALID,
 ZYDIS_SWIZZLE_MODE_DCBA,
 ZYDIS_SWIZZLE_MODE_CDAB,
 ZYDIS_SWIZZLE_MODE_BADC,
 ZYDIS_SWIZZLE_MODE_DACB,
 ZYDIS_SWIZZLE_MODE_AAAA,
 ZYDIS_SWIZZLE_MODE_BBBB,
 ZYDIS_SWIZZLE_MODE_CCCC,
 ZYDIS_SWIZZLE_MODE_DDDD,
 
 ZYDIS_SWIZZLE_MODE_MAX_VALUE = ZYDIS_SWIZZLE_MODE_DDDD
};
 
/* ---------------------------------------------------------------------------------------------- */
/* KNC conversion-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef ZydisU8 ZydisConversionMode;
 
enum ZydisConversionModes
{
 ZYDIS_CONVERSION_MODE_INVALID,
 ZYDIS_CONVERSION_MODE_FLOAT16,
 ZYDIS_CONVERSION_MODE_SINT8,
 ZYDIS_CONVERSION_MODE_UINT8,
 ZYDIS_CONVERSION_MODE_SINT16,
 ZYDIS_CONVERSION_MODE_UINT16,
 
 ZYDIS_CONVERSION_MODE_MAX_VALUE = ZYDIS_CONVERSION_MODE_UINT16
};
 
/* ---------------------------------------------------------------------------------------------- */
/* Decoded instruction */
/* ---------------------------------------------------------------------------------------------- */
 
typedef struct ZydisDecodedInstruction_
{
 ZydisMachineMode machineMode;
 ZydisMnemonic mnemonic;
 ZydisU8 length;
 ZydisU8 data[ZYDIS_MAX_INSTRUCTION_LENGTH];
 ZydisInstructionEncoding encoding;
 ZydisOpcodeMap opcodeMap;
 ZydisU8 opcode;
 ZydisU8 stackWidth;
 ZydisU8 operandWidth;
 ZydisU8 addressWidth;
 ZydisU8 operandCount;
 ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
 ZydisInstructionAttributes attributes;
 ZydisU64 instrAddress;
 struct
 {
 ZydisCPUFlagAction action;
 } accessedFlags[ZYDIS_CPUFLAG_MAX_VALUE + 1];
 struct
 {
 ZydisVectorLength vectorLength;
 struct
 {
 ZydisMaskMode mode;
 ZydisRegister reg;
 ZydisBool isControlMask;
 } mask;
 struct
 {
 ZydisBool isStatic;
 ZydisBroadcastMode mode;
 } broadcast;
 struct
 {
 ZydisRoundingMode mode;
 } rounding;
 struct
 {
 ZydisSwizzleMode mode;
 } swizzle;
 struct
 {
 ZydisConversionMode mode;
 } conversion;
 ZydisBool hasSAE;
 ZydisBool hasEvictionHint;
 // TODO: publish EVEX tuple-type and MVEX functionality
 } avx;
 struct
 {
 ZydisInstructionCategory category;
 ZydisISASet isaSet;
 ZydisISAExt isaExt;
 ZydisExceptionClass exceptionClass;
 } meta;
 struct
 {
 struct
 {
 ZydisU8 data[ZYDIS_MAX_INSTRUCTION_LENGTH - 1];
 ZydisU8 count;
 ZydisU8 hasF0;
 ZydisU8 hasF3;
 ZydisU8 hasF2;
 ZydisU8 has2E;
 ZydisU8 has36;
 ZydisU8 has3E;
 ZydisU8 has26;
 ZydisU8 has64;
 ZydisU8 has65;
 ZydisU8 has66;
 ZydisU8 has67;
 } prefixes;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[1];
 ZydisU8 W;
 ZydisU8 R;
 ZydisU8 X;
 ZydisU8 B;
 } rex;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[3];
 ZydisU8 R;
 ZydisU8 X;
 ZydisU8 B;
 ZydisU8 m_mmmm;
 ZydisU8 W;
 ZydisU8 vvvv;
 ZydisU8 L;
 ZydisU8 pp;
 } xop;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[3];
 ZydisU8 R;
 ZydisU8 X;
 ZydisU8 B;
 ZydisU8 m_mmmm;
 ZydisU8 W;
 ZydisU8 vvvv;
 ZydisU8 L;
 ZydisU8 pp;
 } vex;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[4];
 ZydisU8 R;
 ZydisU8 X;
 ZydisU8 B;
 ZydisU8 R2;
 ZydisU8 mm;
 ZydisU8 W;
 ZydisU8 vvvv;
 ZydisU8 pp;
 ZydisU8 z;
 ZydisU8 L2;
 ZydisU8 L;
 ZydisU8 b;
 ZydisU8 V2;
 ZydisU8 aaa;
 } evex;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[4];
 ZydisU8 R;
 ZydisU8 X;
 ZydisU8 B;
 ZydisU8 R2;
 ZydisU8 mmmm;
 ZydisU8 W;
 ZydisU8 vvvv;
 ZydisU8 pp;
 ZydisU8 E;
 ZydisU8 SSS;
 ZydisU8 V2;
 ZydisU8 kkk;
 } mvex;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[1];
 ZydisU8 mod;
 ZydisU8 reg;
 ZydisU8 rm;
 } modrm;
 struct
 {
 ZydisBool isDecoded;
 ZydisU8 data[1];
 ZydisU8 scale;
 ZydisU8 index;
 ZydisU8 base;
 } sib;
 struct
 {
 ZydisI64 value;
 ZydisU8 size;
 // TODO: publish cd8 scale
 ZydisU8 offset;
 } disp;
 struct
 {
 ZydisBool isSigned;
 ZydisBool isRelative;
 union
 {
 ZydisU64 u;
 ZydisI64 s;
 } value;
 ZydisU8 size;
 ZydisU8 offset;
 } imm[2];
 } raw;
} ZydisDecodedInstruction;
 
/* ---------------------------------------------------------------------------------------------- */
 
/* ============================================================================================== */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZYDIS_INSTRUCTIONINFO_H */