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                                                                                */
/* ============================================================================================== */

/* ---------------------------------------------------------------------------------------------- */
/* Operand attributes                                                                             */
/* ---------------------------------------------------------------------------------------------- */

typedef ZyanU8 ZydisOperandAttributes;

#define ZYDIS_OATTRIB_IS_MULTISOURCE4   0x01 // (1 <<  0)

/* ---------------------------------------------------------------------------------------------- */
/* Memory type                                                                                    */
/* ---------------------------------------------------------------------------------------------- */

typedef enum ZydisMemoryOperandType_
{
    ZYDIS_MEMOP_TYPE_INVALID,
    ZYDIS_MEMOP_TYPE_MEM,
    ZYDIS_MEMOP_TYPE_AGEN,
    ZYDIS_MEMOP_TYPE_MIB,
    ZYDIS_MEMOP_TYPE_VSIB,

    ZYDIS_MEMOP_TYPE_MAX_VALUE = ZYDIS_MEMOP_TYPE_VSIB,
    ZYDIS_MEMOP_TYPE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_MEMOP_TYPE_MAX_VALUE)
} ZydisMemoryOperandType;

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

typedef struct ZydisDecodedOperandReg_
{
    ZydisRegister value;
} ZydisDecodedOperandReg;

typedef struct ZydisDecodedOperandMem_
{
    ZydisMemoryOperandType type;
    ZydisRegister segment;
    ZydisRegister base;
    ZydisRegister index;
    ZyanU8 scale;
    struct ZydisDecodedOperandMemDisp_
    {
        ZyanBool has_displacement;
        ZyanI64 value;
    } disp;
} ZydisDecodedOperandMem;

typedef struct ZydisDecodedOperandPtr_
{
    ZyanU16 segment;
    ZyanU32 offset;
} ZydisDecodedOperandPtr;

typedef struct ZydisDecodedOperandImm_
{
    ZyanBool is_signed;
    ZyanBool is_relative;
    union ZydisDecodedOperandImmValue_
    {
        ZyanU64 u;
        ZyanI64 s;
    } value;
} ZydisDecodedOperandImm;

typedef struct ZydisDecodedOperand_
{
    ZyanU8 id;
    ZydisOperandVisibility visibility;
    ZydisOperandActions actions;
    ZydisOperandEncoding encoding;
    ZyanU16 size;
    ZydisElementType element_type;
    ZydisElementSize element_size;
    ZyanU16 element_count;
    /*
     * Additional operand attributes.
     */
    ZydisOperandAttributes attributes;
    ZydisOperandType type;
    /*
     * Operand type specific information.
     *
     * The enabled union variant is determined by the `type` field.
     */
    union
    {
        ZydisDecodedOperandReg reg;
        ZydisDecodedOperandMem mem;
        ZydisDecodedOperandPtr ptr;
        ZydisDecodedOperandImm imm;
    };
} ZydisDecodedOperand;

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

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

/* ---------------------------------------------------------------------------------------------- */
/* CPU/FPU flags                                                                                  */
/* ---------------------------------------------------------------------------------------------- */

typedef ZyanU32 ZydisAccessedFlagsMask;

#define ZYDIS_CPUFLAG_CF    (1ul <<  0)

#define ZYDIS_CPUFLAG_PF    (1ul <<  2)

#define ZYDIS_CPUFLAG_AF    (1ul <<  4)

#define ZYDIS_CPUFLAG_ZF    (1ul <<  6)

#define ZYDIS_CPUFLAG_SF    (1ul <<  7)

#define ZYDIS_CPUFLAG_TF    (1ul <<  8)

#define ZYDIS_CPUFLAG_IF    (1ul <<  9)

#define ZYDIS_CPUFLAG_DF    (1ul << 10)

#define ZYDIS_CPUFLAG_OF    (1ul << 11)

#define ZYDIS_CPUFLAG_IOPL  (1ul << 12)

#define ZYDIS_CPUFLAG_NT    (1ul << 14)

#define ZYDIS_CPUFLAG_RF    (1ul << 16)

#define ZYDIS_CPUFLAG_VM    (1ul << 17)

#define ZYDIS_CPUFLAG_AC    (1ul << 18)

#define ZYDIS_CPUFLAG_VIF   (1ul << 19)

#define ZYDIS_CPUFLAG_VIP   (1ul << 20)

#define ZYDIS_CPUFLAG_ID    (1ul << 21)

#define ZYDIS_FPUFLAG_C0    (1ul <<  0)

#define ZYDIS_FPUFLAG_C1    (1ul <<  1)

#define ZYDIS_FPUFLAG_C2    (1ul <<  2)

#define ZYDIS_FPUFLAG_C3    (1ul <<  3)

/*
 * Information about CPU/FPU flags accessed by the instruction.
 */
typedef struct ZydisAccessedFlags_
{
    /*
     * As mask containing the flags `TESTED` by the instruction.
     */
    ZydisAccessedFlagsMask tested;
    /*
     * As mask containing the flags `MODIFIED` by the instruction.
     */
    ZydisAccessedFlagsMask modified;
    /*
     * As mask containing the flags `SET_0` by the instruction.
     */
    ZydisAccessedFlagsMask set_0;
    /*
     * As mask containing the flags `SET_1` by the instruction.
     */
    ZydisAccessedFlagsMask set_1;
    /*
     * As mask containing the flags `UNDEFINED` by the instruction.
     */
    ZydisAccessedFlagsMask undefined;
} ZydisAccessedFlags;

