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 <Zycore/Types.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 enum ZydisMemoryOperandType_
{
    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,
    ZYDIS_MEMOP_TYPE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_MEMOP_TYPE_MAX_VALUE)
} ZydisMemoryOperandType;

/* ---------------------------------------------------------------------------------------------- */
/* Decoded operand                                                                                */
/* ---------------------------------------------------------------------------------------------- */

typedef struct ZydisDecodedOperand_
{
    ZyanU8 id;
    ZydisOperandType type;
    ZydisOperandVisibility visibility;
    ZydisOperandActions actions;
    ZydisOperandEncoding encoding;
    ZyanU16 size;
    ZydisElementType element_type;
    ZydisElementSize element_size;
    ZyanU16 element_count;
    struct ZydisDecodedOperandReg_
    {
        ZydisRegister value;
        // TODO: AVX512_4VNNIW MULTISOURCE registers
    } reg;
    struct ZydisDecodedOperandMem_
    {
        ZydisMemoryOperandType type;
        ZydisRegister segment;
        ZydisRegister base;
        ZydisRegister index;
        ZyanU8 scale;
        struct ZydisDecodedOperandMemDisp_
        {
            ZyanBool has_displacement;
            ZyanI64 value;
        } disp;
    } mem;
    struct ZydisDecodedOperandPtr_
    {
        ZyanU16 segment;
        ZyanU32 offset;
    } ptr;
    struct ZydisDecodedOperandImm_
    {
        ZyanBool is_signed;
        ZyanBool is_relative;
        union ZydisDecodedOperandImmValue_
        {
            ZyanU64 u;
            ZyanI64 s;
        } value;
    } imm;
} ZydisDecodedOperand;

/* ---------------------------------------------------------------------------------------------- */

/* ============================================================================================== */
/* Decoded instruction                                                                            */
/* ============================================================================================== */

/* ---------------------------------------------------------------------------------------------- */
/* Instruction attributes                                                                         */
/* ---------------------------------------------------------------------------------------------- */

typedef ZyanU64 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_CPUFLAG_ACCESS             0x0000001000000000 // (1 << 36) // TODO: rebase

#define ZYDIS_ATTRIB_CPU_STATE_CR               0x0000002000000000 // (1 << 37) // TODO: rebase

#define ZYDIS_ATTRIB_CPU_STATE_CW               0x0000004000000000 // (1 << 38) // TODO: rebase

#define ZYDIS_ATTRIB_FPU_STATE_CR               0x0000008000000000 // (1 << 39) // TODO: rebase

#define ZYDIS_ATTRIB_FPU_STATE_CW               0x0000010000000000 // (1 << 40) // TODO: rebase

#define ZYDIS_ATTRIB_XMM_STATE_CR               0x0000020000000000 // (1 << 41) // TODO: rebase

#define ZYDIS_ATTRIB_XMM_STATE_CW               0x0000040000000000 // (1 << 42) // 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_BND                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_BND                    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 ZyanU32 ZydisCPUFlags;

typedef enum ZydisCPUFlag_
{
    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,
    ZYDIS_CPUFLAG_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_CPUFLAG_MAX_VALUE)
} ZydisCPUFlag;

typedef enum ZydisCPUFlagAction_
{
    ZYDIS_CPUFLAG_ACTION_NONE,
    ZYDIS_CPUFLAG_ACTION_TESTED,
    ZYDIS_CPUFLAG_ACTION_TESTED_MODIFIED,
    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,
    ZYDIS_CPUFLAG_ACTION_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_CPUFLAG_ACTION_MAX_VALUE)
} ZydisCPUFlagAction;

/* ---------------------------------------------------------------------------------------------- */
/* Branch types                                                                                   */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisBranchType_
{
    ZYDIS_BRANCH_TYPE_NONE,
    ZYDIS_BRANCH_TYPE_SHORT,
    ZYDIS_BRANCH_TYPE_NEAR,
    ZYDIS_BRANCH_TYPE_FAR,

    ZYDIS_BRANCH_TYPE_MAX_VALUE = ZYDIS_BRANCH_TYPE_FAR,
    ZYDIS_BRANCH_TYPE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_BRANCH_TYPE_MAX_VALUE)
} ZydisBranchType;

