Deleted the 'AsmOperandSize' definition and set the x86 minimal instruction size.

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

43 files changed, 210 insertions, 187 deletions

diff --git a/ChangeLog b/ChangeLog
index 2556203..7fe4a05 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,59 @@
+10-08-01  Cyrille Bagard <nocbos@gmail.com>
+
+	* src/arch/artificial.c:
+	Destroy the instruction on loading error.
+
+	* src/arch/dalvik/operand.c:
+	* src/arch/mips/operand.c:
+	Update code.
+
+	* src/arch/operand.h:
+	Delete the 'AsmOperandSize' definition (use MemoryDataSize instead).
+
+	* src/arch/x86/op_adc.c:
+	* src/arch/x86/op_add.c:
+	* src/arch/x86/op_and.c:
+	* src/arch/x86/op_arpl.c:
+	* src/arch/x86/op_call.c:
+	* src/arch/x86/op_cmp.c:
+	* src/arch/x86/op_dec.c:
+	* src/arch/x86/operand.c:
+	* src/arch/x86/operand.h:
+	* src/arch/x86/op_inc.c:
+	* src/arch/x86/op_int.c:
+	* src/arch/x86/op_jump.c:
+	* src/arch/x86/op_lea.c:
+	* src/arch/x86/op_mov.c:
+	* src/arch/x86/op_movs.c:
+	* src/arch/x86/op_movsx.c:
+	* src/arch/x86/op_movzx.c:
+	* src/arch/x86/op_mul.c:
+	* src/arch/x86/op_not.c:
+	* src/arch/x86/op_or.c:
+	* src/arch/x86/op_pop.c:
+	* src/arch/x86/op_push.c:
+	* src/arch/x86/op_rcl.c:
+	* src/arch/x86/op_rcr.c:
+	* src/arch/x86/op_rol.c:
+	* src/arch/x86/op_ror.c:
+	* src/arch/x86/op_sar.c:
+	* src/arch/x86/op_sbb.c:
+	* src/arch/x86/op_shl.c:
+	* src/arch/x86/op_shr.c:
+	* src/arch/x86/op_stos.c:
+	* src/arch/x86/op_sub.c:
+	* src/arch/x86/op_test.c:
+	* src/arch/x86/op_xchg.c:
+	* src/arch/x86/op_xor.c:
+	Update code.
+
+	* src/arch/x86/processor.c:
+	Set the x86 minimal instruction size. Update code.
+
+	* src/arch/x86/processor.h:
+	* src/arch/x86/registers.c:
+	Update code.
+
 10-07-29  Cyrille Bagard <nocbos@gmail.com>
 
 	* configure.ac:
diff --git a/src/arch/artificial.c b/src/arch/artificial.c
index e588a4e..7556d0a 100644
--- a/src/arch/artificial.c
+++ b/src/arch/artificial.c
@@ -152,7 +152,7 @@ GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos,
 
  gdinfd_error:
 
-    /* TODO */
+    g_object_unref(G_OBJECT(result));
 
     return NULL;
 
diff --git a/src/arch/dalvik/operand.c b/src/arch/dalvik/operand.c
index f6f654e..9c4a2c2 100644
--- a/src/arch/dalvik/operand.c
+++ b/src/arch/dalvik/operand.c
@@ -964,7 +964,7 @@ GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t l
     }
 
     result = g_object_new(G_TYPE_DALVIK_TARGET_OPERAND, NULL);
-    result->immediate = G_IMM_OPERAND(g_imm_operand_new_from_value(AOS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */));
+    result->immediate = G_IMM_OPERAND(g_imm_operand_new_from_value(MDS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */));
 
     return G_ARCH_OPERAND(result);
 
diff --git a/src/arch/mips/operand.c b/src/arch/mips/operand.c
index 4021cf6..6c88a7e 100644
--- a/src/arch/mips/operand.c
+++ b/src/arch/mips/operand.c
@@ -407,7 +407,7 @@ GArchOperand *g_mips_mem_content_operand_new(bin_t index, int16_t offset)
         result = g_object_new(G_TYPE_MIPS_MEM_CONTENT_OPERAND, NULL);
 
         result->base = base;
-        result->offset = g_imm_operand_new_from_value(AOS_16_BITS_SIGNED, offset);
+        result->offset = g_imm_operand_new_from_value(MDS_16_BITS_SIGNED, offset);
 
     }
     else result = NULL;
@@ -523,7 +523,7 @@ GArchOperand *g_mips_offset_operand_new(int16_t offset)
 
     result = g_object_new(G_TYPE_MIPS_OFFSET_OPERAND, NULL);
 
-    result->offset = g_imm_operand_new_from_value(AOS_16_BITS_SIGNED, offset);
+    result->offset = g_imm_operand_new_from_value(MDS_16_BITS_SIGNED, offset);
 
     return G_ARCH_OPERAND(result);
 
