Supported all kinds of add/sub/mul opcodes.

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

8 files changed, 707 insertions, 16 deletions

diff --git a/ChangeLog b/ChangeLog
index 545c28d..c78422d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+12-08-03  Cyrille Bagard <nocbos@gmail.com>
+
+	* src/arch/dalvik/instruction.c:
+	* src/arch/dalvik/instruction-def.h:
+	* src/arch/dalvik/opcodes/add.c:
+	* src/arch/dalvik/opcodes/mul.c:
+	* src/arch/dalvik/opcodes/opcodes.h:
+	* src/arch/dalvik/opcodes/sub.c:
+	* src/arch/dalvik/processor.c:
+	Support all kinds of add/sub/mul opcodes.
+
 12-07-29  Cyrille Bagard <nocbos@gmail.com>
 
 	* src/analysis/decomp/decompiler.c:
diff --git a/src/arch/dalvik/instruction-def.h b/src/arch/dalvik/instruction-def.h
index 38df061..3959d87 100644
--- a/src/arch/dalvik/instruction-def.h
+++ b/src/arch/dalvik/instruction-def.h
@@ -174,6 +174,8 @@ typedef enum _DalvikOpcodes
     DOP_USHR_INT,                           /* ushr-int (0x9a)             */
 
 
+    DOP_ADD_LONG,                           /* add-long (0x9b)             */
+    DOP_SUB_LONG,                           /* sub-long (0x9c)             */
     DOP_MUL_LONG,                           /* mul-long (0x9d)             */
     DOP_DIV_LONG,                           /* div-long (0x9e)             */
 
@@ -181,10 +183,18 @@ typedef enum _DalvikOpcodes
     DOP_SHL_LONG,                           /* shl-long (0xa3)             */
     DOP_SHR_LONG,                           /* shr-long (0xa4)             */
     DOP_USHR_LONG,                          /* ushr-long (0xa5)            */
+    DOP_ADD_FLOAT,                          /* add-float (0xa6)            */
+    DOP_SUB_FLOAT,                          /* sub-float (0xa7)            */
+    DOP_MUL_FLOAT,                          /* mul-float (0xa8)            */
 
 
-    DOP_ADD_INT_2ADDR,                      /* add-int/2addr (0xb0)        */
+    DOP_ADD_DOUBLE,                         /* add-double (0xab)           */
+    DOP_SUB_DOUBLE,                         /* add-double (0xac)           */
+    DOP_MUL_DOUBLE,                         /* add-double (0xad)           */
+
 
+    DOP_ADD_INT_2ADDR,                      /* add-int/2addr (0xb0)        */
+    DOP_SUB_INT_2ADDR,                      /* add-int/2addr (0xb1)        */
     DOP_MUL_INT_2ADDR,                      /* mul-int/2addr (0xb2)        */
     DOP_DIV_INT_2ADDR,                      /* div-int/2addr (0xb3)        */
     DOP_REM_INT_2ADDR,                      /* rem-int/2addr (0xb4)        */
@@ -195,16 +205,24 @@ typedef enum _DalvikOpcodes
     DOP_SHR_INT_2ADDR,                      /* shr-int/2addr (0xb9)        */
     DOP_USHR_INT_2ADDR,                     /* ushr-int/2addr (0xba)       */
     DOP_ADD_LONG_2ADDR,                     /* add-long/2addr (0xbb)       */
-
+    DOP_SUB_LONG_2ADDR,                     /* sub-long/2addr (0xbc)       */
+    DOP_MUL_LONG_2ADDR,                     /* mul-long/2addr (0xbd)       */
 
 
     DOP_SHL_LONG_2ADDR,                     /* shl-long/2addr (0xc3)       */
     DOP_SHR_LONG_2ADDR,                     /* shr-long/2addr (0xc4)       */
     DOP_USHR_LONG_2ADDR,                    /* ushr-long/2addr (0xc5)      */
 