/* ---------------------------------------------------------------------------------------------- */
/* SSE/AVX exception-class                                                                        */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisExceptionClass_
{
    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,
    ZYDIS_EXCEPTION_CLASS_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_EXCEPTION_CLASS_MAX_VALUE)
} ZydisExceptionClass;

/* ---------------------------------------------------------------------------------------------- */
/* AVX mask mode                                                                                  */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisMaskMode_
{
    ZYDIS_MASK_MODE_INVALID,
    ZYDIS_MASK_MODE_DISABLED,
    ZYDIS_MASK_MODE_MERGING,
    ZYDIS_MASK_MODE_ZEROING,
    ZYDIS_MASK_MODE_CONTROL,
    ZYDIS_MASK_MODE_CONTROL_ZEROING,

    ZYDIS_MASK_MODE_MAX_VALUE = ZYDIS_MASK_MODE_CONTROL_ZEROING,
    ZYDIS_MASK_MODE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_MASK_MODE_MAX_VALUE)
} ZydisMaskMode;

/* ---------------------------------------------------------------------------------------------- */
/* AVX broadcast-mode                                                                             */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisBroadcastMode_
{
    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,
    ZYDIS_BROADCAST_MODE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_BROADCAST_MODE_MAX_VALUE)
} ZydisBroadcastMode;

/* ---------------------------------------------------------------------------------------------- */
/* AVX rounding-mode                                                                              */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisRoundingMode_
{
    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,
    ZYDIS_ROUNDING_MODE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_ROUNDING_MODE_MAX_VALUE)
} ZydisRoundingMode;

/* ---------------------------------------------------------------------------------------------- */
/* KNC swizzle-mode                                                                               */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisSwizzleMode_
{
    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,
    ZYDIS_SWIZZLE_MODE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_SWIZZLE_MODE_MAX_VALUE)
} ZydisSwizzleMode;

/* ---------------------------------------------------------------------------------------------- */
/* KNC conversion-mode                                                                            */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisConversionMode_
{
    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,
    ZYDIS_CONVERSION_MODE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_CONVERSION_MODE_MAX_VALUE)
} ZydisConversionMode;

/* ---------------------------------------------------------------------------------------------- */
/* Legacy prefix type                                                                             */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisPrefixType_
{
    ZYDIS_PREFIX_TYPE_IGNORED,
    ZYDIS_PREFIX_TYPE_EFFECTIVE,
    ZYDIS_PREFIX_TYPE_MANDATORY,

    ZYDIS_PREFIX_TYPE_MAX_VALUE = ZYDIS_PREFIX_TYPE_MANDATORY,
    ZYDIS_PREFIX_TYPE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_PREFIX_TYPE_MAX_VALUE)
} ZydisPrefixType;

// TODO: Check effective for 66/67 prefixes (currently defaults to EFFECTIVE)

/* ---------------------------------------------------------------------------------------------- */
/* Decoded instruction                                                                            */
/* ---------------------------------------------------------------------------------------------- */