@@ -613,7 +613,7 @@ bool mips_read_n_operands(GArchInstruction *instr, const bin_t *data, off_t *pos
                 break;
 
             case MIPS_OTP_IMMEDIATE:
-                op = g_imm_operand_new_from_value(AOS_16_BITS, code & 0xffff);
+                op = g_imm_operand_new_from_value(MDS_16_BITS, code & 0xffff);
                 break;
 
 
@@ -628,7 +628,7 @@ bool mips_read_n_operands(GArchInstruction *instr, const bin_t *data, off_t *pos
                 break;
 
             case MIPS_OTP_SA:
-                op = g_imm_operand_new_from_value(AOS_8_BITS, (code & 0x7c0) >> 6);
+                op = g_imm_operand_new_from_value(MDS_8_BITS, (code & 0x7c0) >> 6);
                 break;
 
             default:
diff --git a/src/arch/operand.h b/src/arch/operand.h
index c84c7fb..6d0dc48 100644
--- a/src/arch/operand.h
+++ b/src/arch/operand.h
@@ -25,40 +25,6 @@
 #define _ARCH_OPERAND_H
 
 
-#include <stdbool.h>
-
-
-#include "archbase.h"
-
-
-
-
-/* Taille des données intégrées */
-typedef enum _AsmOperandSize
-{
-    AOS_UNDEFINED,                          /* Taille non définie          */
-
-    AOS_8_BITS_UNSIGNED,                    /* Opérande sur 8 bits n.-s.   */
-    AOS_16_BITS_UNSIGNED,                   /* Opérande sur 16 bits n.-s.  */
-    AOS_32_BITS_UNSIGNED,                   /* Opérande sur 32 bits n.-s.  */
-    AOS_64_BITS_UNSIGNED,                   /* Opérande sur 64 bits n.-s.  */
-
-    AOS_8_BITS_SIGNED,                      /* Opérande sur 8 bits  signés */
-    AOS_16_BITS_SIGNED,                     /* Opérande sur 16 bits signés */
-    AOS_32_BITS_SIGNED,                     /* Opérande sur 32 bits signés */
-    AOS_64_BITS_SIGNED                      /* Opérande sur 64 bits signés */
-
-} AsmOperandSize;
-
-
-#define AOS_8_BITS  AOS_8_BITS_UNSIGNED
-#define AOS_16_BITS AOS_16_BITS_UNSIGNED
-#define AOS_32_BITS AOS_32_BITS_UNSIGNED
-#define AOS_64_BITS AOS_64_BITS_UNSIGNED
-
-
-
-
 #include <glib-object.h>
 
 
diff --git a/src/arch/x86/op_adc.c b/src/arch/x86/op_adc.c
index 6ee4ed3..5d7c1c6 100644
--- a/src/arch/x86/op_adc.c
+++ b/src/arch/x86/op_adc.c
@@ -110,7 +110,7 @@ GArchInstruction *x86_read_instr_adc_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_adc_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADC_RM1632_IMM8);
 
@@ -146,7 +146,7 @@ GArchInstruction *x86_read_instr_adc_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_adc_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADC_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_add.c b/src/arch/x86/op_add.c
index 93506a1..2090d5a 100644
--- a/src/arch/x86/op_add.c
+++ b/src/arch/x86/op_add.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_add_al_imm8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_add_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADD_E_AX_IMM1632);
 
@@ -217,7 +217,7 @@ GArchInstruction *x86_read_instr_add_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_add_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
 
@@ -253,7 +253,7 @@ GArchInstruction *x86_read_instr_add_r1632_rm1632(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_add_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
 
@@ -289,7 +289,7 @@ GArchInstruction *x86_read_instr_add_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_add_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
 
@@ -325,7 +325,7 @@ GArchInstruction *x86_read_instr_add_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_add_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ADD_RM1632_R1632);
 
diff --git a/src/arch/x86/op_and.c b/src/arch/x86/op_and.c
index d59c8f0..74f6d8f 100644
--- a/src/arch/x86/op_and.c
+++ b/src/arch/x86/op_and.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_and_al_imm8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_and_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_AND_E_AX_IMM1632);
 
@@ -184,7 +184,7 @@ GArchInstruction *x86_read_instr_and_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_and_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
 
@@ -220,7 +220,7 @@ GArchInstruction *x86_read_instr_and_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_and_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
 
@@ -256,7 +256,7 @@ GArchInstruction *x86_read_instr_and_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_and_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_AND_RM1632_R1632);
 
diff --git a/src/arch/x86/op_arpl.c b/src/arch/x86/op_arpl.c
index 9b58bda..22ff122 100644
--- a/src/arch/x86/op_arpl.c
+++ b/src/arch/x86/op_arpl.c
@@ -52,7 +52,7 @@ GArchInstruction *x86_read_instr_arpl_rm16_r16(const bin_t *data, off_t *pos, of
 
     result = g_x86_instruction_new(XOP_ARPL_RM16_R16);
 
-    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, AOS_16_BITS))
+    if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, MDS_16_BITS))
     {
         /* TODO free(result);*/
         return NULL;
diff --git a/src/arch/x86/op_call.c b/src/arch/x86/op_call.c
index f121dd3..3bf162a 100644
--- a/src/arch/x86/op_call.c
+++ b/src/arch/x86/op_call.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_call_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CALL_REL1632);
 
@@ -85,7 +85,7 @@ GArchInstruction *x86_read_instr_call_rel1632(const bin_t *data, off_t *pos, off
 GArchInstruction *x86_read_instr_call_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CALL_RM1632);
 
diff --git a/src/arch/x86/op_cmp.c b/src/arch/x86/op_cmp.c
index 5dfa20d..eabc0d6 100644
--- a/src/arch/x86/op_cmp.c
+++ b/src/arch/x86/op_cmp.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_cmp_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CMP_R1632_RM1632);
 
@@ -118,7 +118,7 @@ GArchInstruction *x86_read_instr_cmp_rm8_imm8(const bin_t *data, off_t *pos, off
 GArchInstruction *x86_read_instr_cmp_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
 
@@ -154,7 +154,7 @@ GArchInstruction *x86_read_instr_cmp_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_cmp_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
 
@@ -190,7 +190,7 @@ GArchInstruction *x86_read_instr_cmp_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_cmp_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_CMP_RM1632_R1632);
 
