Supported several extra x86 instructions.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@182 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

16 files changed, 1636 insertions, 25 deletions

diff --git a/src/arch/x86/instruction.c b/src/arch/x86/instruction.c
index af1d25e..f5901ef 100644
--- a/src/arch/x86/instruction.c
+++ b/src/arch/x86/instruction.c
@@ -137,7 +137,7 @@ static x86_instruction _instructions[XOP_COUNT] = {
 
     [XOP_CMP_RM8_R8]                = { false, 0x38, IDX_TO_EXT(-1), "cmp", XPX_NONE },
     [XOP_CMP_RM1632_R1632]          = { false, 0x39, IDX_TO_EXT(-1), "cmp", XPX_OPERAND_SIZE_OVERRIDE },
-
+    [XOP_CMP_R8_RM8]                = { false, 0x3a, IDX_TO_EXT(-1), "cmp", XPX_NONE },
     [XOP_CMP_R1632_RM1632]          = { false, 0x3b, IDX_TO_EXT(-1), "cmp", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_CMP_AL_IMM8]               = { false, 0x3c, IDX_TO_EXT(-1), "cmp", XPX_NONE },
     [XOP_CMP_E_AX_IMM1632]          = { false, 0x3d, IDX_TO_EXT(-1), "cmp", XPX_OPERAND_SIZE_OVERRIDE },
@@ -291,9 +291,14 @@ static x86_instruction _instructions[XOP_COUNT] = {
     [XOP_MOV_E_BP_IMM1632]          = { true, 0xbd, IDX_TO_EXT(-1), "mov", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_MOV_E_SI_IMM1632]          = { true, 0xbe, IDX_TO_EXT(-1), "mov", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_MOV_E_DI_IMM1632]          = { true, 0xbf, IDX_TO_EXT(-1), "mov", XPX_OPERAND_SIZE_OVERRIDE },
-
-
-
+    [XOP_ROL_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(0), "rol", XPX_NONE },
+    [XOP_ROR_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(1), "ror", XPX_NONE },
+    [XOP_RCL_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(2), "rcl", XPX_NONE },
+    [XOP_RCR_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(3), "rcr", XPX_NONE },
+    [XOP_SHL_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(4), "shl", XPX_NONE },
+    [XOP_SHR_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(5), "shr", XPX_NONE },
+    [XOP_SAL_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(6), "sal", XPX_NONE },
+    [XOP_SAR_RM8_IMM8]              = { false, 0xc0, IDX_TO_EXT(7), "sar", XPX_NONE },
     [XOP_ROL_RM1632_IMM8]           = { false, 0xc1, IDX_TO_EXT(0), "rol", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_ROR_RM1632_IMM8]           = { false, 0xc1, IDX_TO_EXT(1), "ror", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_RCL_RM1632_IMM8]           = { false, 0xc1, IDX_TO_EXT(2), "rcl", XPX_OPERAND_SIZE_OVERRIDE },
@@ -304,7 +309,8 @@ static x86_instruction _instructions[XOP_COUNT] = {
     [XOP_SAR_RM1632_IMM8]           = { false, 0xc1, IDX_TO_EXT(7), "sar", XPX_OPERAND_SIZE_OVERRIDE },
 
 
-    [XOP_RET]                       = { false, 0xc3, IDX_TO_EXT(-1), "ret", XPX_NONE },
+    [XOP_RETN_IMM16]                = { false, 0xc2, IDX_TO_EXT(-1), "retn", XPX_NONE },
+    [XOP_RETN]                      = { false, 0xc3, IDX_TO_EXT(-1), "ret", XPX_NONE },
 
 
     [XOP_MOV_RM8_IMM8]              = { false, 0xc6, IDX_TO_EXT(0), "mov", XPX_NONE },
@@ -313,13 +319,44 @@ static x86_instruction _instructions[XOP_COUNT] = {
 
 
     [XOP_LEAVE]                     = { false, 0xc9, IDX_TO_EXT(-1), "leave", XPX_NONE },
-
-
+    [XOP_RETF_IMM16]                = { false, 0xca, IDX_TO_EXT(-1), "retf", XPX_NONE },
+    [XOP_RETF]                      = { false, 0xcb, IDX_TO_EXT(-1), "ret", XPX_NONE },
     [XOP_INT_3]                     = { false, 0xcc, IDX_TO_EXT(-1), "int", XPX_NONE },
     [XOP_INT]                       = { false, 0xcd, IDX_TO_EXT(-1), "int", XPX_NONE },
 
 
+    [XOP_ROL_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(0), "rol", XPX_NONE },
+    [XOP_ROR_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(1), "ror", XPX_NONE },
+    [XOP_RCL_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(2), "rcl", XPX_NONE },
+    [XOP_RCR_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(3), "rcr", XPX_NONE },
+    [XOP_SHL_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(4), "shl", XPX_NONE },
+    [XOP_SHR_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(5), "shr", XPX_NONE },
+    [XOP_SAL_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(6), "sal", XPX_NONE },
+    [XOP_SAR_RM8_1]                 = { false, 0xd0, IDX_TO_EXT(7), "sar", XPX_NONE },
+    [XOP_ROL_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(0), "rol", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_ROR_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(1), "ror", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_RCL_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(2), "rcl", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_RCR_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(3), "rcr", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SHL_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(4), "shl", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SHR_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(5), "shr", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SAL_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(6), "sal", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SAR_RM1632_1]              = { false, 0xd1, IDX_TO_EXT(7), "sar", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_ROL_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(0), "rol", XPX_NONE },
+    [XOP_ROR_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(1), "ror", XPX_NONE },
+    [XOP_RCL_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(2), "rcl", XPX_NONE },
+    [XOP_RCR_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(3), "rcr", XPX_NONE },
+    [XOP_SHL_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(4), "shl", XPX_NONE },
+    [XOP_SHR_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(5), "shr", XPX_NONE },
+    [XOP_SAL_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(6), "sal", XPX_NONE },
+    [XOP_SAR_RM8_CL]                = { false, 0xd2, IDX_TO_EXT(7), "sar", XPX_NONE },
+    [XOP_ROL_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(0), "rol", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_ROR_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(1), "ror", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_RCL_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(2), "rcl", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_RCR_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(3), "rcr", XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_SHL_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(4), "shl", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SHR_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(5), "shr", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SAL_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(6), "sal", XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_SAR_RM1632_CL]             = { false, 0xd3, IDX_TO_EXT(7), "sar", XPX_OPERAND_SIZE_OVERRIDE },
 
 
     [XOP_CALL_REL1632]              = { false, 0xe8, IDX_TO_EXT(-1), "call", XPX_OPERAND_SIZE_OVERRIDE },
@@ -394,6 +431,8 @@ static x86_instruction _instructions[XOP_COUNT] = {
 
 
     [XOP_MOVZX_R1632_RM8]           = { false, 0xb6, IDX_TO_EXT(-1), "movzx", XPX_TWO_BYTES | XPX_OPERAND_SIZE_OVERRIDE },
+    [XOP_MOVZX_R1632_RM16]          = { false, 0xb7, IDX_TO_EXT(-1), "movzx", XPX_TWO_BYTES | XPX_OPERAND_SIZE_OVERRIDE },
+
     [XOP_MOVSX_R1632_RM8]           = { false, 0xbe, IDX_TO_EXT(-1), "movsx", XPX_TWO_BYTES | XPX_OPERAND_SIZE_OVERRIDE },
     [XOP_MOVSX_R1632_RM1632]        = { false, 0xbf, IDX_TO_EXT(-1), "movsx", XPX_TWO_BYTES | XPX_OPERAND_SIZE_OVERRIDE }
 
@@ -779,6 +818,6 @@ static InstructionLinkType x86_get_instruction_link(const GX86Instruction *instr
 
 static bool x86_instruction_is_return(const GX86Instruction *instr)
 {
-    return (instr->type == XOP_RET);
+    return false;/* FIXME (instr->type == XOP_RET);*/
 
 }
diff --git a/src/arch/x86/instruction.h b/src/arch/x86/instruction.h
index bd57ff6..001233e 100644
--- a/src/arch/x86/instruction.h
+++ b/src/arch/x86/instruction.h
@@ -78,7 +78,7 @@ typedef enum _X86Opcodes
 
     XOP_CMP_RM8_R8,                         /* cmp (0x38)                  */
     XOP_CMP_RM1632_R1632,                   /* cmp ([0x66] 0x39)           */
-
+    XOP_CMP_R8_RM8,                         /* cmp (0x3a)                  */
     XOP_CMP_R1632_RM1632,                   /* cmp ([0x66] 0x3b)           */
     XOP_CMP_AL_IMM8,                        /* cmp (0x3c)                  */
     XOP_CMP_E_AX_IMM1632,                   /* cmp ([0x66] 0x3d)           */
@@ -232,8 +232,14 @@ typedef enum _X86Opcodes
     XOP_MOV_E_BP_IMM1632,                   /* mov ([0x66] 0xbd)           */
     XOP_MOV_E_SI_IMM1632,                   /* mov ([0x66] 0xbe)           */
     XOP_MOV_E_DI_IMM1632,                   /* mov ([0x66] 0xbf)           */
-
-
+    XOP_ROL_RM8_IMM8,                       /* rol (0xc0 0)                */
+    XOP_ROR_RM8_IMM8,                       /* ror (0xc0 1)                */
+    XOP_RCL_RM8_IMM8,                       /* rcl (0xc0 2)                */
+    XOP_RCR_RM8_IMM8,                       /* rcr (0xc0 3)                */
+    XOP_SHL_RM8_IMM8,                       /* shl (0xc0 4)                */
+    XOP_SHR_RM8_IMM8,                       /* shr (0xc0 5)                */
+    XOP_SAL_RM8_IMM8,                       /* sal (0xc0 6)                */
+    XOP_SAR_RM8_IMM8,                       /* sar (0xc0 7)                */
     XOP_ROL_RM1632_IMM8,                    /* rol ([0x66] 0xc1 0)         */
     XOP_ROR_RM1632_IMM8,                    /* ror ([0x66] 0xc1 1)         */
     XOP_RCL_RM1632_IMM8,                    /* rcl ([0x66] 0xc1 2)         */
@@ -244,17 +250,52 @@ typedef enum _X86Opcodes
     XOP_SAR_RM1632_IMM8,                    /* sar ([0x66] 0xc1 7)         */
 
 
-    XOP_RET,                                /* ret (0xc3)                  */
+    XOP_RETN_IMM16,                         /* retn (0xc2)                 */
+    XOP_RETN,                               /* ret (0xc3)                  */
 
     XOP_MOV_RM8_IMM8,                       /* mov (0xc6 0)                */
     XOP_MOV_RM1632_IMM1632,                 /* mov ([0x66] 0xc7 0)         */
 
     XOP_LEAVE,                              /* leave (0xc9)                */
-
+    XOP_RETF_IMM16,                         /* retn (0xca)                 */
+    XOP_RETF,                               /* ret (0xcb)                  */
     XOP_INT_3,                              /* int 3 (0xcc)                */
     XOP_INT,                                /* int (0xcd)                  */
 
+
+    XOP_ROL_RM8_1,                          /* rol (0xd0 0)                */
+    XOP_ROR_RM8_1,                          /* ror (0xd0 1)                */
+    XOP_RCL_RM8_1,                          /* rcl (0xd0 2)                */
+    XOP_RCR_RM8_1,                          /* rcr (0xd0 3)                */
+    XOP_SHL_RM8_1,                          /* shl (0xd0 4)                */
+    XOP_SHR_RM8_1,                          /* shr (0xd0 5)                */
+    XOP_SAL_RM8_1,                          /* sal (0xd0 6)                */
+    XOP_SAR_RM8_1,                          /* sar (0xd0 7)                */
+    XOP_ROL_RM1632_1,                       /* rol ([0x66] 0xd1 0)         */
+    XOP_ROR_RM1632_1,                       /* ror ([0x66] 0xd1 1)         */
+    XOP_RCL_RM1632_1,                       /* rcl ([0x66] 0xd1 2)         */
+    XOP_RCR_RM1632_1,                       /* rcr ([0x66] 0xd1 3)         */
+    XOP_SHL_RM1632_1,                       /* shl ([0x66] 0xd1 4)         */
+    XOP_SHR_RM1632_1,                       /* shr ([0x66] 0xd1 5)         */
+    XOP_SAL_RM1632_1,                       /* sal ([0x66] 0xd1 6)         */
+    XOP_SAR_RM1632_1,                       /* sar ([0x66] 0xd1 7)         */
+    XOP_ROL_RM8_CL,                         /* rol (0xd2 0)                */
+    XOP_ROR_RM8_CL,                         /* ror (0xd2 1)                */
+    XOP_RCL_RM8_CL,                         /* rcl (0xd2 2)                */
+    XOP_RCR_RM8_CL,                         /* rcr (0xd2 3)                */
+    XOP_SHL_RM8_CL,                         /* shl (0xd2 4)                */
+    XOP_SHR_RM8_CL,                         /* shr (0xd2 5)                */
+    XOP_SAL_RM8_CL,                         /* sal (0xd2 6)                */
+    XOP_SAR_RM8_CL,                         /* sar (0xd2 7)                */
+    XOP_ROL_RM1632_CL,                      /* rol ([0x66] 0xd3 0)         */
+    XOP_ROR_RM1632_CL,                      /* ror ([0x66] 0xd3 1)         */
+    XOP_RCL_RM1632_CL,                      /* rcl ([0x66] 0xd3 2)         */
+    XOP_RCR_RM1632_CL,                      /* rcr ([0x66] 0xd3 3)         */
     XOP_SHL_RM1632_CL,                      /* shl ([0x66] 0xd3 4)         */
+    XOP_SHR_RM1632_CL,                      /* shr ([0x66] 0xd3 5)         */
+    XOP_SAL_RM1632_CL,                      /* sal ([0x66] 0xd3 6)         */
+    XOP_SAR_RM1632_CL,                      /* sar ([0x66] 0xd3 7)         */
+
 
     XOP_CALL_REL1632,                       /* call ([0x66] 0xe8)          */
     XOP_JMP_REL1632,                        /* jmp ([0x66] 0xe9)           */
@@ -321,6 +362,8 @@ typedef enum _X86Opcodes
 
 
     XOP_MOVZX_R1632_RM8,                    /* movzx ([0x66] 0x0f 0xb6)    */
+    XOP_MOVZX_R1632_RM16,                   /* movzx ([0x66] 0x0f 0xb7)    */
+
     XOP_MOVSX_R1632_RM8,                    /* movsx ([0x66] 0x0f 0xbe)    */
     XOP_MOVSX_R1632_RM1632,                 /* movsx ([0x66] 0x0f 0xbf)    */
 
diff --git a/src/arch/x86/op_cmp.c b/src/arch/x86/op_cmp.c
index 7972fd9..c503b02 100644
--- a/src/arch/x86/op_cmp.c
+++ b/src/arch/x86/op_cmp.c
@@ -107,6 +107,39 @@ GArchInstruction *x86_read_instr_cmp_e_ax_imm1632(const bin_t *data, off_t *pos,
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'cmp' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_cmp_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_CMP_R8_RM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'cmp' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
@@ -170,6 +203,11 @@ GArchInstruction *x86_read_instr_cmp_rm8_imm8(const bin_t *data, off_t *pos, off
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
 *  Description : Décode une instruction de type 'cmp' (8 bits).               *
 *                                                                             *
diff --git a/src/arch/x86/op_movzx.c b/src/arch/x86/op_movzx.c
index 917399a..e25ca85 100644
--- a/src/arch/x86/op_movzx.c
+++ b/src/arch/x86/op_movzx.c
@@ -64,3 +64,39 @@ GArchInstruction *x86_read_instr_movzx_r1632_rm8(const bin_t *data, off_t *pos,
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'movzx' (16 ou 32 bits).      *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_movzx_r1632_rm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_MOVZX_R1632_RM16);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM16, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
diff --git a/src/arch/x86/op_rcl.c b/src/arch/x86/op_rcl.c
index 52709a4..03e920e 100644
--- a/src/arch/x86/op_rcl.c
+++ b/src/arch/x86/op_rcl.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'rcl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcl_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCL_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcl_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCL_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcl_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCL_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcl' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcl_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_RCL_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcl' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcl_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_RCL_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'rcl' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_rcr.c b/src/arch/x86/op_rcr.c
index 0047203..cd2c42d 100644
--- a/src/arch/x86/op_rcr.c
+++ b/src/arch/x86/op_rcr.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'rcr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcr_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCR_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcr_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCR_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcr_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RCR_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcr' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcr_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_RCR_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rcr' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rcr_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_RCR_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'rcr' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_ret.c b/src/arch/x86/op_ret.c
index fcb4d6d..4e2f26b 100644
--- a/src/arch/x86/op_ret.c
+++ b/src/arch/x86/op_ret.c
@@ -26,6 +26,7 @@
 
 #include "../instruction-int.h"
 #include "opcodes.h"
+#include "operand.h"
 
 
 
@@ -38,7 +39,7 @@
 *                prefix = éventuel(s) préfixe(s) remarqué(s).                 *
 *                proc   = architecture ciblée par le désassemblage.           *
 *                                                                             *
-*  Description : Décode une instruction de type 'ret'.                        *
+*  Description : Décode une instruction de type 'retf'.                       *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
 *                                                                             *
@@ -46,11 +47,107 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *x86_read_instr_ret(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+GArchInstruction *x86_read_instr_retf(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
 
-    result = g_x86_instruction_new(XOP_RET);
+    result = g_x86_instruction_new(XOP_RETF);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data   = flux de données à analyser.                         *
+*                pos    = position courante dans ce flux. [OUT]               *
+*                len    = taille totale des données à analyser.               *
+*                addr   = adresse virtuelle de l'instruction.                 *
+*                prefix = éventuel(s) préfixe(s) remarqué(s).                 *
+*                proc   = architecture ciblée par le désassemblage.           *
+*                                                                             *
+*  Description : Décode une instruction de type 'retf' (16 bits).             *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_retf_imm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RETF_IMM16);
+
+    if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM16))
+    {
+        g_object_unref(G_OBJECT(result));
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data   = flux de données à analyser.                         *
+*                pos    = position courante dans ce flux. [OUT]               *
+*                len    = taille totale des données à analyser.               *
+*                addr   = adresse virtuelle de l'instruction.                 *
+*                prefix = éventuel(s) préfixe(s) remarqué(s).                 *
+*                proc   = architecture ciblée par le désassemblage.           *
+*                                                                             *
+*  Description : Décode une instruction de type 'retn'.                       *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_retn(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RETN);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data   = flux de données à analyser.                         *
+*                pos    = position courante dans ce flux. [OUT]               *
+*                len    = taille totale des données à analyser.               *
+*                addr   = adresse virtuelle de l'instruction.                 *
+*                prefix = éventuel(s) préfixe(s) remarqué(s).                 *
+*                proc   = architecture ciblée par le désassemblage.           *
+*                                                                             *
+*  Description : Décode une instruction de type 'retn' (16 bits).             *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_retn_imm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_RETN_IMM16);
+
+    if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM16))
+    {
+        g_object_unref(G_OBJECT(result));
+        return NULL;
+    }
 
     return result;
 
diff --git a/src/arch/x86/op_rol.c b/src/arch/x86/op_rol.c
index a0c5738..e322e9f 100644
--- a/src/arch/x86/op_rol.c
+++ b/src/arch/x86/op_rol.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'rol' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rol_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROL_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rol' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rol_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROL_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rol' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rol_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROL_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rol' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rol_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_ROL_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'rol' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_rol_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_ROL_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'rol' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_ror.c b/src/arch/x86/op_ror.c
index b77a010..55d350a 100644
--- a/src/arch/x86/op_ror.c
+++ b/src/arch/x86/op_ror.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'ror' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_ror_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROR_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'ror' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_ror_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROR_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'ror' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_ror_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_ROR_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'ror' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_ror_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_ROR_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'ror' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_ror_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_ROR_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'ror' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_sar.c b/src/arch/x86/op_sar.c
index dc2cd7d..924a5be 100644
--- a/src/arch/x86/op_sar.c
+++ b/src/arch/x86/op_sar.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'sar' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_sar_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SAR_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'sar' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_sar_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SAR_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'sar' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_sar_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SAR_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'sar' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_sar_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_SAR_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'sar' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_sar_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_SAR_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'sar' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_shl.c b/src/arch/x86/op_shl.c
index 19d3ed3..62f4adf 100644
--- a/src/arch/x86/op_shl.c
+++ b/src/arch/x86/op_shl.c
@@ -38,6 +38,141 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'shl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shl_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHL_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shl_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHL_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shl' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shl_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHL_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shl' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shl_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_SHL_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'shl' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/op_shr.c b/src/arch/x86/op_shr.c
index ba75534..612df13 100644
--- a/src/arch/x86/op_shr.c
+++ b/src/arch/x86/op_shr.c
@@ -38,6 +38,177 @@
 *                addr = adresse virtuelle de l'instruction.                   *
 *                proc = architecture ciblée par le désassemblage.             *
 *                                                                             *
+*  Description : Décode une instruction de type 'shr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shr_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHR_RM8_1);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shr_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHR_RM8_CL);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shr' (8 bits).               *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shr_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+
+    result = g_x86_instruction_new(XOP_SHR_RM8_IMM8);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shr' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shr_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_SHR_RM1632_1);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
+*  Description : Décode une instruction de type 'shr' (16 ou 32 bits).        *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *x86_read_instr_shr_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
+
+    result = g_x86_instruction_new(XOP_SHR_RM1632_CL);
+
+    oprsize = g_x86_processor_get_operand_size(proc, prefix);
+
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
+    {
+        /* TODO free(result);*/
+        return NULL;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : data = flux de données à analyser.                           *
+*                pos  = position courante dans ce flux. [OUT]                 *
+*                len  = taille totale des données à analyser.                 *
+*                addr = adresse virtuelle de l'instruction.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                                                                             *
 *  Description : Décode une instruction de type 'shr' (16 ou 32 bits).        *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/x86/opcodes.h b/src/arch/x86/opcodes.h
index 19af64b..b1f9232 100644
--- a/src/arch/x86/opcodes.h
+++ b/src/arch/x86/opcodes.h
@@ -113,6 +113,9 @@ GArchInstruction *x86_read_instr_cmp_al_imm8(const bin_t *, off_t *, off_t, vmpa
 /* Décode une instruction de type 'cmp' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_cmp_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'cmp' (8 bits). */
+GArchInstruction *x86_read_instr_cmp_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'cmp' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_cmp_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
@@ -326,6 +329,9 @@ GArchInstruction *x86_read_instr_movsx_r1632_rm1632(const bin_t *, off_t *, off_
 /* Décode une instruction de type 'movzx' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_movzx_r1632_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'movzx' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_movzx_r1632_rm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'nop'. */
 GArchInstruction *x86_read_instr_nop(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
@@ -374,24 +380,129 @@ GArchInstruction *x86_read_instr_push_r1632(const bin_t *, off_t *, off_t, vmpa_
 /* Décode une instruction de type 'push' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_push_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'rcl' (8 bits). */
+GArchInstruction *x86_read_instr_rcl_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcl' (8 bits). */
+GArchInstruction *x86_read_instr_rcl_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcl' (8 bits). */
+GArchInstruction *x86_read_instr_rcl_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcl' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rcl_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcl' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rcl_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'rcl' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_rcl_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'rcr' (8 bits). */
+GArchInstruction *x86_read_instr_rcr_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcr' (8 bits). */
+GArchInstruction *x86_read_instr_rcr_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcr' (8 bits). */
+GArchInstruction *x86_read_instr_rcr_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcr' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rcr_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rcr' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rcr_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'rcr' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_rcr_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
-/* Décode une instruction de type 'ret'. */
-GArchInstruction *x86_read_instr_ret(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+/* Décode une instruction de type 'retf'. */
+GArchInstruction *x86_read_instr_retf(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'retf' (16 bits). */
+GArchInstruction *x86_read_instr_retf_imm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'retn'. */
+GArchInstruction *x86_read_instr_retn(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'retn' (16 bits). */
+GArchInstruction *x86_read_instr_retn_imm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rol' (8 bits). */
+GArchInstruction *x86_read_instr_rol_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rol' (8 bits). */
+GArchInstruction *x86_read_instr_rol_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rol' (8 bits). */
+GArchInstruction *x86_read_instr_rol_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rol' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rol_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'rol' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_rol_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
 /* Décode une instruction de type 'rol' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_rol_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'ror' (8 bits). */
+GArchInstruction *x86_read_instr_ror_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'ror' (8 bits). */
+GArchInstruction *x86_read_instr_ror_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'ror' (8 bits). */
+GArchInstruction *x86_read_instr_ror_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'ror' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_ror_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'ror' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_ror_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'ror' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_ror_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'sal' (8 bits). */
+#define x86_read_instr_sal_rm8_1 x86_read_instr_shl_rm8_1
+
+/* Décode une instruction de type 'sal' (8 bits). */
+#define x86_read_instr_sal_rm8_cl x86_read_instr_shl_rm8_cl
+
+/* Décode une instruction de type 'sal' (8 bits). */
+#define x86_read_instr_sal_rm8_imm8 x86_read_instr_shl_rm8_imm8
+
+/* Décode une instruction de type 'sal' (16 ou 32 bits). */
+#define x86_read_instr_sal_rm1632_1 x86_read_instr_shl_rm1632_1
+
+/* Décode une instruction de type 'sal' (16 ou 32 bits). */
+#define x86_read_instr_sal_rm1632_cl x86_read_instr_shl_rm1632_cl
+
+/* Décode une instruction de type 'sal' (16 ou 32 bits). */
+#define x86_read_instr_sal_rm1632_1 x86_read_instr_shl_rm1632_1
+
+/* Décode une instruction de type 'sal' (16 ou 32 bits). */
+#define x86_read_instr_sal_rm1632_cl x86_read_instr_shl_rm1632_cl
+
 /* Décode une instruction de type 'sal' (16 ou 32 bits). */
 #define x86_read_instr_sal_rm1632_imm8 x86_read_instr_shl_rm1632_imm8
 
+/* Décode une instruction de type 'sar' (8 bits). */
+GArchInstruction *x86_read_instr_sar_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'sar' (8 bits). */
+GArchInstruction *x86_read_instr_sar_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'sar' (8 bits). */
+GArchInstruction *x86_read_instr_sar_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'sar' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_sar_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'sar' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_sar_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'sar' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_sar_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
@@ -458,12 +569,39 @@ GArchInstruction *x86_read_instr_setp_rm8(const bin_t *, off_t *, off_t, vmpa_t,
 /* Décode une instruction de type 'sets' (8 bits). */
 GArchInstruction *x86_read_instr_sets_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'shl' (8 bits). */
+GArchInstruction *x86_read_instr_shl_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shl' (8 bits). */
+GArchInstruction *x86_read_instr_shl_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shl' (8 bits). */
+GArchInstruction *x86_read_instr_shl_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shl' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_shl_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'shl' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_shl_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
 /* Décode une instruction de type 'shl' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_shl_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
+/* Décode une instruction de type 'shr' (8 bits). */
+GArchInstruction *x86_read_instr_shr_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shr' (8 bits). */
+GArchInstruction *x86_read_instr_shr_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shr' (8 bits). */
+GArchInstruction *x86_read_instr_shr_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shr' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_shr_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'shr' (16 ou 32 bits). */
+GArchInstruction *x86_read_instr_shr_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
 /* Décode une instruction de type 'shr' (16 ou 32 bits). */
 GArchInstruction *x86_read_instr_shr_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
 
diff --git a/src/arch/x86/operand.c b/src/arch/x86/operand.c
index 420ceec..bf7010c 100644
--- a/src/arch/x86/operand.c
+++ b/src/arch/x86/operand.c
@@ -1425,6 +1425,10 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 op = g_imm_operand_new_from_data(MDS_8_BITS, data, &op_pos[i], len, SRE_LITTLE /* FIXME */);
                 break;
 
+            case X86_OTP_IMM16:
+                op = g_imm_operand_new_from_data(MDS_16_BITS, data, &op_pos[i], len, SRE_LITTLE /* FIXME */);
+                break;
+
             case X86_OTP_IMM1632:
                 if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_imm_operand_new_from_data(oprsize == MDS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op_pos[i], len, SRE_LITTLE /* FIXME */);
@@ -1474,6 +1478,10 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, MDS_8_BITS);
                 break;
 
+            case X86_OTP_RM16:
+                op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, MDS_16_BITS);
+                break;
+
             case X86_OTP_RM1632:
                 if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, oprsize);
@@ -1497,6 +1505,10 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 op = g_x86_data_operand_new(oprsize == MDS_32_BITS ? MDS_32_BITS : MDS_16_BITS, false);
                 break;
 
+            case X86_OTP_ONE:
+                op = g_imm_operand_new_from_value(MDS_8_BITS, 1);
+                break;
+
             case X86_OTP_CL:
                 op = g_x86_register_operand_new_from_index(0x01, MDS_8_BITS);
                 break;
diff --git a/src/arch/x86/operand.h b/src/arch/x86/operand.h
index 93fac2d..12bd371 100644
--- a/src/arch/x86/operand.h
+++ b/src/arch/x86/operand.h
@@ -214,11 +214,12 @@ typedef enum _X86OperandType
     X86_OTP_NONE        = 0,                /* Aucun opérande de prévu     */
 
     X86_OTP_IMM8        = X86_OTP_IMM(1),   /* Valeur immédiate sur 8 bits */
-    X86_OTP_IMM1632     = X86_OTP_IMM(2),   /* Valeur immédiate sur 16/32b */
-    X86_OTP_MOFFS8      = X86_OTP_IMM(3),   /* Décallage immédiat 8 bits   */
-    X86_OTP_MOFFS1632   = X86_OTP_IMM(4),   /* Décallage immédiat 16/32b   */
-    X86_OTP_REL8        = X86_OTP_IMM(5),   /* Adresse relative 8 bits     */
-    X86_OTP_REL1632     = X86_OTP_IMM(6),   /* Adresse relative 16/32 bits */
+    X86_OTP_IMM16       = X86_OTP_IMM(2),   /* Valeur immédiate sur 16b    */
+    X86_OTP_IMM1632     = X86_OTP_IMM(3),   /* Valeur immédiate sur 16/32b */
+    X86_OTP_MOFFS8      = X86_OTP_IMM(4),   /* Décallage immédiat 8 bits   */
+    X86_OTP_MOFFS1632   = X86_OTP_IMM(5),   /* Décallage immédiat 16/32b   */
+    X86_OTP_REL8        = X86_OTP_IMM(6),   /* Adresse relative 8 bits     */
+    X86_OTP_REL1632     = X86_OTP_IMM(7),   /* Adresse relative 16/32 bits */
 
     X86_OTP_R8          = X86_OTP_REG(1),   /* Registre 8 bits             */
     X86_OTP_R1632       = X86_OTP_REG(2),   /* Registre 16 ou 32 bits      */
@@ -226,13 +227,15 @@ typedef enum _X86OperandType
     X86_OTP_OP_R1632    = X86_OTP_REG(4),   /* Registre 16 ou 32 bits      */
 
     X86_OTP_RM8         = X86_OTP_RM(1),    /* Registre 8 bits ou mémoire  */
-    X86_OTP_RM1632      = X86_OTP_RM(2),    /* Registre 16/32b ou mémoire  */
+    X86_OTP_RM16        = X86_OTP_RM(2),    /* Registre 16 bits ou mémoire */
+    X86_OTP_RM1632      = X86_OTP_RM(3),    /* Registre 16/32b ou mémoire  */
 
     X86_OTP_DST_8       = X86_OTP_DATA(1),  /* Emplacement sur 8 bits      */
     X86_OTP_DST_1632    = X86_OTP_DATA(2),  /* Emplacement sur 16/32 bits  */
     X86_OTP_SRC_8       = X86_OTP_DATA(3),  /* Emplacement sur 8 bits      */
     X86_OTP_SRC_1632    = X86_OTP_DATA(4),  /* Emplacement sur 16/32 bits  */
 
+    X86_OTP_ONE         = 0x0ffc,           /* Valeur immédiate "1"        */
     X86_OTP_CL          = 0x0ffd,           /* Registre cl                 */
     X86_OTP_AL          = 0x0ffe,           /* Registre al                 */
     X86_OTP_E_AX        = 0x0fff            /* Registre eax ou ax          */
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
index 7048890..beddda6 100644
--- a/src/arch/x86/processor.c
+++ b/src/arch/x86/processor.c
@@ -214,6 +214,7 @@ static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor
         [XOP_XOR_E_AX_IMM1632]          = x86_read_instr_xor_e_ax_imm1632,
         [XOP_CMP_RM8_R8]                = x86_read_instr_cmp_rm8_r8,
         [XOP_CMP_RM1632_R1632]          = x86_read_instr_cmp_rm1632_r1632,
+        [XOP_CMP_R8_RM8]                = x86_read_instr_cmp_r8_rm8,
         [XOP_CMP_R1632_RM1632]          = x86_read_instr_cmp_r1632_rm1632,
         [XOP_CMP_AL_IMM8]               = x86_read_instr_cmp_al_imm8,
         [XOP_CMP_E_AX_IMM1632]          = x86_read_instr_cmp_e_ax_imm1632,
@@ -335,6 +336,14 @@ static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor
         [XOP_MOV_E_BP_IMM1632]          = x86_read_instr_mov_r1632_imm1632,
         [XOP_MOV_E_SI_IMM1632]          = x86_read_instr_mov_r1632_imm1632,
         [XOP_MOV_E_DI_IMM1632]          = x86_read_instr_mov_r1632_imm1632,
+        [XOP_ROL_RM8_IMM8]              = x86_read_instr_rol_rm8_imm8,
+        [XOP_ROR_RM8_IMM8]              = x86_read_instr_ror_rm8_imm8,
+        [XOP_RCL_RM8_IMM8]              = x86_read_instr_rcl_rm8_imm8,
+        [XOP_RCR_RM8_IMM8]              = x86_read_instr_rcr_rm8_imm8,
+        [XOP_SHL_RM8_IMM8]              = x86_read_instr_shl_rm8_imm8,
+        [XOP_SHR_RM8_IMM8]              = x86_read_instr_shr_rm8_imm8,
+        [XOP_SAL_RM8_IMM8]              = x86_read_instr_sal_rm8_imm8,
+        [XOP_SAR_RM8_IMM8]              = x86_read_instr_sar_rm8_imm8,
         [XOP_ROL_RM1632_IMM8]           = x86_read_instr_rol_rm1632_imm8,
         [XOP_ROR_RM1632_IMM8]           = x86_read_instr_ror_rm1632_imm8,
         [XOP_RCL_RM1632_IMM8]           = x86_read_instr_rcl_rm1632_imm8,
@@ -343,13 +352,47 @@ static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor
         [XOP_SHR_RM1632_IMM8]           = x86_read_instr_shr_rm1632_imm8,
         [XOP_SAL_RM1632_IMM8]           = x86_read_instr_sal_rm1632_imm8,
         [XOP_SAR_RM1632_IMM8]           = x86_read_instr_sar_rm1632_imm8,
-        [XOP_RET]                       = x86_read_instr_ret,
+        [XOP_RETN_IMM16]                = x86_read_instr_retn_imm16,
+        [XOP_RETN]                      = x86_read_instr_retn,
         [XOP_MOV_RM8_IMM8]              = x86_read_instr_mov_rm8_imm8,
         [XOP_MOV_RM1632_IMM1632]        = x86_read_instr_mov_rm1632_imm1632,
         [XOP_LEAVE]                     = x86_read_instr_leave,
+        [XOP_RETF_IMM16]                = x86_read_instr_retf_imm16,
+        [XOP_RETF]                      = x86_read_instr_retf,
         [XOP_INT_3]                     = x86_read_instr_int_3,
         [XOP_INT]                       = x86_read_instr_int_imm8,
+        [XOP_ROL_RM8_1]                 = x86_read_instr_rol_rm8_1,
+        [XOP_ROR_RM8_1]                 = x86_read_instr_ror_rm8_1,
+        [XOP_RCL_RM8_1]                 = x86_read_instr_rcl_rm8_1,
+        [XOP_RCR_RM8_1]                 = x86_read_instr_rcr_rm8_1,
+        [XOP_SHL_RM8_1]                 = x86_read_instr_shl_rm8_1,
+        [XOP_SHR_RM8_1]                 = x86_read_instr_shr_rm8_1,
+        [XOP_SAL_RM8_1]                 = x86_read_instr_sal_rm8_1,
+        [XOP_SAR_RM8_1]                 = x86_read_instr_sar_rm8_1,
+        [XOP_ROL_RM1632_1]              = x86_read_instr_rol_rm1632_1,
+        [XOP_ROR_RM1632_1]              = x86_read_instr_ror_rm1632_1,
+        [XOP_RCL_RM1632_1]              = x86_read_instr_rcl_rm1632_1,
+        [XOP_RCR_RM1632_1]              = x86_read_instr_rcr_rm1632_1,
+        [XOP_SHL_RM1632_1]              = x86_read_instr_shl_rm1632_1,
+        [XOP_SHR_RM1632_1]              = x86_read_instr_shr_rm1632_1,
+        [XOP_SAL_RM1632_1]              = x86_read_instr_sal_rm1632_1,
+        [XOP_SAR_RM1632_1]              = x86_read_instr_sar_rm1632_1,
+        [XOP_ROL_RM8_CL]                = x86_read_instr_rol_rm8_cl,
+        [XOP_ROR_RM8_CL]                = x86_read_instr_ror_rm8_cl,
+        [XOP_RCL_RM8_CL]                = x86_read_instr_rcl_rm8_cl,
+        [XOP_RCR_RM8_CL]                = x86_read_instr_rcr_rm8_cl,
+        [XOP_SHL_RM8_CL]                = x86_read_instr_shl_rm8_cl,
+        [XOP_SHR_RM8_CL]                = x86_read_instr_shr_rm8_cl,
+        [XOP_SAL_RM8_CL]                = x86_read_instr_sal_rm8_cl,
+        [XOP_SAR_RM8_CL]                = x86_read_instr_sar_rm8_cl,
+        [XOP_ROL_RM1632_CL]             = x86_read_instr_rol_rm1632_cl,
+        [XOP_ROR_RM1632_CL]             = x86_read_instr_ror_rm1632_cl,
+        [XOP_RCL_RM1632_CL]             = x86_read_instr_rcl_rm1632_cl,
+        [XOP_RCR_RM1632_CL]             = x86_read_instr_rcr_rm1632_cl,
         [XOP_SHL_RM1632_CL]             = x86_read_instr_shl_rm1632_cl,
+        [XOP_SHR_RM1632_CL]             = x86_read_instr_shr_rm1632_cl,
+        [XOP_SAL_RM1632_CL]             = x86_read_instr_sal_rm1632_cl,
+        [XOP_SAR_RM1632_CL]             = x86_read_instr_sar_rm1632_cl,
         [XOP_CALL_REL1632]              = x86_read_instr_call_rel1632,
         [XOP_JMP_REL1632]               = x86_read_instr_jmp_rel1632,
         [XOP_JMP_REL8]                  = x86_read_instr_jmp_rel8,
@@ -405,6 +448,7 @@ static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor
         [XOP_SETNG_RM8]                 = x86_read_instr_setng_rm8,
         [XOP_SETG_RM8]                  = x86_read_instr_setg_rm8,
         [XOP_MOVZX_R1632_RM8]           = x86_read_instr_movzx_r1632_rm8,
+        [XOP_MOVZX_R1632_RM16]          = x86_read_instr_movzx_r1632_rm16,
         [XOP_MOVSX_R1632_RM8]           = x86_read_instr_movsx_r1632_rm8,
         [XOP_MOVSX_R1632_RM1632]        = x86_read_instr_movsx_r1632_rm1632