+    DOP_ADD_FLOAT_2ADDR,                    /* add-float/2addr (0xc6)      */
+    DOP_SUB_FLOAT_2ADDR,                    /* sub-float/2addr (0xc7)      */
+    DOP_MUL_FLOAT_2ADDR,                    /* mul-float/2addr (0xc8)      */
 
+    DOP_ADD_DOUBLE_2ADDR,                   /* add-double/2addr (0xcb)     */
+    DOP_SUB_DOUBLE_2ADDR,                   /* sub-double/2addr (0xcc)     */
     DOP_MUL_DOUBLE_2ADDR,                   /* mul-double/2addr (0xcd)     */
 
+
+
     DOP_ADD_INT_LIT16,                      /* add-int/lit16 (0xd0)        */
     DOP_RSUB_INT,                           /* rsub-int (0xd1)             */
     DOP_MUL_INT_LIT16,                      /* mul-int/lit16 (0xd2)        */
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index 7949225..49b5573 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -205,6 +205,8 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_USHR_INT]              = { 0x9a, "ushr-int" },
 
 
+    [DOP_ADD_LONG]              = { 0x9b, "add-long" },
+    [DOP_SUB_LONG]              = { 0x9c, "sub-long" },
     [DOP_MUL_LONG]              = { 0x9d, "mul-long" },
     [DOP_DIV_LONG]              = { 0x9e, "div-long" },
 
@@ -212,26 +214,36 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
     [DOP_SHL_LONG]              = { 0xa3, "shl-long" },
     [DOP_SHR_LONG]              = { 0xa4, "shr-long" },
     [DOP_USHR_LONG]             = { 0xa5, "ushr-long" },