diff --git a/src/arch/x86/op_dec.c b/src/arch/x86/op_dec.c
index 928dafd..7a524b9 100644
--- a/src/arch/x86/op_dec.c
+++ b/src/arch/x86/op_dec.c
@@ -51,7 +51,7 @@ GArchInstruction *x86_read_instr_dec_r1632(const bin_t *data, off_t *pos, off_t
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_DEC_E_AX + (data[*pos] - 0x48);
 
@@ -122,7 +122,7 @@ GArchInstruction *x86_read_instr_dec_rm8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_dec_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_DEC_RM1632);
 
diff --git a/src/arch/x86/op_inc.c b/src/arch/x86/op_inc.c
index eee3490..e9bea6d 100644
--- a/src/arch/x86/op_inc.c
+++ b/src/arch/x86/op_inc.c
@@ -51,7 +51,7 @@ GArchInstruction *x86_read_instr_inc_r1632(const bin_t *data, off_t *pos, off_t
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_INC_E_AX + (data[*pos] - 0x40);
 
@@ -122,7 +122,7 @@ GArchInstruction *x86_read_instr_inc_rm8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_inc_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_INC_RM1632);
 
diff --git a/src/arch/x86/op_int.c b/src/arch/x86/op_int.c
index eef2c1c..b40b257 100644
--- a/src/arch/x86/op_int.c
+++ b/src/arch/x86/op_int.c
@@ -54,7 +54,7 @@ GArchInstruction *x86_read_instr_int_3(const bin_t *data, off_t *pos, off_t len,
 
     result = g_x86_instruction_new(XOP_INT_3);
 
-    three = g_imm_operand_new_from_value(AOS_8_BITS, 3);
+    three = g_imm_operand_new_from_value(MDS_8_BITS, 3);
     g_arch_instruction_attach_extra_operand(result, three);
 
     return result;
diff --git a/src/arch/x86/op_jump.c b/src/arch/x86/op_jump.c
index be8d305..75e06f2 100644
--- a/src/arch/x86/op_jump.c
+++ b/src/arch/x86/op_jump.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_ja_rel8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_ja_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JA_REL1632);
 
@@ -151,7 +151,7 @@ GArchInstruction *x86_read_instr_jb_rel8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_jbe_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JBE_REL1632);
 
@@ -220,7 +220,7 @@ GArchInstruction *x86_read_instr_je_rel8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_je_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JE_REL1632);
 
@@ -289,7 +289,7 @@ GArchInstruction *x86_read_instr_jg_rel8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_jg_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JG_REL1632);
 
@@ -325,7 +325,7 @@ GArchInstruction *x86_read_instr_jg_rel1632(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_jge_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JGE_REL1632);
 
@@ -394,7 +394,7 @@ GArchInstruction *x86_read_instr_jl_rel8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_jle_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JLE_REL1632);
 
@@ -463,7 +463,7 @@ GArchInstruction *x86_read_instr_jmp_rel8(const bin_t *data, off_t *pos, off_t l
 GArchInstruction *x86_read_instr_jmp_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JMP_REL1632);
 
@@ -499,7 +499,7 @@ GArchInstruction *x86_read_instr_jmp_rel1632(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_jmp_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JMP_RM1632);
 
@@ -634,7 +634,7 @@ GArchInstruction *x86_read_instr_jne_rel8(const bin_t *data, off_t *pos, off_t l
 GArchInstruction *x86_read_instr_jne_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_JNE_REL1632);
 
diff --git a/src/arch/x86/op_lea.c b/src/arch/x86/op_lea.c
index 4ea1943..2438798 100644
--- a/src/arch/x86/op_lea.c
+++ b/src/arch/x86/op_lea.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_lea_r1632_m(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_LEA_R1632_M);
 
diff --git a/src/arch/x86/op_mov.c b/src/arch/x86/op_mov.c
index 4532e90..67ef1c8 100644
--- a/src/arch/x86/op_mov.c
+++ b/src/arch/x86/op_mov.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_mov_al_moffs8(const bin_t *data, off_t *pos, of
 GArchInstruction *x86_read_instr_mov_e_ax_moffs1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOV_E_AX_MOFFS1632);
 
@@ -151,7 +151,7 @@ GArchInstruction *x86_read_instr_mov_moffs8_al(const bin_t *data, off_t *pos, of
 GArchInstruction *x86_read_instr_mov_moffs1632_e_ax(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOV_MOFFS1632_E_AX);
 
@@ -224,7 +224,7 @@ GArchInstruction *x86_read_instr_mov_r1632_imm1632(const bin_t *data, off_t *pos
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_MOV_E_AX_IMM1632 + (data[*pos] - 0xb8);
 
@@ -262,7 +262,7 @@ GArchInstruction *x86_read_instr_mov_r1632_imm1632(const bin_t *data, off_t *pos
 GArchInstruction *x86_read_instr_mov_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOV_R1632_RM1632);
 
@@ -359,7 +359,7 @@ GArchInstruction *x86_read_instr_mov_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_mov_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOV_RM1632_IMM1632);
 
@@ -395,7 +395,7 @@ GArchInstruction *x86_read_instr_mov_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_mov_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOV_RM1632_R1632);
 
diff --git a/src/arch/x86/op_movs.c b/src/arch/x86/op_movs.c
index 64c8685..291a111 100644
--- a/src/arch/x86/op_movs.c
+++ b/src/arch/x86/op_movs.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_movs_m1632_m1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOVS_M1632_M1632);
 
