Bugfixes and table changes

- Fixed decoding of `XOP` instructions
- Fixed handling of illegal `LOCK` prefixes for `XOP/VEX/EVEX/MVEX` instructions
- Significantly improved detection of bad register values
- Added SSE4a instructions (`EXTRQ`, `INSERTQ`, `MOVNTSD` and `MOVNTSS`)
- Added `VPOPCNTD`/`VPOPCNTQ` instructions with 128- and 256-bit vector-length
- Fixed exception-class of some `GFNI` instructions
- Fixed `RDRAND` and `RDSEED` instructions
- Fixed `SYSRET` instruction

include/Zydis/Defines.h

@@ -183,6 +183,11 @@
  */
 #define ZYDIS_UNUSED_PARAMETER(x) (void)(x)
 
+/**
+ * @brief   Intentional fallthrough.
+ */
+#define ZYDIS_FALLTHROUGH
+
 /**
  * @brief   Calculates the size of an array.
  */

include/Zydis/Generated/EnumISAExt.h

@@ -66,6 +66,8 @@ enum ZydisISAExts
     ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_128,
     ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_256,
     ZYDIS_ISA_EXT_AVX512_VPCLMULQDQ_512,
+    ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_128,
+    ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_256,
     ZYDIS_ISA_EXT_AVX512_VPOPCNTDQ_512,
     ZYDIS_ISA_EXT_AVXAES,
     ZYDIS_ISA_EXT_BMI1,

include/Zydis/Generated/EnumISASet.h

@@ -60,6 +60,7 @@ enum ZydisISASets
     ZYDIS_ISA_SET_SSE2,
     ZYDIS_ISA_SET_SSE3,
     ZYDIS_ISA_SET_SSE4,
+    ZYDIS_ISA_SET_SSE4A,
     ZYDIS_ISA_SET_SSSE3,
     ZYDIS_ISA_SET_SVM,
     ZYDIS_ISA_SET_TBM,

include/Zydis/Generated/EnumMnemonic.h

@@ -159,6 +159,7 @@ enum ZydisMnemonics
     ZYDIS_MNEMONIC_ENDBR64,
     ZYDIS_MNEMONIC_ENTER,
     ZYDIS_MNEMONIC_EXTRACTPS,
+    ZYDIS_MNEMONIC_EXTRQ,
     ZYDIS_MNEMONIC_F2XM1,
     ZYDIS_MNEMONIC_FABS,
     ZYDIS_MNEMONIC_FADD,
@@ -274,6 +275,7 @@ enum ZydisMnemonics
     ZYDIS_MNEMONIC_INSB,
     ZYDIS_MNEMONIC_INSD,
     ZYDIS_MNEMONIC_INSERTPS,
+    ZYDIS_MNEMONIC_INSERTQ,
     ZYDIS_MNEMONIC_INSW,
     ZYDIS_MNEMONIC_INT,
     ZYDIS_MNEMONIC_INT1,
@@ -439,6 +441,8 @@ enum ZydisMnemonics
     ZYDIS_MNEMONIC_MOVNTPD,
     ZYDIS_MNEMONIC_MOVNTPS,
     ZYDIS_MNEMONIC_MOVNTQ,
+    ZYDIS_MNEMONIC_MOVNTSD,
+    ZYDIS_MNEMONIC_MOVNTSS,
     ZYDIS_MNEMONIC_MOVQ,
     ZYDIS_MNEMONIC_MOVQ2DQ,
     ZYDIS_MNEMONIC_MOVSB,

include/Zydis/Internal/SharedData.h

@@ -189,6 +189,32 @@ enum ZydisImplicitMemBase
 /* Instruction definition                                                                         */
 /* ---------------------------------------------------------------------------------------------- */
 