+    [DOP_ADD_FLOAT]             = { 0xa6, "add-float" },
 
 
-    [DOP_ADD_INT_2ADDR]         = { 0xb0, "add-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_ADD_DOUBLE]            = { 0xab, "add-double" },
 
 
+    [DOP_ADD_INT_2ADDR]         = { 0xb0, "add-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_SUB_INT_2ADDR]         = { 0xb1, "sub-int/2addr",      dalvik_decomp_instr_arithm_2addr },
     [DOP_MUL_INT_2ADDR]         = { 0xb2, "mul-int/2addr",      dalvik_decomp_instr_arithm_2addr },
     [DOP_DIV_INT_2ADDR]         = { 0xb3, "div-int/2addr",      dalvik_decomp_instr_arithm_2addr },
     [DOP_REM_INT_2ADDR]         = { 0xb4, "rem-int/2addr",      dalvik_decomp_instr_arithm_2addr },
     [DOP_AND_INT_2ADDR]         = { 0xb5, "and-int/2addr",      dalvik_decomp_instr_arithm_2addr },
     [DOP_OR_INT_2ADDR]          = { 0xb6, "or-int/2addr",       dalvik_decomp_instr_arithm_2addr },
     [DOP_XOR_INT_2ADDR]         = { 0xb7, "xor-int/2addr",      dalvik_decomp_instr_arithm_2addr },
-    [DOP_SHL_INT_2ADDR]         = { 0xb8, "shl-int/2addr" },
-    [DOP_SHR_INT_2ADDR]         = { 0xb9, "shr-int/2addr" },
-    [DOP_USHR_INT_2ADDR]        = { 0xba, "ushr-int/2addr" },
-    [DOP_ADD_LONG_2ADDR]        = { 0xbb, "add-long/2addr" },
-
-    [DOP_SHL_LONG_2ADDR]        = { 0xc3, "shl-long/2addr" },
-    [DOP_SHR_LONG_2ADDR]        = { 0xc4, "shr-long/2addr" },
-    [DOP_USHR_LONG_2ADDR]       = { 0xc5, "ushr-long/2addr" },
-
+    [DOP_SHL_INT_2ADDR]         = { 0xb8, "shl-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_SHR_INT_2ADDR]         = { 0xb9, "shr-int/2addr",      dalvik_decomp_instr_arithm_2addr },
+    [DOP_USHR_INT_2ADDR]        = { 0xba, "ushr-int/2addr",     dalvik_decomp_instr_arithm_2addr },
+    [DOP_ADD_LONG_2ADDR]        = { 0xbb, "add-long/2addr",     dalvik_decomp_instr_arithm_2addr },
+    [DOP_SUB_LONG_2ADDR]        = { 0xbc, "sub-long/2addr",     dalvik_decomp_instr_arithm_2addr },
+    [DOP_MUL_LONG_2ADDR]        = { 0xbd, "mul-long/2addr",     dalvik_decomp_instr_arithm_2addr },
+
+    [DOP_SHL_LONG_2ADDR]        = { 0xc3, "shl-long/2addr",     dalvik_decomp_instr_arithm_2addr },
+    [DOP_SHR_LONG_2ADDR]        = { 0xc4, "shr-long/2addr",     dalvik_decomp_instr_arithm_2addr },
+    [DOP_USHR_LONG_2ADDR]       = { 0xc5, "ushr-long/2addr",    dalvik_decomp_instr_arithm_2addr },
+    [DOP_ADD_FLOAT_2ADDR]       = { 0xc6, "add-float/2addr",    dalvik_decomp_instr_arithm_2addr },
+    [DOP_SUB_FLOAT_2ADDR]       = { 0xc7, "sub-float/2addr",    dalvik_decomp_instr_arithm_2addr },
+    [DOP_MUL_FLOAT_2ADDR]       = { 0xc8, "mul-float/2addr",    dalvik_decomp_instr_arithm_2addr },
+
+    [DOP_ADD_DOUBLE_2ADDR]      = { 0xcb, "add-double/2addr",   dalvik_decomp_instr_arithm_2addr },
+    [DOP_SUB_DOUBLE_2ADDR]      = { 0xcc, "sub-double/2addr",   dalvik_decomp_instr_arithm_2addr },
     [DOP_MUL_DOUBLE_2ADDR]      = { 0xcd, "mul-double/2addr",   dalvik_decomp_instr_arithm_2addr },
 
     [DOP_ADD_INT_LIT16]         = { 0xd0, "add-int/lit16",      dalvik_decomp_instr_arithm_lit },
diff --git a/src/arch/dalvik/opcodes/add.c b/src/arch/dalvik/opcodes/add.c
index b1431a9..792eacd 100644
--- a/src/arch/dalvik/opcodes/add.c
+++ b/src/arch/dalvik/opcodes/add.c
@@ -38,6 +38,80 @@
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
 *                                                                             *
+*  Description : Décode une instruction de type 'add-double'.                 *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_ADD_DOUBLE);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'add-double/2addr'.           *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_ADD_DOUBLE_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
 *  Description : Décode une instruction de type 'add-int'.                    *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
@@ -186,6 +260,117 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
 *                                                                             *
+*  Description : Décode une instruction de type 'add-float'.                  *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_ADD_FLOAT);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'add-float/2addr'.            *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_ADD_FLOAT_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'add-long'.                   *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_ADD_LONG);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
 *  Description : Décode une instruction de type 'add-long/2addr'.             *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
diff --git a/src/arch/dalvik/opcodes/mul.c b/src/arch/dalvik/opcodes/mul.c
index 334f568..aeddd14 100644
--- a/src/arch/dalvik/opcodes/mul.c
+++ b/src/arch/dalvik/opcodes/mul.c
@@ -38,6 +38,43 @@
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
 *                                                                             *
+*  Description : Décode une instruction de type 'mul-double'.                 *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_MUL_DOUBLE);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
 *  Description : Décode une instruction de type 'mul-double/2addr'.           *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
@@ -223,6 +260,80 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
 *                                                                             *