diff --git a/src/arch/x86/op_movsx.c b/src/arch/x86/op_movsx.c
index 7e8a09b..bed7ea3 100644
--- a/src/arch/x86/op_movsx.c
+++ b/src/arch/x86/op_movsx.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_movsx_r1632_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOVSX_R1632_RM8);
 
@@ -85,7 +85,7 @@ GArchInstruction *x86_read_instr_movsx_r1632_rm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_movsx_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOVSX_R1632_RM1632);
 
diff --git a/src/arch/x86/op_movzx.c b/src/arch/x86/op_movzx.c
index fc32623..917399a 100644
--- a/src/arch/x86/op_movzx.c
+++ b/src/arch/x86/op_movzx.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_movzx_r1632_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_MOVZX_R1632_RM8);
 
diff --git a/src/arch/x86/op_mul.c b/src/arch/x86/op_mul.c
index 2f29929..6227da1 100644
--- a/src/arch/x86/op_mul.c
+++ b/src/arch/x86/op_mul.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_imul_r1632_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_IMUL_R1632_RM1632_IMM1632);
 
@@ -85,7 +85,7 @@ GArchInstruction *x86_read_instr_imul_r1632_rm1632_imm1632(const bin_t *data, of
 GArchInstruction *x86_read_instr_imul_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_IMUL_RM1632);
 
@@ -121,7 +121,7 @@ GArchInstruction *x86_read_instr_imul_rm1632(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_imul_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_IMUL_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_not.c b/src/arch/x86/op_not.c
index e5677fe..2933cf0 100644
--- a/src/arch/x86/op_not.c
+++ b/src/arch/x86/op_not.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_not_rm8(const bin_t *data, off_t *pos, off_t le
 GArchInstruction *x86_read_instr_not_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_NOT_RM1632);
 
diff --git a/src/arch/x86/op_or.c b/src/arch/x86/op_or.c
index f620d7b..6f483bf 100644
--- a/src/arch/x86/op_or.c
+++ b/src/arch/x86/op_or.c
@@ -115,7 +115,7 @@ GArchInstruction *x86_read_instr_or_r8_rm8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_or_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_OR_R1632_RM1632);
 
@@ -184,7 +184,7 @@ GArchInstruction *x86_read_instr_or_rm8_imm8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_or_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
 
@@ -220,7 +220,7 @@ GArchInstruction *x86_read_instr_or_rm1632_imm8(const bin_t *data, off_t *pos, o
 GArchInstruction *x86_read_instr_or_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
 
@@ -289,7 +289,7 @@ GArchInstruction *x86_read_instr_or_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_or_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_OR_RM1632_R1632);
 
diff --git a/src/arch/x86/op_pop.c b/src/arch/x86/op_pop.c
index 04b49e6..f9c77ca 100644
--- a/src/arch/x86/op_pop.c
+++ b/src/arch/x86/op_pop.c
@@ -50,7 +50,7 @@ GArchInstruction *x86_read_instr_pop_r1632(const bin_t *data, off_t *pos, off_t
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_POP_E_AX + (data[*pos] - 0x58);
 
diff --git a/src/arch/x86/op_push.c b/src/arch/x86/op_push.c
index 0e0d100..8181984 100644
--- a/src/arch/x86/op_push.c
+++ b/src/arch/x86/op_push.c
@@ -50,7 +50,7 @@
 GArchInstruction *x86_read_instr_push_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_PUSH_IMM1632);
 
@@ -88,7 +88,7 @@ GArchInstruction *x86_read_instr_push_r1632(const bin_t *data, off_t *pos, off_t
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_PUSH_E_AX + (data[*pos] - 0x50);
 
@@ -126,7 +126,7 @@ GArchInstruction *x86_read_instr_push_r1632(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_push_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_PUSH_RM1632);
 
diff --git a/src/arch/x86/op_rcl.c b/src/arch/x86/op_rcl.c
index e3d95b3..52709a4 100644
--- a/src/arch/x86/op_rcl.c
+++ b/src/arch/x86/op_rcl.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_rcl_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_RCL_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_rcr.c b/src/arch/x86/op_rcr.c
index 028a53c..0047203 100644
--- a/src/arch/x86/op_rcr.c
+++ b/src/arch/x86/op_rcr.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_rcr_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_RCR_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_rol.c b/src/arch/x86/op_rol.c
index 9f42ada..a0c5738 100644
--- a/src/arch/x86/op_rol.c
+++ b/src/arch/x86/op_rol.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_rol_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ROL_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_ror.c b/src/arch/x86/op_ror.c
index 5220259..b77a010 100644
--- a/src/arch/x86/op_ror.c
+++ b/src/arch/x86/op_ror.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_ror_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_ROR_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_sar.c b/src/arch/x86/op_sar.c
index 2d7dc30..dc2cd7d 100644
--- a/src/arch/x86/op_sar.c
+++ b/src/arch/x86/op_sar.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_sar_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SAR_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_sbb.c b/src/arch/x86/op_sbb.c
index 24c70e7..9aaa765 100644
--- a/src/arch/x86/op_sbb.c
+++ b/src/arch/x86/op_sbb.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_sbb_rm8_imm8(const bin_t *data, off_t *pos, off
 GArchInstruction *x86_read_instr_sbb_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
 
@@ -118,7 +118,7 @@ GArchInstruction *x86_read_instr_sbb_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_sbb_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_shl.c b/src/arch/x86/op_shl.c
index f6d9a77..19d3ed3 100644
--- a/src/arch/x86/op_shl.c
+++ b/src/arch/x86/op_shl.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_shl_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SHL_RM1632_CL);
 
@@ -85,7 +85,7 @@ GArchInstruction *x86_read_instr_shl_rm1632_cl(const bin_t *data, off_t *pos, of
 GArchInstruction *x86_read_instr_shl_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SHL_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_shr.c b/src/arch/x86/op_shr.c
index e6b4edf..ba75534 100644
--- a/src/arch/x86/op_shr.c
+++ b/src/arch/x86/op_shr.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_shr_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SHR_RM1632_IMM8);
 
diff --git a/src/arch/x86/op_stos.c b/src/arch/x86/op_stos.c
index bf47ee7..c44c304 100644
--- a/src/arch/x86/op_stos.c
+++ b/src/arch/x86/op_stos.c
@@ -49,7 +49,7 @@
 GArchInstruction *x86_read_instr_stos_m1632_e_ax(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_STOS_M1632_E_AX);
 
diff --git a/src/arch/x86/op_sub.c b/src/arch/x86/op_sub.c
index 192c848..2df4dce 100644
--- a/src/arch/x86/op_sub.c
+++ b/src/arch/x86/op_sub.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_sub_al_imm8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_sub_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SUB_E_AX_IMM1632);
 
