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/Mnemonic.h>
#include <Zydis/Register.h>
#include <Zydis/SharedTypes.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ============================================================================================== */
/* Decoded operand */
/* ============================================================================================== */
 
typedef struct ZydisDecodedOperand_
{
 uint8_t id;
 ZydisOperandType type;
 ZydisOperandVisibility visibility;
 ZydisOperandAction action; 
 ZydisOperandEncoding encoding;
 uint16_t size; 
 ZydisElementType elementType;
 ZydisElementSize elementSize;
 uint16_t elementCount;
 ZydisRegister reg;
 struct
 {
 ZydisBool isAddressGenOnly;
 ZydisRegister segment;
 ZydisRegister base;
 ZydisRegister index;
 uint8_t scale;
 struct
 {
 ZydisBool hasDisplacement;
 int64_t value;
 } disp;
 } mem;
 struct 
 {
 uint16_t segment;
 uint32_t offset;
 } ptr;
 struct
 {
 ZydisBool isSigned;
 ZydisBool isRelative;
 union 
 {
 uint64_t u;
 int64_t s; 
 } value;
 } imm;
} ZydisDecodedOperand;
 
/* ============================================================================================== */
/* Decoded instruction */
/* ============================================================================================== */
 
/* ---------------------------------------------------------------------------------------------- */
/* Instruction attributes */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint64_t ZydisInstructionAttributes;
 
// TODO: Update values
 
#define ZYDIS_ATTRIB_HAS_MODRM 0x0000000000000001
#define ZYDIS_ATTRIB_HAS_SIB 0x0000000000000002
#define ZYDIS_ATTRIB_HAS_REX 0x0000000000000004
#define ZYDIS_ATTRIB_HAS_XOP 0x0000000000000008
#define ZYDIS_ATTRIB_HAS_VEX 0x0000000000000010
#define ZYDIS_ATTRIB_HAS_EVEX 0x0000000000000020
#define ZYDIS_ATTRIB_IS_RELATIVE 0x0000000000000040
#define ZYDIS_ATTRIB_IS_PRIVILEGED 0x0000000000000080
#define ZYDIS_ATTRIB_ACCEPTS_LOCK 0x0000000000000100
#define ZYDIS_ATTRIB_ACCEPTS_REP 0x0000000000000200
#define ZYDIS_ATTRIB_ACCEPTS_REPE 0x0000000000000400
#define ZYDIS_ATTRIB_ACCEPTS_REPZ 0x0000000000000400
#define ZYDIS_ATTRIB_ACCEPTS_REPNE 0x0000000000000800
#define ZYDIS_ATTRIB_ACCEPTS_REPNZ 0x0000000000000800
#define ZYDIS_ATTRIB_ACCEPTS_BOUND 0x0000000000001000
#define ZYDIS_ATTRIB_ACCEPTS_XACQUIRE 0x0000000000002000
#define ZYDIS_ATTRIB_ACCEPTS_XRELEASE 0x0000000000004000
#define ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK 0x0000000000008000
#define ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS 0x0000000000010000
#define ZYDIS_ATTRIB_ACCEPTS_SEGMENT 0x0000000000020000
#define ZYDIS_ATTRIB_HAS_LOCK 0x0000000000100000
#define ZYDIS_ATTRIB_HAS_REP 0x0000000000200000
#define ZYDIS_ATTRIB_HAS_REPE 0x0000000000400000
#define ZYDIS_ATTRIB_HAS_REPZ 0x0000000000400000
#define ZYDIS_ATTRIB_HAS_REPNE 0x0000000000800000
#define ZYDIS_ATTRIB_HAS_REPNZ 0x0000000000800000
#define ZYDIS_ATTRIB_HAS_BOUND 0x0000000001000000
#define ZYDIS_ATTRIB_HAS_XACQUIRE 0x0000000002000000
#define ZYDIS_ATTRIB_HAS_XRELEASE 0x0000000004000000
#define ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN 0x0000000008000000
#define ZYDIS_ATTRIB_HAS_BRANCH_TAKEN 0x0000000010000000
#define ZYDIS_ATTRIB_HAS_SEGMENT 0x00000007E0000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_CS 0x0000000020000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_SS 0x0000000040000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_DS 0x0000000080000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_ES 0x0000000100000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_FS 0x0000000200000000
#define ZYDIS_ATTRIB_HAS_SEGMENT_GS 0x0000000400000000
#define ZYDIS_ATTRIB_HAS_OPERANDSIZE 0x0000000800000000
#define ZYDIS_ATTRIB_HAS_ADDRESSSIZE 0x0000001000000000
 
/* ---------------------------------------------------------------------------------------------- */
/* R/E/FLAGS info */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint8_t ZydisCPUFlag;
 
typedef uint32_t 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_ENUM_COUNT
};
 
typedef uint8_t 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
};
 
/* ---------------------------------------------------------------------------------------------- */
/* SSE/AVX exception-class */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint16_t ZydisExceptionClass;
 