/* ---------------------------------------------------------------------------------------------- */
/* 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_AMXE1,
    ZYDIS_EXCEPTION_CLASS_AMXE2,
    ZYDIS_EXCEPTION_CLASS_AMXE3,
    ZYDIS_EXCEPTION_CLASS_AMXE4,
    ZYDIS_EXCEPTION_CLASS_AMXE5,
    ZYDIS_EXCEPTION_CLASS_AMXE6,

    ZYDIS_EXCEPTION_CLASS_MAX_VALUE = ZYDIS_EXCEPTION_CLASS_AMXE6,
    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 ZydisDecodedInstructionRawRex_
{
    ZyanU8 W;
    ZyanU8 R;
    ZyanU8 X;
    ZyanU8 B;
    ZyanU8 offset;
} ZydisDecodedInstructionRawRex;

typedef struct ZydisDecodedInstructionRawXop_
{
    ZyanU8 R;
    ZyanU8 X;
    ZyanU8 B;
    ZyanU8 m_mmmm;
    ZyanU8 W;
    ZyanU8 vvvv;
    ZyanU8 L;
    ZyanU8 pp;
    ZyanU8 offset;
} ZydisDecodedInstructionRawXop;

typedef struct ZydisDecodedInstructionRawVex_
{
    ZyanU8 R;
    ZyanU8 X;
    ZyanU8 B;
    ZyanU8 m_mmmm;
    ZyanU8 W;
    ZyanU8 vvvv;
    ZyanU8 L;
    ZyanU8 pp;
    ZyanU8 offset;
    ZyanU8 size;
} ZydisDecodedInstructionRawVex;

typedef struct ZydisDecodedInstructionRawEvex
{
    ZyanU8 R;
    ZyanU8 X;
    ZyanU8 B;
    ZyanU8 R2;
    ZyanU8 mmm;
    ZyanU8 W;
    ZyanU8 vvvv;
    ZyanU8 pp;
    ZyanU8 z;
    ZyanU8 L2;
    ZyanU8 L;
    ZyanU8 b;
    ZyanU8 V2;
    ZyanU8 aaa;
    ZyanU8 offset;
} ZydisDecodedInstructionRawEvex;

typedef 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;
} ZydisDecodedInstructionRawMvex;

typedef 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
} ZydisDecodedInstructionAvx;

typedef struct ZydisDecodedInstructionMeta_
{
    ZydisInstructionCategory category;
    ZydisISASet isa_set;
    ZydisISAExt isa_ext;
    ZydisBranchType branch_type;
    ZydisExceptionClass exception_class;
} ZydisDecodedInstructionMeta;

typedef struct ZydisDecodedInstructionRaw_
{
    ZyanU8 prefix_count;
    struct ZydisDecodedInstructionRawPrefixes_
    {
        ZydisPrefixType type;
        ZyanU8 value;
    } prefixes[ZYDIS_MAX_INSTRUCTION_LENGTH];

    /*
     * Copy of the `encoding` field.
     *
     * This is here to allow the Rust bindings to treat the following union as an `enum`,
     * sparing us a lot of unsafe code. Prefer using the regular `encoding` field in C/C++ code.
     */
    ZydisInstructionEncoding encoding2;
    /*
     * Union for things from various mutually exclusive encodings.
     */
    union
    {
        ZydisDecodedInstructionRawRex rex;
        ZydisDecodedInstructionRawXop xop;
        ZydisDecodedInstructionRawVex vex;
        ZydisDecodedInstructionRawEvex evex;
        ZydisDecodedInstructionRawMvex 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];
} ZydisDecodedInstructionRaw;

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;
    ZyanU8 operand_count_visible;
    ZydisInstructionAttributes attributes;
    const ZydisAccessedFlags* cpu_flags;
    const ZydisAccessedFlags* fpu_flags;
    ZydisDecodedInstructionAvx avx;
    ZydisDecodedInstructionMeta meta;
    ZydisDecodedInstructionRaw raw;
} ZydisDecodedInstruction;

/* ---------------------------------------------------------------------------------------------- */
/* Decoder context                                                                                */
/* ---------------------------------------------------------------------------------------------- */

typedef struct ZydisDecoderContext_
{
    const void* definition;
    ZyanU8 eosz_index;
    ZyanU8 easz_index;
    struct
    {
        ZyanU8 W;
        ZyanU8 R;
        ZyanU8 X;
        ZyanU8 B;
        ZyanU8 L;
        ZyanU8 LL;
        ZyanU8 R2;
        ZyanU8 V2;
        ZyanU8 vvvv;
        ZyanU8 mask;
    } vector_unified;
    struct
    {
        ZyanBool is_mod_reg;
        ZyanU8 id_reg;
        ZyanU8 id_rm;
        ZyanU8 id_ndsndd;
        ZyanU8 id_base;
        ZyanU8 id_index;
    } reg_info;
    struct
    {
        ZyanU8 tuple_type;
        ZyanU8 element_size;
    } evex;
    struct
    {
        ZyanU8 functionality;
    } mvex;
    ZyanU8 cd8_scale; // TODO: Could make sense to expose this in the ZydisDecodedInstruction
} ZydisDecoderContext;

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

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

#ifdef __cplusplus
}
#endif

#endif /* ZYDIS_INSTRUCTIONINFO_H */