@@ -184,7 +184,7 @@ GArchInstruction *x86_read_instr_sub_rm8_imm8(const bin_t *data, off_t *pos, off
 GArchInstruction *x86_read_instr_sub_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
 
@@ -220,7 +220,7 @@ GArchInstruction *x86_read_instr_sub_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_sub_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
 
@@ -256,7 +256,7 @@ GArchInstruction *x86_read_instr_sub_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_sub_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_SUB_RM1632_R1632);
 
diff --git a/src/arch/x86/op_test.c b/src/arch/x86/op_test.c
index a64861f..a214b22 100644
--- a/src/arch/x86/op_test.c
+++ b/src/arch/x86/op_test.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_test_al_imm8(const bin_t *data, off_t *pos, off
 GArchInstruction *x86_read_instr_test_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_TEST_E_AX_IMM1632);
 
@@ -184,7 +184,7 @@ GArchInstruction *x86_read_instr_test_rm8_r8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_test_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_TEST_RM1632_IMM1632);
 
@@ -220,7 +220,7 @@ GArchInstruction *x86_read_instr_test_rm1632_imm1632(const bin_t *data, off_t *p
 GArchInstruction *x86_read_instr_test_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_TEST_RM1632_R1632);
 
diff --git a/src/arch/x86/op_xchg.c b/src/arch/x86/op_xchg.c
index 7a7d71b..280db6e 100644
--- a/src/arch/x86/op_xchg.c
+++ b/src/arch/x86/op_xchg.c
@@ -50,7 +50,7 @@ GArchInstruction *x86_read_instr_xchg_r1632_e_ax(const bin_t *data, off_t *pos,
 {
     GArchInstruction *result;               /* Instruction à retourner     */
     X86Opcodes opcode;                      /* Instruction effective       */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     opcode = XOP_XCHG_R1632_E_AX + (data[*pos] - 0x90);
 
diff --git a/src/arch/x86/op_xor.c b/src/arch/x86/op_xor.c
index b6e690b..87a1b76 100644
--- a/src/arch/x86/op_xor.c
+++ b/src/arch/x86/op_xor.c
@@ -82,7 +82,7 @@ GArchInstruction *x86_read_instr_xor_al_imm8(const bin_t *data, off_t *pos, off_
 GArchInstruction *x86_read_instr_xor_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
 
@@ -217,7 +217,7 @@ GArchInstruction *x86_read_instr_xor_rm8_r8(const bin_t *data, off_t *pos, off_t
 GArchInstruction *x86_read_instr_xor_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
 
@@ -253,7 +253,7 @@ GArchInstruction *x86_read_instr_xor_r1632_rm1632(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_xor_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
 
@@ -289,7 +289,7 @@ GArchInstruction *x86_read_instr_xor_rm1632_imm8(const bin_t *data, off_t *pos,
 GArchInstruction *x86_read_instr_xor_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
 
@@ -325,7 +325,7 @@ GArchInstruction *x86_read_instr_xor_rm1632_imm1632(const bin_t *data, off_t *po
 GArchInstruction *x86_read_instr_xor_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
 
     result = g_x86_instruction_new(XOP_XOR_RM1632_R1632);
 
diff --git a/src/arch/x86/operand.c b/src/arch/x86/operand.c
index 23b08c2..e97dc2b 100644
--- a/src/arch/x86/operand.c
+++ b/src/arch/x86/operand.c
@@ -350,7 +350,7 @@ static void g_x86_register_operand_init(GX86RegisterOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bin_t base)
+GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bin_t base)
 {
     GX86RegisterOperand *result;            /* Structure à retourner       */
     GX86Register *reg;                      /* Registre lu                 */
@@ -389,7 +389,7 @@ GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bool first)
+GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bool first)
 {
     GX86RegisterOperand *result;            /* Structure à retourner       */
     bin_t index;                            /* Registre lu                 */
@@ -429,7 +429,7 @@ GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *p
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_register_operand_new_from_index(bin_t index, AsmOperandSize size)
+GArchOperand *g_x86_register_operand_new_from_index(bin_t index, MemoryDataSize size)
 {
     GX86RegisterOperand *result;            /* Structure à retourner       */
     GX86Register *reg;                      /* Registre lu                 */
@@ -560,7 +560,7 @@ static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
+GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size)
 {
     GX86ModRMOperand *result;               /* Structure à retourner       */
     uint8_t mod;                            /* Modificateur présent        */
@@ -936,7 +936,7 @@ static void g_x86_relative_operand_init(GX86RelativeOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, vmpa_t base)
+GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, vmpa_t base)
 {
     GX86RelativeOperand *result;            /* Structure à retourner       */
     off_t init_pos;                         /* Position avant lecture      */
@@ -949,15 +949,15 @@ GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t le
 
     switch (size)
     {
-        case AOS_8_BITS_UNSIGNED:
+        case MDS_8_BITS_UNSIGNED:
             read_s8(&val8, data, pos, len, SRE_LITTLE /* FIXME */);
             address = base + (*pos - init_pos) + val8;
             break;
-        case AOS_16_BITS_UNSIGNED:
+        case MDS_16_BITS_UNSIGNED:
             read_s16(&val16, data, pos, len, SRE_LITTLE /* FIXME */);
             address = base + (*pos - init_pos) + val16;
             break;
-        case AOS_32_BITS_UNSIGNED:
+        case MDS_32_BITS_UNSIGNED:
             read_s32(&val32, data, pos, len, SRE_LITTLE /* FIXME */);
             address = base + (*pos - init_pos) + val32;
             break;
@@ -967,7 +967,7 @@ GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t le
     }
 
     result = g_object_new(G_TYPE_X86_RELATIVE_OPERAND, NULL);
-    result->immediate = g_imm_operand_new_from_value(AOS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */);
+    result->immediate = g_imm_operand_new_from_value(MDS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */);
 
     return G_ARCH_OPERAND(result);
 
@@ -1103,7 +1103,7 @@ static void g_x86_moffs_operand_init(GX86MOffsOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
+GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size)
 {
     GX86MOffsOperand *result;               /* Structure à retourner       */
     GImmOperand *offset;                    /* Emplacement lu              */
@@ -1354,7 +1354,7 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
     unsigned int i;                         /* Boucle de parcours          */
     bool op1_first;                         /* Position de l'opérande  #1  */
     bool op2_first;                         /* Position de l'opérande  #2  */
-    AsmOperandSize oprsize;                 /* Taille des opérandes        */
+    MemoryDataSize oprsize;                 /* Taille des opérandes        */
     off_t op_pos[MAX_OPERANDS];             /* Position après lecture      */
     vmpa_t offset;                          /* Adresse courante            */
     bin_t base;                             /* Indice du premier registre  */
@@ -1369,7 +1369,7 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
     /* Types à charger */
 
     for (i = 0; i < count; i++)
-        types[i] = va_arg(ap, AsmOperandSize);
+        types[i] = va_arg(ap, MemoryDataSize);
 
     for ( ; i < MAX_OPERANDS; i++)
         types[i] = X86_OTP_NONE;
@@ -1392,7 +1392,7 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
         op2_first = false;
     }
 
-    oprsize = AOS_UNDEFINED;
+    oprsize = MDS_UNDEFINED;
 
     /* Lecture des opérandes */
 
@@ -1426,56 +1426,56 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 break;
 
             case X86_OTP_IMM1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
-                op = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op_pos[i], len, SRE_LITTLE /* FIXME */);
+                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 */);
                 break;
 
             case X86_OTP_MOFFS8:
-                op = g_x86_moffs_operand_new(data, &op_pos[i], len, AOS_8_BITS);
+                op = g_x86_moffs_operand_new(data, &op_pos[i], len, MDS_8_BITS);
                 break;
 
             case X86_OTP_MOFFS1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_x86_moffs_operand_new(data, &op_pos[i], len, oprsize);
                 break;
 
             case X86_OTP_REL8:
                 offset = va_arg(ap, vmpa_t);
-                op = g_x86_relative_operand_new(data, &op_pos[i], len, AOS_8_BITS, offset + 1);
+                op = g_x86_relative_operand_new(data, &op_pos[i], len, MDS_8_BITS, offset + 1);
                 break;
 
             case X86_OTP_REL1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 offset = va_arg(ap, vmpa_t);
                 op = g_x86_relative_operand_new(data, &op_pos[i], len, oprsize, offset + 1);
                 break;
 
             case X86_OTP_R8:
-                op = g_x86_register_operand_new_from_mod_rm(data, &op_pos[i], len, AOS_8_BITS, i == 0 ? op1_first : op2_first);
+                op = g_x86_register_operand_new_from_mod_rm(data, &op_pos[i], len, MDS_8_BITS, i == 0 ? op1_first : op2_first);
                 break;
 
             case X86_OTP_R1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_x86_register_operand_new_from_mod_rm(data, &op_pos[i], len, oprsize, i == 0 ? op1_first : op2_first);
                 break;
 
             case X86_OTP_OP_R8:
                 base = (bin_t)va_arg(ap, int);
-                op = g_x86_register_operand_new_from_opcode(data, &op_pos[i], len, AOS_8_BITS, base);
+                op = g_x86_register_operand_new_from_opcode(data, &op_pos[i], len, MDS_8_BITS, base);
                 break;
 
             case X86_OTP_OP_R1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 base = (bin_t)va_arg(ap, int);
                 op = g_x86_register_operand_new_from_opcode(data, &op_pos[i], len, oprsize, base);
                 break;
 
             case X86_OTP_RM8:
-                op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, AOS_8_BITS);
+                op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, MDS_8_BITS);
                 break;
 
             case X86_OTP_RM1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_x86_mod_rm_operand_new(data, &op_pos[i], len, oprsize);
                 break;
 
@@ -1484,8 +1484,8 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 break;
 
             case X86_OTP_DST_1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
-                op = g_x86_data_operand_new(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, true);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
+                op = g_x86_data_operand_new(oprsize == MDS_32_BITS ? MDS_32_BITS : MDS_16_BITS, true);
                 break;
 
             case X86_OTP_SRC_8:
@@ -1493,20 +1493,20 @@ bool _x86_read_operands(GArchInstruction *instr, const bin_t *data, off_t *pos,
                 break;
 
             case X86_OTP_SRC_1632:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
-                op = g_x86_data_operand_new(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, false);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
+                op = g_x86_data_operand_new(oprsize == MDS_32_BITS ? MDS_32_BITS : MDS_16_BITS, false);
                 break;
 
             case X86_OTP_CL:
-                op = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
+                op = g_x86_register_operand_new_from_index(0x01, MDS_8_BITS);
                 break;
 
             case X86_OTP_AL:
-                op = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
+                op = g_x86_register_operand_new_from_index(0x00, MDS_8_BITS);
                 break;
 
             case X86_OTP_E_AX:
-                if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+                if (oprsize == MDS_UNDEFINED) oprsize = va_arg(ap, MemoryDataSize);
                 op = g_x86_register_operand_new_from_index(0x00, oprsize);
                 break;
 
diff --git a/src/arch/x86/operand.h b/src/arch/x86/operand.h
index f42b67d..93fac2d 100644
--- a/src/arch/x86/operand.h
+++ b/src/arch/x86/operand.h
@@ -75,13 +75,13 @@ typedef struct _GX86RegisterOperandClass GX86RegisterOperandClass;
 GType g_x86_register_operand_get_type(void);
 
 /* Crée un opérande visant un registre x86. */
-GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *, off_t *, off_t, AsmOperandSize, bin_t);
+GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *, off_t *, off_t, MemoryDataSize, bin_t);
 
 /* Crée un opérande visant un registre x86. */
-GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *, off_t *, off_t, AsmOperandSize, bool);
+GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *, off_t *, off_t, MemoryDataSize, bool);
 
 /* Crée un opérande visant un registre x86 donné. */