+*  Description : Décode une instruction de type 'mul-float'.                  *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_MUL_FLOAT);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'mul-float/2addr'.            *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_MUL_FLOAT_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
 *  Description : Décode une instruction de type 'mul-long'.                   *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
@@ -249,3 +360,40 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
     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.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'mul-long/2addr'.             *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_MUL_LONG_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        g_object_unref(G_OBJECT(result));
+        return NULL;
+    }
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/opcodes/opcodes.h b/src/arch/dalvik/opcodes/opcodes.h
index 45457e3..5a6d157 100644
--- a/src/arch/dalvik/opcodes/opcodes.h
+++ b/src/arch/dalvik/opcodes/opcodes.h
@@ -36,6 +36,12 @@ typedef GArchInstruction * (* dalvik_read_instr) (const bin_t *, off_t *, off_t,
 
 
 
+/* Décode une instruction de type 'add-double'. */
+GArchInstruction *dalvik_read_instr_add_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'add-double/2addr'. */
+GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 /* Décode une instruction de type 'add-int'. */
 GArchInstruction *dalvik_read_instr_add_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
@@ -48,6 +54,15 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *, off_t *, off_t,
 /* Décode une instruction de type 'add-int/lit16'. */
 GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
+/* Décode une instruction de type 'add-float'. */
+GArchInstruction *dalvik_read_instr_add_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'add-float/2addr'. */
+GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'add-long'. */
+GArchInstruction *dalvik_read_instr_add_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 /* Décode une instruction de type 'add-long/2addr'. */
 GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
@@ -360,6 +375,9 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *, off_t *, off
 GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
 
+/* Décode une instruction de type 'mul-double'. */
+GArchInstruction *dalvik_read_instr_mul_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 /* Décode une instruction de type 'mul-double/2addr'. */
 GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
@@ -375,9 +393,18 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *, off_t *, off_t,
 /* Décode une instruction de type 'mul-int/lit16'. */
 GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
+/* Décode une instruction de type 'mul-float'. */
+GArchInstruction *dalvik_read_instr_mul_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'mul-float/2addr'. */
+GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 /* Décode une instruction de type 'mul-long'. */
 GArchInstruction *dalvik_read_instr_mul_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
+/* Décode une instruction de type 'mul-long/2addr'. */
+GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 
 
 /* Décode une instruction de type 'new-array'. */
@@ -529,9 +556,32 @@ GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *, off_t *, off_t, vmp
 
 
 
+/* Décode une instruction de type 'sub-double'. */
+GArchInstruction *dalvik_read_instr_sub_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'sub-double/2addr'. */
+GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
 /* Décode une instruction de type 'sub-int'. */
 GArchInstruction *dalvik_read_instr_sub_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
 
+/* Décode une instruction de type 'sub-int/2addr'. */
+GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'sub-float'. */
+GArchInstruction *dalvik_read_instr_sub_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'sub-float/2addr'. */
+GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'sub-long'. */
+GArchInstruction *dalvik_read_instr_sub_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+/* Décode une instruction de type 'sub-long/2addr'. */
+GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *);
+
+
+
 
 
 /* Décode une instruction de type 'int-to-byte'. */
diff --git a/src/arch/dalvik/opcodes/sub.c b/src/arch/dalvik/opcodes/sub.c
index 8d42899..c35b9fd 100644
--- a/src/arch/dalvik/opcodes/sub.c
+++ b/src/arch/dalvik/opcodes/sub.c
@@ -38,6 +38,80 @@
 *                proc = architecture ciblée par le désassemblage.             *
 *                fmt  = format du fichier contenant le code.                  *
 *                                                                             *
+*  Description : Décode une instruction de type 'sub-double'.                 *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_DOUBLE);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-double/2addr'.           *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_DOUBLE_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
 *  Description : Décode une instruction de type 'sub-int'.                    *
 *                                                                             *
 *  Retour      : Instruction mise en place ou NULL.                           *