typedef struct ZydisDecodedInstruction_
{
    ZydisMachineMode machine_mode;
    ZydisMnemonic mnemonic;
    ZyanU8 length;
    ZydisInstructionEncoding encoding;
    ZydisOpcodeMap opcode_map;
    ZyanU8 opcode;
    ZyanU8 stack_width;
    ZyanU8 operand_width;
    ZyanU8 address_width;
    ZyanU8 operand_count;
    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
    ZydisInstructionAttributes attributes;
    struct ZydisDecodedInstructionAccessedFlags_
    {
        ZydisCPUFlagAction action;
    } accessed_flags[ZYDIS_CPUFLAG_MAX_VALUE + 1];
    struct ZydisDecodedInstructionAvx_
    {
        ZyanU16 vector_length;
        struct ZydisDecodedInstructionAvxMask_
        {
            ZydisMaskMode mode;
            ZydisRegister reg;
        } mask;
        struct ZydisDecodedInstructionAvxBroadcast_
        {
            ZyanBool is_static;
            ZydisBroadcastMode mode;
        } broadcast;
        struct ZydisDecodedInstructionAvxRounding_
        {
            ZydisRoundingMode mode;
        } rounding;
        struct ZydisDecodedInstructionAvxSwizzle_
        {
            ZydisSwizzleMode mode;
        } swizzle;
        struct ZydisDecodedInstructionAvxConversion_
        {
            ZydisConversionMode mode;
        } conversion;
        ZyanBool has_sae;
        ZyanBool has_eviction_hint;
        // TODO: publish EVEX tuple-type and MVEX functionality
    } avx;
    struct ZydisDecodedInstructionMeta_
    {
        ZydisInstructionCategory category;
        ZydisISASet isa_set;
        ZydisISAExt isa_ext;
        ZydisBranchType branch_type;
        ZydisExceptionClass exception_class;
    } meta;
    struct ZydisDecodedInstructionRaw_
    {
        ZyanU8 prefix_count;
        struct ZydisDecodedInstructionRawPrefixes_
        {
            ZydisPrefixType type;
            ZyanU8 value;
        } prefixes[ZYDIS_MAX_INSTRUCTION_LENGTH];
        struct ZydisDecodedInstructionRawRex_
        {
            ZyanU8 W;
            ZyanU8 R;
            ZyanU8 X;
            ZyanU8 B;
            ZyanU8 offset;
        } rex;
        struct ZydisDecodedInstructionRawXop_
        {
            ZyanU8 R;
            ZyanU8 X;
            ZyanU8 B;
            ZyanU8 m_mmmm;
            ZyanU8 W;
            ZyanU8 vvvv;
            ZyanU8 L;
            ZyanU8 pp;
            ZyanU8 offset;
        } xop;
        struct ZydisDecodedInstructionRawVex_
        {
            ZyanU8 R;
            ZyanU8 X;
            ZyanU8 B;
            ZyanU8 m_mmmm;
            ZyanU8 W;
            ZyanU8 vvvv;
            ZyanU8 L;
            ZyanU8 pp;
            ZyanU8 offset;
            ZyanU8 size;
        } vex;
        struct ZydisDecodedInstructionRawEvex_
        {
            ZyanU8 R;
            ZyanU8 X;
            ZyanU8 B;
            ZyanU8 R2;
            ZyanU8 mm;
            ZyanU8 W;
            ZyanU8 vvvv;
            ZyanU8 pp;
            ZyanU8 z;
            ZyanU8 L2;
            ZyanU8 L;
            ZyanU8 b;
            ZyanU8 V2;
            ZyanU8 aaa;
            ZyanU8 offset;
        } evex;
        struct ZydisDecodedInstructionRawMvex_
        {
            ZyanU8 R;
            ZyanU8 X;
            ZyanU8 B;
            ZyanU8 R2;
            ZyanU8 mmmm;
            ZyanU8 W;
            ZyanU8 vvvv;
            ZyanU8 pp;
            ZyanU8 E;
            ZyanU8 SSS;
            ZyanU8 V2;
            ZyanU8 kkk;
            ZyanU8 offset;
        } mvex;
        struct ZydisDecodedInstructionModRm_
        {
            ZyanU8 mod;
            ZyanU8 reg;
            ZyanU8 rm;
            ZyanU8 offset;
        } modrm;
        struct ZydisDecodedInstructionRawSib_
        {
            ZyanU8 scale;
            ZyanU8 index;
            ZyanU8 base;
            ZyanU8 offset;
        } sib;
        struct ZydisDecodedInstructionRawDisp_
        {
            ZyanI64 value;
            ZyanU8 size;
            // TODO: publish cd8 scale
            ZyanU8 offset;
        } disp;
        struct ZydisDecodedInstructionRawImm_
        {
            ZyanBool is_signed;
            ZyanBool is_relative;
            union ZydisDecodedInstructionRawImmValue_
            {
                ZyanU64 u;
                ZyanI64 s;
            } value;
            ZyanU8 size;
            ZyanU8 offset;
        } imm[2];
    } raw;
} ZydisDecodedInstruction;

/* ---------------------------------------------------------------------------------------------- */

/* ============================================================================================== */

#ifdef __cplusplus
}
#endif

#endif /* ZYDIS_INSTRUCTIONINFO_H */