+/**
+ * @brief   Defines the `ZydisRegisterConstraint` datatype.
+ */
+typedef ZydisU8 ZydisRegisterConstraint;
+
+/**
+ * @brief   Values that represent register-constraints.
+ */
+enum ZydisRegisterConstraints
+{
+    ZYDIS_REG_CONSTRAINTS_NONE,
+    ZYDIS_REG_CONSTRAINTS_UNUSED,
+    ZYDIS_REG_CONSTRAINTS_GPR,
+    ZYDIS_REG_CONSTRAINTS_SR_DEST,
+    ZYDIS_REG_CONSTRAINTS_SR,
+    ZYDIS_REG_CONSTRAINTS_CR,
+    ZYDIS_REG_CONSTRAINTS_DR,
+    ZYDIS_REG_CONSTRAINTS_MASK,
+    ZYDIS_REG_CONSTRAINTS_BND,
+
+    ZYDIS_REG_CONSTRAINTS_MAX_VALUE = ZYDIS_REG_CONSTRAINTS_BND,
+    ZYDIS_REG_CONSTRAINTS_MIN_BITS  = 4
+};
+
+/* ---------------------------------------------------------------------------------------------- */
+
 /**
  * @brief   Defines the @c ZydisInternalVectorLength datatype.
  */
@@ -559,30 +585,35 @@ enum ZydisMaskPolicies
     ZydisInstructionCategory category       ZYDIS_BITFIELD(ZYDIS_CATEGORY_MIN_BITS); \
     ZydisISASet isaSet                      ZYDIS_BITFIELD(ZYDIS_ISA_SET_MIN_BITS); \
     ZydisISAExt isaExt                      ZYDIS_BITFIELD(ZYDIS_ISA_EXT_MIN_BITS); \
-    ZydisExceptionClass exceptionClass      ZYDIS_BITFIELD( 6)
+    ZydisExceptionClass exceptionClass      ZYDIS_BITFIELD( 6); \
+    ZydisRegisterConstraint constrREG       ZYDIS_BITFIELD(ZYDIS_REG_CONSTRAINTS_MIN_BITS); \
+    ZydisRegisterConstraint constrRM        ZYDIS_BITFIELD(ZYDIS_REG_CONSTRAINTS_MIN_BITS)
 
 #define ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR \
     ZYDIS_INSTRUCTION_DEFINITION_BASE; \
-    ZydisBool hasNDSNDDOperand              ZYDIS_BITFIELD( 1)
+    ZydisRegisterConstraint constrNDSNDD    ZYDIS_BITFIELD(ZYDIS_REG_CONSTRAINTS_MIN_BITS)
 
 #define ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR_EX \
     ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR; \
     ZydisBool hasVSIB                       ZYDIS_BITFIELD( 1)
 
 /**
- * @brief   Defines the @c ZydisInstructionDefinition struct.
+ * @brief   Defines the `ZydisInstructionDefinition` struct.
  */
 typedef struct ZydisInstructionDefinition_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE;
 } ZydisInstructionDefinition;
 
+/**
+ * @brief   Defines the `ZydisInstructionDefinitionDEFAULT` struct.
+ */
 typedef struct ZydisInstructionDefinitionDEFAULT_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE;
     ZydisBool isPrivileged                  ZYDIS_BITFIELD( 1);
     ZydisBool isFarBranch                   ZYDIS_BITFIELD( 1);
-    ZydisBool acceptsLock                   ZYDIS_BITFIELD( 1);
+    ZydisBool acceptsLOCK                   ZYDIS_BITFIELD( 1);
     ZydisBool acceptsREP                    ZYDIS_BITFIELD( 1);
     ZydisBool acceptsREPEREPZ               ZYDIS_BITFIELD( 1);
     ZydisBool acceptsREPNEREPNZ             ZYDIS_BITFIELD( 1);
@@ -594,16 +625,25 @@ typedef struct ZydisInstructionDefinitionDEFAULT_
     ZydisBool acceptsSegment                ZYDIS_BITFIELD( 1);
 } ZydisInstructionDefinitionDEFAULT;
 
+/**
+ * @brief   Defines the `ZydisInstructionDefinition3DNOW` struct.
+ */
 typedef struct ZydisInstructionDefinition3DNOW_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE;
 } ZydisInstructionDefinition3DNOW;
 
+/**
+ * @brief   Defines the `ZydisInstructionDefinitionXOP` struct.
+ */
 typedef struct ZydisInstructionDefinitionXOP_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR;
 } ZydisInstructionDefinitionXOP;
 
+/**
+ * @brief   Defines the `ZydisInstructionDefinitionVEX` struct.
+ */
 typedef struct ZydisInstructionDefinitionVEX_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR;