enum ZydisExceptionClasses
{
 ZYDIS_EXCEPTION_CLASS_NONE,
 // TODO: SSE and AVX
 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_E12,
 ZYDIS_EXCEPTION_CLASS_E12NP,
 ZYDIS_EXCEPTION_CLASS_K20,
 ZYDIS_EXCEPTION_CLASS_K21
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX vector-length */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint16_t ZydisVectorLength;
 
enum ZydisVectorLengths
{
 ZYDIS_VECTOR_LENGTH_INVALID = 0,
 ZYDIS_VECTOR_LENGTH_128 = 128,
 ZYDIS_VECTOR_LENGTH_256 = 256,
 ZYDIS_VECTOR_LENGTH_512 = 512
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX mask mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint8_t ZydisMaskMode;
 
enum ZydisMaskModes
{
 ZYDIS_MASK_MODE_INVALID,
 ZYDIS_MASK_MODE_MERGE,
 ZYDIS_MASK_MODE_ZERO
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX broadcast-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint16_t 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
};
 
/* ---------------------------------------------------------------------------------------------- */
/* AVX rounding-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint8_t ZydisRoundingMode;
 
enum ZydisRoundingModes
{
 ZYDIS_ROUNDING_MODE_INVALID,
 ZYDIS_ROUNDING_MODE_RN,
 ZYDIS_ROUNDING_MODE_RD,
 ZYDIS_ROUNDING_MODE_RU,
 ZYDIS_ROUNDING_MODE_RZ
};
 
/* ---------------------------------------------------------------------------------------------- */
/* KNC swizzle-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint16_t 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
};
 
/* ---------------------------------------------------------------------------------------------- */
/* KNC conversion-mode */
/* ---------------------------------------------------------------------------------------------- */
 
typedef uint16_t 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
};
 
/* ---------------------------------------------------------------------------------------------- */
/* Decoded instruction */
/* ---------------------------------------------------------------------------------------------- */
 
typedef struct ZydisDecodedInstruction_
{
 ZydisMachineMode machineMode;
 ZydisMnemonic mnemonic; 
 uint8_t length;
 uint8_t data[ZYDIS_MAX_INSTRUCTION_LENGTH];
 ZydisInstructionEncoding encoding;
 ZydisOpcodeMap opcodeMap;
 uint8_t opcode;
 uint8_t operandSize;
 uint8_t stackWidth;
 uint8_t addressWidth;
 uint8_t operandCount;
 ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
 ZydisInstructionAttributes attributes;
 uint64_t instrAddress;
 uint64_t instrPointer;
 struct
 {
 ZydisCPUFlagAction action;
 } flags[ZYDIS_CPUFLAG_ENUM_COUNT];
 struct
 {
 ZydisVectorLength vectorLength;
 struct
 {
 ZydisMaskMode mode;
 ZydisRegister reg;
 ZydisBool isControlMask;
 } mask;
 struct
 {
 ZydisBool isStatic;
 ZydisBroadcastMode mode;
 } broadcast;
 ZydisRoundingMode roundingMode;
 ZydisSwizzleMode swizzleMode;
 ZydisConversionMode conversionMode;
 ZydisBool hasSAE;
 ZydisBool hasEvictionHint;
 } avx; 
 struct
 {
 struct
 {
 uint8_t data[ZYDIS_MAX_INSTRUCTION_LENGTH - 1];
 uint8_t count;
 uint8_t hasF0;
 uint8_t hasF3;
 uint8_t hasF2;
 uint8_t has2E;
 uint8_t has36;
 uint8_t has3E;
 uint8_t has26;
 uint8_t has64;
 uint8_t has65;
 uint8_t has66;
 uint8_t has67;
 } prefixes;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[1];
 uint8_t W;
 uint8_t R;
 uint8_t X;
 uint8_t B;
 } rex; 
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[3];
 uint8_t R;
 uint8_t X;
 uint8_t B;
 uint8_t m_mmmm;
 uint8_t W;
 uint8_t vvvv;
 uint8_t L;
 uint8_t pp;
 } xop;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[3];
 uint8_t R;
 uint8_t X;
 uint8_t B;
 uint8_t m_mmmm;
 uint8_t W;
 uint8_t vvvv;
 uint8_t L;
 uint8_t pp;
 } vex;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[4];
 uint8_t R;
 uint8_t X;
 uint8_t B;
 uint8_t R2;
 uint8_t mm;
 uint8_t W;
 uint8_t vvvv;
 uint8_t pp;
 uint8_t z;
 uint8_t L2;
 uint8_t L;
 uint8_t b;
 uint8_t V2;
 uint8_t aaa;
 } evex;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[4];
 uint8_t R;
 uint8_t X;
 uint8_t B;
 uint8_t R2;
 uint8_t mmmm;
 uint8_t W;
 uint8_t vvvv;
 uint8_t pp;
 uint8_t E;
 uint8_t SSS;
 uint8_t V2;
 uint8_t kkk;
 } mvex;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[1];
 uint8_t mod;
 uint8_t reg;
 uint8_t rm;
 } modrm;
 struct
 {
 ZydisBool isDecoded;
 uint8_t data[1];
 uint8_t scale;
 uint8_t index;
 uint8_t base;
 } sib;
 struct
 {
 int64_t value;
 uint8_t size;
 uint8_t offset;
 } disp;
 struct
 {
 ZydisBool isSigned; 
 ZydisBool isRelative;
 union
 { 
 uint64_t u;
 int64_t s;
 } value;
 uint8_t size;
 uint8_t offset;
 } imm[2];
 } raw;
 void* userData;
} ZydisDecodedInstruction;
 
/* ---------------------------------------------------------------------------------------------- */
 
/* ============================================================================================== */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZYDIS_INSTRUCTIONINFO_H */