summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog11
-rw-r--r--src/arch/dalvik/instruction-def.h22
-rw-r--r--src/arch/dalvik/instruction.c32
-rw-r--r--src/arch/dalvik/opcodes/add.c185
-rw-r--r--src/arch/dalvik/opcodes/mul.c148
-rw-r--r--src/arch/dalvik/opcodes/opcodes.h50
-rw-r--r--src/arch/dalvik/opcodes/sub.c259
-rw-r--r--src/arch/dalvik/processor.c16
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,
generated by cgit v0.11.2-87-g4458 at 2024-12-26 05:36:48 (GMT)