@@ -64,3 +138,188 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
     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.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-int/2addr'.              *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_INT_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-float'.                  *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_FLOAT);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-float/2addr'.            *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_FLOAT_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-long'.                   *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_LONG);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+    {
+        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.                   *
+*                proc = architecture ciblée par le désassemblage.             *
+*                fmt  = format du fichier contenant le code.                  *
+*                                                                             *
+*  Description : Décode une instruction de type 'sub-long/2addr'.             *
+*                                                                             *
+*  Retour      : Instruction mise en place ou NULL.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    SourceEndian endian;                    /* Boutisme lié au binaire     */
+
+    result = g_dalvik_instruction_new(DOP_SUB_LONG_2ADDR);
+
+    endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
+
+    if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+    {
+        g_object_unref(G_OBJECT(result));
+        return NULL;
+    }
+
+    return result;
+
+}
diff --git a/src/arch/dalvik/processor.c b/src/arch/dalvik/processor.c
index 9936738..ef4b733 100644
--- a/src/arch/dalvik/processor.c
+++ b/src/arch/dalvik/processor.c
@@ -404,6 +404,8 @@ static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProc
         [DOP_USHR_INT]              = dalvik_read_instr_ushr_int,
 
 
+        [DOP_ADD_LONG]               = dalvik_read_instr_add_long,
+        [DOP_SUB_LONG]               = dalvik_read_instr_sub_long,
         [DOP_MUL_LONG]               = dalvik_read_instr_mul_long,
         [DOP_DIV_LONG]               = dalvik_read_instr_div_long,
 
@@ -414,7 +416,7 @@ static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProc
 
 
         [DOP_ADD_INT_2ADDR]         = dalvik_read_instr_add_int_2addr,
-
+        [DOP_SUB_INT_2ADDR]         = dalvik_read_instr_sub_int_2addr,
         [DOP_MUL_INT_2ADDR]         = dalvik_read_instr_mul_int_2addr,
         [DOP_DIV_INT_2ADDR]         = dalvik_read_instr_div_int_2addr,
         [DOP_REM_INT_2ADDR]         = dalvik_read_instr_rem_int_2addr,
@@ -426,10 +428,16 @@ static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProc
         [DOP_USHR_INT_2ADDR]        = dalvik_read_instr_ushr_int_2addr,
         [DOP_ADD_LONG_2ADDR]        = dalvik_read_instr_add_long_2addr,
 
-        [DOP_SHL_LONG_2ADDR]         = dalvik_read_instr_shl_long_2addr,
-        [DOP_SHR_LONG_2ADDR]         = dalvik_read_instr_shr_long_2addr,
-        [DOP_USHR_LONG_2ADDR]         = dalvik_read_instr_ushr_long_2addr,
+        [DOP_SHL_LONG_2ADDR]        = dalvik_read_instr_shl_long_2addr,
+        [DOP_SHR_LONG_2ADDR]        = dalvik_read_instr_shr_long_2addr,
+        [DOP_USHR_LONG_2ADDR]       = dalvik_read_instr_ushr_long_2addr,
+
+        [DOP_ADD_FLOAT_2ADDR]       = dalvik_read_instr_add_float_2addr,
+        [DOP_SUB_FLOAT_2ADDR]       = dalvik_read_instr_sub_float_2addr,
+        [DOP_MUL_FLOAT_2ADDR]       = dalvik_read_instr_mul_float_2addr,
 
+        [DOP_ADD_DOUBLE_2ADDR]      = dalvik_read_instr_add_double_2addr,
+        [DOP_SUB_DOUBLE_2ADDR]      = dalvik_read_instr_sub_double_2addr,
         [DOP_MUL_DOUBLE_2ADDR]      = dalvik_read_instr_mul_double_2addr,
 
         [DOP_ADD_INT_LIT16]         = dalvik_read_instr_add_int_lit16,