@@ -611,6 +651,9 @@ typedef struct ZydisInstructionDefinitionVEX_
 } ZydisInstructionDefinitionVEX;
 
 #ifndef ZYDIS_DISABLE_EVEX
+/**
+ * @brief   Defines the `ZydisInstructionDefinitionEVEX` struct.
+ */
 typedef struct ZydisInstructionDefinitionEVEX_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR_EX;
@@ -626,6 +669,9 @@ typedef struct ZydisInstructionDefinitionEVEX_
 #endif
 
 #ifndef ZYDIS_DISABLE_MVEX
+/**
+ * @brief   Defines the `ZydisInstructionDefinitionMVEX` struct.
+ */
 typedef struct ZydisInstructionDefinitionMVEX_
 {
     ZYDIS_INSTRUCTION_DEFINITION_BASE_VECTOR_EX;

src/Decoder.c

@@ -2083,7 +2083,7 @@ static void ZydisSetAttributes(ZydisDecoderContext* context, ZydisDecodedInstruc
                          (instruction->meta.category == ZYDIS_CATEGORY_RET));
             instruction->attributes |= ZYDIS_ATTRIB_IS_FAR_BRANCH;
         }
-        if (def->acceptsLock)
+        if (def->acceptsLOCK)
         {
             instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_LOCK;
             if (instruction->raw.prefixes.hasF0)
@@ -3446,7 +3446,7 @@ static ZydisStatus ZydisNodeHandlerXOP(ZydisDecodedInstruction* instruction, Zyd
         break;
     case ZYDIS_INSTRUCTION_ENCODING_XOP:
         ZYDIS_ASSERT(instruction->raw.xop.isDecoded);
-        *index = (instruction->raw.xop.m_mmmm - 0x08) + 1;
+        *index = (instruction->raw.xop.m_mmmm - 0x08) + (instruction->raw.xop.pp * 3) + 1;
         break;
     default:
         ZYDIS_UNREACHABLE;
@@ -3531,6 +3531,10 @@ static ZydisStatus ZydisNodeHandlerOpcode(ZydisDecoderContext* context,
                     {
                         return ZYDIS_STATUS_ILLEGAL_REX;
                     }
+                    if (instruction->raw.prefixes.hasF0)
+                    {
+                        return ZYDIS_STATUS_ILLEGAL_LOCK;
+                    }
                     if (context->mandatoryCandidate)
                     {
                         return ZYDIS_STATUS_ILLEGAL_LEGACY_PFX;
@@ -3629,6 +3633,10 @@ static ZydisStatus ZydisNodeHandlerOpcode(ZydisDecoderContext* context,
                     {
                         return ZYDIS_STATUS_ILLEGAL_REX;
                     }
+                    if (instruction->raw.prefixes.hasF0)
+                    {
+                        return ZYDIS_STATUS_ILLEGAL_LOCK;
+                    }
                     if (context->mandatoryCandidate)
                     {
                         return ZYDIS_STATUS_ILLEGAL_LEGACY_PFX;
@@ -4003,8 +4011,9 @@ static ZydisStatus ZydisNodeHandlerMvexE(ZydisDecodedInstruction* instruction, Z
 static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context, 
     ZydisDecodedInstruction* instruction, const ZydisInstructionDefinition* definition)
 {
-    ZydisBool acceptsLock = ZYDIS_FALSE;
+    const ZydisRegisterConstraint constrREG = definition->constrREG;
-    ZydisBool hasNDSNDDOperand = ZYDIS_FALSE;
+    const ZydisRegisterConstraint constrRM  = definition->constrRM;
+    ZydisRegisterConstraint constrNDSNDD = ZYDIS_REG_CONSTRAINTS_NONE;
     ZydisBool hasVSIB = ZYDIS_FALSE;
 #if !defined(ZYDIS_DISABLE_EVEX) || !defined(ZYDIS_DISABLE_MVEX)
     ZydisMaskPolicy maskPolicy = ZYDIS_MASK_POLICY_INVALID;
@@ -4015,12 +4024,17 @@ static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context,
     {
         const ZydisInstructionDefinitionDEFAULT* def = 
             (const ZydisInstructionDefinitionDEFAULT*)definition;
+
         if (def->requiresProtectedMode && 
             (context->decoder->machineMode == ZYDIS_MACHINE_MODE_REAL_16))
         {
             return ZYDIS_STATUS_DECODING_ERROR;
         }
-        acceptsLock = def->acceptsLock;
+
+        if (instruction->raw.prefixes.hasF0 && !def->acceptsLOCK)
+        {
+            return ZYDIS_STATUS_ILLEGAL_LOCK;
+        }
         break;
     }
     case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
@@ -4031,14 +4045,14 @@ static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context,
     {
         const ZydisInstructionDefinitionXOP* def = 
             (const ZydisInstructionDefinitionXOP*)definition;
-        hasNDSNDDOperand = def->hasNDSNDDOperand;
+        constrNDSNDD = def->constrNDSNDD;
         break;
     }
     case ZYDIS_INSTRUCTION_ENCODING_VEX:
     {
         const ZydisInstructionDefinitionVEX* def = 
             (const ZydisInstructionDefinitionVEX*)definition;
-        hasNDSNDDOperand = def->hasNDSNDDOperand;
+        constrNDSNDD = def->constrNDSNDD;
         break;
     }
     case ZYDIS_INSTRUCTION_ENCODING_EVEX:
@@ -4046,7 +4060,7 @@ static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context,
 #ifndef ZYDIS_DISABLE_EVEX
         const ZydisInstructionDefinitionEVEX* def = 
             (const ZydisInstructionDefinitionEVEX*)definition;
-        hasNDSNDDOperand = def->hasNDSNDDOperand;
+        constrNDSNDD = def->constrNDSNDD;
         hasVSIB = def->hasVSIB;
         maskPolicy = def->maskPolicy;
 
@@ -4065,7 +4079,7 @@ static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context,
 #ifndef ZYDIS_DISABLE_MVEX
         const ZydisInstructionDefinitionMVEX* def = 
             (const ZydisInstructionDefinitionMVEX*)definition;
-        hasNDSNDDOperand = def->hasNDSNDDOperand;
+        constrNDSNDD = def->constrNDSNDD;
         hasVSIB = def->hasVSIB;
         maskPolicy = def->maskPolicy;
 
@@ -4140,22 +4154,139 @@ static ZydisStatus ZydisCheckErrorConditions(ZydisDecoderContext* context,
         ZYDIS_UNREACHABLE;
     }
 
-    // Check for illegal LOCK-prefix
+    // Validate register constraints
-    if (instruction->raw.prefixes.hasF0 && !acceptsLock)
+    switch (constrREG)
     {
-        return ZYDIS_STATUS_ILLEGAL_LOCK;
+    case ZYDIS_REG_CONSTRAINTS_NONE:
+    case ZYDIS_REG_CONSTRAINTS_UNUSED:
+        break;
+    case ZYDIS_REG_CONSTRAINTS_GPR:
+        if (context->cache.R2)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    case ZYDIS_REG_CONSTRAINTS_SR_DEST:
+        // `ZYDIS_REGISTER_CR` is not allowed as `MOV` target
+        if (instruction->raw.modrm.reg == 1)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        ZYDIS_FALLTHROUGH;
+    case ZYDIS_REG_CONSTRAINTS_SR:
+    {
+        if (instruction->raw.modrm.reg > 6)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break; 
     }
-
+    case ZYDIS_REG_CONSTRAINTS_CR:
-    // Check for invalid `XOP/VEX/EVEX/MVEX.vvvv` value
-    if (!hasNDSNDDOperand && (context->cache.v_vvvv & 0x0F))
     {
-        return ZYDIS_STATUS_DECODING_ERROR;
+        // Attempts to reference CR1, CR5, CR6, CR7, and CR9–CR15 result in undefined opcode (#UD) 
+        // exceptions.
+        const ZydisU8 value = instruction->raw.modrm.reg | (context->cache.R << 3);
+        static const ZydisU8 lookup[16] =
+        {
+            1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0
+        };
+        ZYDIS_ASSERT(value < ZYDIS_ARRAY_SIZE(lookup));
+        if (!lookup[value])
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break; 
     }
-
+    case ZYDIS_REG_CONSTRAINTS_DR:
-    // Check for invalid `EVEX/MVEX.v'` value
+        // Attempts to reference DR8–DR15 result in undefined opcode (#UD) exceptions. DR4 and DR5
-    if (!hasNDSNDDOperand && !hasVSIB && context->cache.V2)
+        // are only valid, if the debug extension (DE) flag in CR4 is set. As we can't check this,
+        // we just allow them.
+        if (context->cache.R)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break; 
+    case ZYDIS_REG_CONSTRAINTS_MASK:
+        // TODO: ZYDIS_ASSERT(!context->cache.R2) ?
+        if (context->cache.R || context->cache.R2)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    case ZYDIS_REG_CONSTRAINTS_BND:
+        ZYDIS_ASSERT(!context->cache.R2);
+        if (context->cache.R || instruction->raw.modrm.reg > 3)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    default:
+        ZYDIS_UNREACHABLE;
+    }
+    switch (constrRM)
     {
-        return ZYDIS_STATUS_DECODING_ERROR;
+    case ZYDIS_REG_CONSTRAINTS_NONE:
+    case ZYDIS_REG_CONSTRAINTS_UNUSED:
+        break;
+    case ZYDIS_REG_CONSTRAINTS_SR_DEST:
+        // `ZYDIS_REGISTER_CR` is not allowed as `MOV` target
+        if (instruction->raw.modrm.rm == 1)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        ZYDIS_FALLTHROUGH;
+    case ZYDIS_REG_CONSTRAINTS_SR:
+    {
+        if (instruction->raw.modrm.rm > 6)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break; 
+    }
+    case ZYDIS_REG_CONSTRAINTS_MASK:
+        // TODO: `.X`?
+        break;
+    case ZYDIS_REG_CONSTRAINTS_BND:
+        ZYDIS_ASSERT(!context->cache.X);
+        if (context->cache.B || instruction->raw.modrm.rm > 3)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    default:
+        ZYDIS_UNREACHABLE;
+    }
+    switch (constrNDSNDD)
+    {
+    case ZYDIS_REG_CONSTRAINTS_NONE:
+        break;
+    case ZYDIS_REG_CONSTRAINTS_UNUSED:
+        // `.vvvv` is not allowed, if the instruction does not encode a NDS/NDD operand
+        if (context->cache.v_vvvv & 0x0F)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        // `.v'` is not allowed, if the instruction does not encode a NDS/NDD or VSIB operand
+        if (!hasVSIB && context->cache.V2)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    case ZYDIS_REG_CONSTRAINTS_GPR:
+        // `.v'` is invalid for GPR-registers
+        if (context->cache.V2)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    case ZYDIS_REG_CONSTRAINTS_MASK:
+        if (context->cache.v_vvvv > 7)
+        {
+            return ZYDIS_STATUS_BAD_REGISTER;
+        }
+        break;
+    default:
+        ZYDIS_UNREACHABLE;
     }
 
 #if !defined(ZYDIS_DISABLE_EVEX) || !defined(ZYDIS_DISABLE_MVEX)

src/DecoderData.c

@@ -38,12 +38,21 @@
  * @brief   Contains all XOP-map filters.
  *          
  *          Index values:
- *          0 = POP instruction (default encoding)
+ *          00 = POP instruction (default encoding)
- *          1 = xop8
+ *          01 = XOP8
- *          2 = xop9
+ *          02 = XOP9
- *          3 = xopA
+ *          03 = XOPA
+ *          04 = 66_XOP8
+ *          05 = 66_XOP9
+ *          06 = 66_XOPA
+ *          07 = F3_XOP8
+ *          08 = F3_XOP9
+ *          09 = F3_XOPA
+ *          0A = F2_XOP8
+ *          0B = F2_XOP9
+ *          0C = F2_XOPA
  */
-extern const ZydisDecoderTreeNode filtersXOP[][4];
+extern const ZydisDecoderTreeNode filtersXOP[][13];
 
 /**
  * @brief   Contains all VEX-map filters.
@@ -284,7 +293,7 @@ const ZydisDecoderTreeNode* ZydisDecoderTreeGetChildNode(const ZydisDecoderTreeN
     switch (parent->type)
     {
     case ZYDIS_NODETYPE_FILTER_XOP:
-        ZYDIS_ASSERT(index <   4);
+        ZYDIS_ASSERT(index <  13);
         return &filtersXOP[parent->value][index];
     case ZYDIS_NODETYPE_FILTER_VEX:
         ZYDIS_ASSERT(index <  17);

src/Generated/EnumISAExt.inc

@@ -58,6 +58,8 @@ static const char* zydisISAExtStrings[] =
     "AVX512_VPCLMULQDQ_128",
     "AVX512_VPCLMULQDQ_256",
     "AVX512_VPCLMULQDQ_512",
+    "AVX512_VPOPCNTDQ_128",
+    "AVX512_VPOPCNTDQ_256",
     "AVX512_VPOPCNTDQ_512",
     "AVXAES",
     "BMI1",

src/Generated/EnumISASet.inc

@@ -52,6 +52,7 @@ static const char* zydisISASetStrings[] =
     "SSE2",
     "SSE3",
     "SSE4",
+    "SSE4a",
     "SSSE3",
     "SVM",
     "TBM",

src/Generated/EnumMnemonic.inc

@@ -151,6 +151,7 @@ static const ZydisStaticString zydisMnemonicStrings[] =
     ZYDIS_MAKE_STATIC_STRING("endbr64"),
     ZYDIS_MAKE_STATIC_STRING("enter"),
     ZYDIS_MAKE_STATIC_STRING("extractps"),
+    ZYDIS_MAKE_STATIC_STRING("extrq"),
     ZYDIS_MAKE_STATIC_STRING("f2xm1"),
     ZYDIS_MAKE_STATIC_STRING("fabs"),
     ZYDIS_MAKE_STATIC_STRING("fadd"),
@@ -266,6 +267,7 @@ static const ZydisStaticString zydisMnemonicStrings[] =
     ZYDIS_MAKE_STATIC_STRING("insb"),
     ZYDIS_MAKE_STATIC_STRING("insd"),
     ZYDIS_MAKE_STATIC_STRING("insertps"),
+    ZYDIS_MAKE_STATIC_STRING("insertq"),
     ZYDIS_MAKE_STATIC_STRING("insw"),
     ZYDIS_MAKE_STATIC_STRING("int"),
     ZYDIS_MAKE_STATIC_STRING("int1"),
@@ -431,6 +433,8 @@ static const ZydisStaticString zydisMnemonicStrings[] =
     ZYDIS_MAKE_STATIC_STRING("movntpd"),
     ZYDIS_MAKE_STATIC_STRING("movntps"),
     ZYDIS_MAKE_STATIC_STRING("movntq"),
+    ZYDIS_MAKE_STATIC_STRING("movntsd"),
+    ZYDIS_MAKE_STATIC_STRING("movntss"),
     ZYDIS_MAKE_STATIC_STRING("movq"),
     ZYDIS_MAKE_STATIC_STRING("movq2dq"),
     ZYDIS_MAKE_STATIC_STRING("movsb"),

src/Generated/InstructionEncodings.inc

@@ -18,5 +18,6 @@ static const ZydisInstructionEncodingInfo instructionEncodings[] =
     { ZYDIS_INSTR_ENC_FLAG_HAS_MODRM | ZYDIS_INSTR_ENC_FLAG_HAS_IMM0, { { 0, 0, 0 } }, { { { 16, 32, 32 }, ZYDIS_TRUE, ZYDIS_TRUE }, { { 0, 0, 0 }, ZYDIS_FALSE, ZYDIS_FALSE } } }, 
     { ZYDIS_INSTR_ENC_FLAG_HAS_MODRM | ZYDIS_INSTR_ENC_FLAG_FORCE_REG_FORM, { { 0, 0, 0 } }, { { { 0, 0, 0 }, ZYDIS_FALSE, ZYDIS_FALSE }, { { 0, 0, 0 }, ZYDIS_FALSE, ZYDIS_FALSE } } }, 
     { ZYDIS_INSTR_ENC_FLAG_HAS_IMM0 | ZYDIS_INSTR_ENC_FLAG_HAS_IMM1, { { 0, 0, 0 } }, { { { 16, 16, 16 }, ZYDIS_FALSE, ZYDIS_FALSE }, { { 8, 8, 8 }, ZYDIS_FALSE, ZYDIS_FALSE } } }, 
-    { ZYDIS_INSTR_ENC_FLAG_HAS_IMM0 | ZYDIS_INSTR_ENC_FLAG_HAS_IMM1, { { 0, 0, 0 } }, { { { 16, 32, 32 }, ZYDIS_TRUE, ZYDIS_TRUE }, { { 16, 16, 16 }, ZYDIS_FALSE, ZYDIS_FALSE } } }
+    { ZYDIS_INSTR_ENC_FLAG_HAS_IMM0 | ZYDIS_INSTR_ENC_FLAG_HAS_IMM1, { { 0, 0, 0 } }, { { { 16, 32, 32 }, ZYDIS_TRUE, ZYDIS_TRUE }, { { 16, 16, 16 }, ZYDIS_FALSE, ZYDIS_FALSE } } }, 
+    { ZYDIS_INSTR_ENC_FLAG_HAS_MODRM | ZYDIS_INSTR_ENC_FLAG_HAS_IMM0 | ZYDIS_INSTR_ENC_FLAG_HAS_IMM1, { { 0, 0, 0 } }, { { { 8, 8, 8 }, ZYDIS_FALSE, ZYDIS_FALSE }, { { 8, 8, 8 }, ZYDIS_FALSE, ZYDIS_FALSE } } }
 };

src/Generated/OperandDefinitions.inc

@@ -1210,6 +1210,10 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_DX } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ_CONDWRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_GPR_ASZ, { .id = 0x1 } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_MEM, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_CONDWRITE, { 2, 2, 2 }, ZYDIS_IELEMENT_TYPE_INT16, { .mem = { 1, ZYDIS_IMPLMEM_BASE_ADI } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_DX } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ_CONDWRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_GPR_ASZ, { .id = 0x1 } } } }, 
@@ -2935,6 +2939,9 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 4, 4, 4 }, ZYDIS_IELEMENT_TYPE_INT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_FLOAT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_IMPLICIT, ZYDIS_OPERAND_ACTION_READWRITE, { 10, 10, 10 }, ZYDIS_IELEMENT_TYPE_FLOAT80, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_ST0 } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_FPR, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 10, 10, 10 }, ZYDIS_IELEMENT_TYPE_FLOAT80, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
@@ -3422,9 +3429,6 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_FLOAT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 1, 1, 1 }, ZYDIS_IELEMENT_TYPE_UINT8, { .encoding = ZYDIS_OPERAND_ENCODING_UIMM8 } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 4, 4, 4 }, ZYDIS_IELEMENT_TYPE_INT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
@@ -5643,6 +5647,8 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READWRITE, { 2, 4, 8 }, ZYDIS_IELEMENT_TYPE_INT, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_INT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READWRITE, { 10, 10, 10 }, ZYDIS_IELEMENT_TYPE_FLOAT80, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_ST0 } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 10, 10, 10 }, ZYDIS_IELEMENT_TYPE_FLOAT80, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_ST0 } } } }, 
@@ -5821,6 +5827,8 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_FLOAT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_GPR64, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
@@ -5833,8 +5841,6 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_GPR64, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MMX, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_INT32, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
@@ -6073,10 +6079,10 @@ const ZydisOperandDefinition operandDefinitions[] =
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_TR } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_MEM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_WRITE, { 2, 2, 2 }, ZYDIS_IELEMENT_TYPE_INT16, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_READ, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_TR } } } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_EIP } } } }, 
-    { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_RIP } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_STATIC, { .reg = ZYDIS_REGISTER_EIP } } } }, 
+    { ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG, ZYDIS_OPERAND_VISIBILITY_HIDDEN, ZYDIS_OPERAND_ACTION_WRITE, { 0, 0, 0 }, ZYDIS_IELEMENT_TYPE_INVALID, { .reg = { ZYDIS_IMPLREG_TYPE_FLAGS_SSZ, { .id = 0x3F } } } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READWRITE, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_FLOAT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READ, { 8, 8, 8 }, ZYDIS_IELEMENT_TYPE_INT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_RM } }, 
     { ZYDIS_SEMANTIC_OPTYPE_XMM, ZYDIS_OPERAND_VISIBILITY_EXPLICIT, ZYDIS_OPERAND_ACTION_READWRITE, { 16, 16, 16 }, ZYDIS_IELEMENT_TYPE_FLOAT64, { .encoding = ZYDIS_OPERAND_ENCODING_MODRM_REG } },