-GArchOperand *g_x86_register_operand_new_from_index(bin_t, AsmOperandSize);
+GArchOperand *g_x86_register_operand_new_from_index(bin_t, MemoryDataSize);
 
 
 
@@ -105,7 +105,7 @@ typedef struct _GX86ModRMOperandClass GX86ModRMOperandClass;
 GType g_x86_mod_rm_operand_get_type(void);
 
 /* Crée un opérande x86 de type ModRM. */
-GArchOperand *g_x86_mod_rm_operand_new(const bin_t *, off_t *, off_t, AsmOperandSize);
+GArchOperand *g_x86_mod_rm_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize);
 
 /* Fournit l'indice et l'échelle d'un opérande x86 ModRM. */
 void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *, const GX86Register **);
@@ -138,7 +138,7 @@ typedef struct _GX86RelativeOperandClass GX86RelativeOperandClass;
 GType g_x86_relative_operand_get_type(void);
 
 /* Crée un opérande X86 d'adresse relative. */
-GArchOperand *g_x86_relative_operand_new(const bin_t *, off_t *, off_t, AsmOperandSize, vmpa_t);
+GArchOperand *g_x86_relative_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize, vmpa_t);
 
 /* Fournit l'adresse représentée par une opérande X86. */
 const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *);
@@ -165,7 +165,7 @@ typedef struct _GX86MOffsOperandClass GX86MOffsOperandClass;
 GType g_x86_moffs_operand_get_type(void);
 
 /* Crée un opérande d'emplacement mémoire x86. */
-GArchOperand *g_x86_moffs_operand_new(const bin_t *, off_t *, off_t, AsmOperandSize);
+GArchOperand *g_x86_moffs_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize);
 
 
 
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
index 58f271c..54008d7 100644
--- a/src/arch/x86/processor.c
+++ b/src/arch/x86/processor.c
@@ -98,6 +98,7 @@ static void g_x86_processor_init(GX86Processor *proc)
 
     parent->endianness = SRE_BIG;
     parent->memsize = MDS_32_BITS;
+    parent->inssize = MDS_8_BITS;
 
     parent->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
 
@@ -140,16 +141,16 @@ GArchProcessor *g_x86_processor_new(void)
 *                                                                             *
 ******************************************************************************/
 
-AsmOperandSize g_x86_processor_get_operand_size(const GX86Processor *proc, X86Prefix prefix)
+MemoryDataSize g_x86_processor_get_operand_size(const GX86Processor *proc, X86Prefix prefix)
 {
-    AsmOperandSize result;                  /* Taille à renvoyer           */
+    MemoryDataSize result;                  /* Taille à renvoyer           */
 
     /* FIXME */
 
     if (prefix & XPX_OPERAND_SIZE_OVERRIDE)
-        result = (AOS_32_BITS/*proc->operand_size*/ == AOS_32_BITS ? AOS_16_BITS : AOS_32_BITS);
+        result = (MDS_32_BITS/*proc->operand_size*/ == MDS_32_BITS ? MDS_16_BITS : MDS_32_BITS);
  
-    else result = AOS_32_BITS/*proc->operand_size*/;
+    else result = MDS_32_BITS/*proc->operand_size*/;
 
     return result;
 
diff --git a/src/arch/x86/processor.h b/src/arch/x86/processor.h
index a04d880..99f2118 100644
--- a/src/arch/x86/processor.h
+++ b/src/arch/x86/processor.h
@@ -50,7 +50,7 @@ GType g_x86_processor_get_type(void);
 GArchProcessor *g_x86_processor_new(void);
 
 /* Fournit la taille supplantée des opérandes pour x86. */
-AsmOperandSize g_x86_processor_get_operand_size(const GX86Processor *, X86Prefix);
+MemoryDataSize g_x86_processor_get_operand_size(const GX86Processor *, X86Prefix);
 
 
 
diff --git a/src/arch/x86/registers.c b/src/arch/x86/registers.c
index f3209bb..45b6286 100644
--- a/src/arch/x86/registers.c
+++ b/src/arch/x86/registers.c
@@ -189,7 +189,7 @@ GX86Register *g_x86_register_new(MemoryDataSize size, bin_t value)
 
     switch (size)
     {
-        case AOS_8_BITS:
+        case MDS_8_BITS:
             switch (value)
             {
                 case 0 ... 7:
@@ -201,7 +201,7 @@ GX86Register *g_x86_register_new(MemoryDataSize size, bin_t value)
             }
             break;
 
-        case AOS_16_BITS:
+        case MDS_16_BITS:
             switch (value)
             {
                 case 0 ... 7:
@@ -213,7 +213,7 @@ GX86Register *g_x86_register_new(MemoryDataSize size, bin_t value)
             }
             break;
 
-        case AOS_32_BITS:
+        case MDS_32_BITS:
             switch (value)
             {
                 case 0 ... 7:
@@ -267,7 +267,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
         case ASX_INTEL:
             switch (reg->size)
             {
-                case AOS_8_BITS:
+                case MDS_8_BITS:
                     *klen = 2;
                     switch (reg->reg.reg8)
                     {
@@ -301,7 +301,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
                     }
                     break;
 
-                case AOS_16_BITS:
+                case MDS_16_BITS:
                     *klen = 2;
                     switch (reg->reg.reg16)
                     {
@@ -335,7 +335,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
                     }
                     break;
 
-                case AOS_32_BITS:
+                case MDS_32_BITS:
                     *klen = 3;
                     switch (reg->reg.reg32)
                     {
@@ -379,7 +379,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
         case ASX_ATT:
             switch (reg->size)
             {
-                case AOS_8_BITS:
+                case MDS_8_BITS:
                     *klen = 3;
                     switch (reg->reg.reg8)
                     {
@@ -413,7 +413,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
                     }
                     break;
 
-                case AOS_16_BITS:
+                case MDS_16_BITS:
                     *klen = 3;
                     switch (reg->reg.reg16)
                     {
@@ -447,7 +447,7 @@ static void g_x86_register_to_string(const GX86Register *reg, AsmSyntax syntax,
                     }
                     break;
 
-                case AOS_32_BITS:
+                case MDS_32_BITS:
                     *klen = 4;
                     switch (reg->reg.reg32)
                     {
@@ -568,21 +568,21 @@ bool g_x86_register_is_base_pointer(const GX86Register *reg)
 
     switch (reg->size)
     {
-        case AOS_8_BITS_UNSIGNED:
-        case AOS_8_BITS_SIGNED:
+        case MDS_8_BITS_UNSIGNED:
+        case MDS_8_BITS_SIGNED:
             result = (reg->reg.reg8 == X86_REG8_CH);
             break;
-        case AOS_16_BITS_UNSIGNED:
-        case AOS_16_BITS_SIGNED:
+        case MDS_16_BITS_UNSIGNED:
+        case MDS_16_BITS_SIGNED:
             result = (reg->reg.reg16 == X86_REG16_BP);
             break;
-        case AOS_32_BITS_UNSIGNED:
-        case AOS_32_BITS_SIGNED:
+        case MDS_32_BITS_UNSIGNED:
+        case MDS_32_BITS_SIGNED:
             result = (reg->reg.reg32 == X86_REG32_EBP);
             break;
             /*
-        case AOS_64_BITS_UNSIGNED:
-        case AOS_64_BITS_SIGNED:
+        case MDS_64_BITS_UNSIGNED:
+        case MDS_64_BITS_SIGNED:
             result = (reg->reg.reg8 == X86_REG8_CH);
             break;
             */
@@ -614,21 +614,21 @@ bool g_x86_register_is_stack_pointer(const GX86Register *reg)
 
     switch (reg->size)
     {
-        case AOS_8_BITS_UNSIGNED:
-        case AOS_8_BITS_SIGNED:
+        case MDS_8_BITS_UNSIGNED:
+        case MDS_8_BITS_SIGNED:
             result = (reg->reg.reg8 == X86_REG8_AH);
             break;
-        case AOS_16_BITS_UNSIGNED:
-        case AOS_16_BITS_SIGNED:
+        case MDS_16_BITS_UNSIGNED:
+        case MDS_16_BITS_SIGNED:
             result = (reg->reg.reg16 == X86_REG16_SP);
             break;
-        case AOS_32_BITS_UNSIGNED:
-        case AOS_32_BITS_SIGNED:
+        case MDS_32_BITS_UNSIGNED:
+        case MDS_32_BITS_SIGNED:
             result = (reg->reg.reg32 == X86_REG32_ESP);
             break;
             /*
-        case AOS_64_BITS_UNSIGNED:
-        case AOS_64_BITS_SIGNED:
+        case MDS_64_BITS_UNSIGNED:
+        case MDS_64_BITS_SIGNED:
             result = (reg->reg.reg8 == X86_REG8_CH);
             break;
             */