summaryrefslogtreecommitdiff
path: root/src/arch
diff options
context:
space:
mode:
authorCyrille Bagard <nocbos@gmail.com>2014-07-31 05:53:06 (GMT)
committerCyrille Bagard <nocbos@gmail.com>2014-07-31 05:53:06 (GMT)
commita5d8e3fc30cda2e13d30f099e93ab1b182fdc0bd (patch)
treecf183906b2301cd3c726af820292fd0f2458bfa1 /src/arch
parentdc436357ff29158dddd836d368d152d42d5b086b (diff)
Improved the way code is decoded by avoiding to propagate the base address everywhere.
git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@385 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a
Diffstat (limited to 'src/arch')
-rw-r--r--src/arch/arm/instruction.c4
-rw-r--r--src/arch/arm/processor.c63
-rw-r--r--src/arch/arm/v456/instruction.c4
-rw-r--r--src/arch/artificial.c6
-rw-r--r--src/arch/dalvik/instruction.c4
-rw-r--r--src/arch/dalvik/opcodes/add.c60
-rw-r--r--src/arch/dalvik/opcodes/aget.c42
-rw-r--r--src/arch/dalvik/opcodes/and.c36
-rw-r--r--src/arch/dalvik/opcodes/aput.c42
-rw-r--r--src/arch/dalvik/opcodes/array.c24
-rw-r--r--src/arch/dalvik/opcodes/check.c6
-rw-r--r--src/arch/dalvik/opcodes/cmp.c30
-rw-r--r--src/arch/dalvik/opcodes/const.c66
-rw-r--r--src/arch/dalvik/opcodes/div.c60
-rw-r--r--src/arch/dalvik/opcodes/goto.c18
-rw-r--r--src/arch/dalvik/opcodes/if.c72
-rw-r--r--src/arch/dalvik/opcodes/iget.c42
-rw-r--r--src/arch/dalvik/opcodes/instanceof.c6
-rw-r--r--src/arch/dalvik/opcodes/invoke.c60
-rw-r--r--src/arch/dalvik/opcodes/iput.c42
-rw-r--r--src/arch/dalvik/opcodes/monitor.c12
-rw-r--r--src/arch/dalvik/opcodes/move.c78
-rw-r--r--src/arch/dalvik/opcodes/mul.c60
-rw-r--r--src/arch/dalvik/opcodes/neg.c24
-rw-r--r--src/arch/dalvik/opcodes/new.c12
-rw-r--r--src/arch/dalvik/opcodes/nop.c6
-rw-r--r--src/arch/dalvik/opcodes/not.c12
-rw-r--r--src/arch/dalvik/opcodes/or.c36
-rw-r--r--src/arch/dalvik/opcodes/rem.c60
-rw-r--r--src/arch/dalvik/opcodes/ret.c24
-rw-r--r--src/arch/dalvik/opcodes/rsub.c12
-rw-r--r--src/arch/dalvik/opcodes/sget.c42
-rw-r--r--src/arch/dalvik/opcodes/shl.c30
-rw-r--r--src/arch/dalvik/opcodes/shr.c30
-rw-r--r--src/arch/dalvik/opcodes/sput.c42
-rw-r--r--src/arch/dalvik/opcodes/sub.c48
-rw-r--r--src/arch/dalvik/opcodes/switch.c12
-rw-r--r--src/arch/dalvik/opcodes/throw.c6
-rw-r--r--src/arch/dalvik/opcodes/to.c90
-rw-r--r--src/arch/dalvik/opcodes/ushr.c30
-rw-r--r--src/arch/dalvik/opcodes/xor.c36
-rw-r--r--src/arch/dalvik/operand.c70
-rw-r--r--src/arch/dalvik/operands/pool.c8
-rw-r--r--src/arch/dalvik/operands/register.c10
-rw-r--r--src/arch/dalvik/operands/target.c10
-rw-r--r--src/arch/dalvik/processor.c76
-rw-r--r--src/arch/dalvik/pseudo/fill.c10
-rw-r--r--src/arch/dalvik/pseudo/switch.c8
-rw-r--r--src/arch/immediate.c24
-rw-r--r--src/arch/jvm/processor.c55
-rw-r--r--src/arch/mips/processor.c55
-rw-r--r--src/arch/processor-int.h3
-rw-r--r--src/arch/processor.c11
-rw-r--r--src/arch/processor.h7
-rw-r--r--src/arch/vmpa.c181
-rw-r--r--src/arch/vmpa.h40
-rw-r--r--src/arch/x86/processor.c63
57 files changed, 1248 insertions, 772 deletions
diff --git a/src/arch/arm/instruction.c b/src/arch/arm/instruction.c
index 70517b3..77dd621 100644
--- a/src/arch/arm/instruction.c
+++ b/src/arch/arm/instruction.c
@@ -101,7 +101,7 @@ static void g_arm_instruction_init(GArmInstruction *instr)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* *
* Description : Recherche l'identifiant de la prochaine instruction. *
* *
@@ -111,7 +111,7 @@ static void g_arm_instruction_init(GArmInstruction *instr)
* *
******************************************************************************/
-ArmOpcodes arm_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+ArmOpcodes arm_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
{
ArmOpcodes result; /* Identifiant à retourner */
diff --git a/src/arch/arm/processor.c b/src/arch/arm/processor.c
index 44dcb19..4bd342f 100644
--- a/src/arch/arm/processor.c
+++ b/src/arch/arm/processor.c
@@ -52,6 +52,12 @@ static void g_arm_processor_class_init(GArmProcessorClass *);
/* Initialise une instance de processeur ARM. */
static void g_arm_processor_init(GArmProcessor *);
+/* Supprime toutes les références externes. */
+static void g_arm_processor_dispose(GArmProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_arm_processor_finalize(GArmProcessor *);
+
/* Décode une instruction dans un flux de données. */
static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *, GProcContext *, const bin_t *, off_t *, off_t, vmpa_t, GBinFormat *);
@@ -75,6 +81,17 @@ G_DEFINE_TYPE(GArmProcessor, g_arm_processor, G_TYPE_ARCH_PROCESSOR);
static void g_arm_processor_class_init(GArmProcessorClass *klass)
{
+ GObjectClass *object; /* Autre version de la classe */
+ GArchProcessorClass *proc; /* Encore une autre vision... */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_arm_processor_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_arm_processor_finalize;
+
+ proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+ proc->decode = (decode_instruction_fc)g_arm_processor_decode_instruction;
}
@@ -101,7 +118,43 @@ static void g_arm_processor_init(GArmProcessor *proc)
parent->memsize = MDS_32_BITS;
parent->inssize = MDS_32_BITS;
- parent->decode = (decode_instruction_fc)g_arm_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_arm_processor_dispose(GArmProcessor *proc)
+{
+ G_OBJECT_CLASS(g_arm_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : bookmark = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_arm_processor_finalize(GArmProcessor *proc)
+{
+ G_OBJECT_CLASS(g_arm_processor_parent_class)->finalize(G_OBJECT(proc));
}
@@ -131,11 +184,11 @@ GArchProcessor *g_arm_processor_new(void)
/******************************************************************************
* *
-* Paramètres : proc = architecture visée par la procédure. *
-* ctx = contexte lié à l'exécution du processeur. *
+* Paramètres : proc = architecture visée par la procédure. *
+* ctx = contexte lié à l'exécution du processeur. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* format = format du fichier contenant le code. *
* *
@@ -149,7 +202,7 @@ GArchProcessor *g_arm_processor_new(void)
#include "encoding.h"
extern GArchInstruction *try_to_decode_arm_v456_instr(bin_t *);
-static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t len, vmpa_t addr, GBinFormat *format)
+static GArchInstruction *g_arm_processor_decode_instruction(const GArmProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GBinFormat *format)
{
GArchInstruction *result; /* Instruction à renvoyer */
diff --git a/src/arch/arm/v456/instruction.c b/src/arch/arm/v456/instruction.c
index 0ab85c0..3ba3c54 100644
--- a/src/arch/arm/v456/instruction.c
+++ b/src/arch/arm/v456/instruction.c
@@ -509,7 +509,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* *
* Description : Recherche l'identifiant de la prochaine instruction. *
* *
@@ -519,7 +519,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
* *
******************************************************************************/
-DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
{
DalvikOpcodes result; /* Identifiant à retourner */
diff --git a/src/arch/artificial.c b/src/arch/artificial.c
index 2a78255..6fbd6d9 100644
--- a/src/arch/artificial.c
+++ b/src/arch/artificial.c
@@ -124,7 +124,7 @@ static void g_db_instruction_init(GDbInstruction *instr)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* addr = adresse, virtuelle ou physique, de l'instruction. *
* proc = architecture ciblée par le désassemblage. *
* *
@@ -136,7 +136,7 @@ static void g_db_instruction_init(GDbInstruction *instr)
* *
******************************************************************************/
-GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GArchProcessor *proc)
+GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GArchProcessor *proc)
{
GArchInstruction *result; /* Instruction à retourner */
GArchOperand *operand; /* Octet non décodé à afficher */
@@ -144,7 +144,7 @@ GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos,
result = g_object_new(G_TYPE_DB_INSTRUCTION, NULL);
operand = g_imm_operand_new_from_data(g_arch_processor_get_instruction_size(proc),
- data, pos, len,
+ data, pos, end,
g_arch_processor_get_endianness(proc));
if (operand == NULL) goto gdinfd_error;
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index b8d0979..83e0e6c 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -489,7 +489,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* *
* Description : Recherche l'identifiant de la prochaine instruction. *
* *
@@ -499,7 +499,7 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
* *
******************************************************************************/
-DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t len)
+DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t end)
{
DalvikOpcodes result; /* Identifiant à retourner */
diff --git a/src/arch/dalvik/opcodes/add.c b/src/arch/dalvik/opcodes/add.c
index 9b34677..4d93df9 100644
--- a/src/arch/dalvik/opcodes/add.c
+++ b/src/arch/dalvik/opcodes/add.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-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 *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-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 *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_add_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-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 *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-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 *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *po
* *
******************************************************************************/
-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 *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/aget.c b/src/arch/dalvik/opcodes/aget.c
index a1a3211..e5033aa 100644
--- a/src/arch/dalvik/opcodes/aget.c
+++ b/src/arch/dalvik/opcodes/aget.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_aget(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_aget_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_aget_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_aget_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/and.c b/src/arch/dalvik/opcodes/and.c
index f8b96b0..d5162bf 100644
--- a/src/arch/dalvik/opcodes/and.c
+++ b/src/arch/dalvik/opcodes/and.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_and_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_and_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/aput.c b/src/arch/dalvik/opcodes/aput.c
index 126f480..6cdde65 100644
--- a/src/arch/dalvik/opcodes/aput.c
+++ b/src/arch/dalvik/opcodes/aput.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_aput(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_aput_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_aput_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_aput_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/array.c b/src/arch/dalvik/opcodes/array.c
index f40d6b8..efa40b7 100644
--- a/src/arch/dalvik/opcodes/array.c
+++ b/src/arch/dalvik/opcodes/array.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_array_length(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -109,7 +109,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -122,7 +122,7 @@ GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -131,7 +131,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -146,7 +146,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -159,7 +159,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -168,7 +168,7 @@ GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *data, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/check.c b/src/arch/dalvik/opcodes/check.c
index dc32e30..725f336 100644
--- a/src/arch/dalvik/opcodes/check.c
+++ b/src/arch/dalvik/opcodes/check.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_check_cast(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/cmp.c b/src/arch/dalvik/opcodes/cmp.c
index c7b4b83..e6de13c 100644
--- a/src/arch/dalvik/opcodes/cmp.c
+++ b/src/arch/dalvik/opcodes/cmp.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/const.c b/src/arch/dalvik/opcodes/const.c
index af5f504..5097804 100644
--- a/src/arch/dalvik/opcodes/const.c
+++ b/src/arch/dalvik/opcodes/const.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31I))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_const(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_const_16(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11N))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11N))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_const_4(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_const_class(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21H))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_const_high16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_STRING)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_STRING)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_const_string(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31C | DALVIK_OP_POOL(DPT_STRING)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31C | DALVIK_OP_POOL(DPT_STRING)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_51L))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_51L))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_const_wide(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31I))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *data, off_t *
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21H))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/div.c b/src/arch/dalvik/opcodes/div.c
index af047f8..a20968b 100644
--- a/src/arch/dalvik/opcodes/div.c
+++ b/src/arch/dalvik/opcodes/div.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_div_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_div_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_div_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_div_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/goto.c b/src/arch/dalvik/opcodes/goto.c
index 739155b..f74774a 100644
--- a/src/arch/dalvik/opcodes/goto.c
+++ b/src/arch/dalvik/opcodes/goto.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_goto(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_20T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_20T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_goto_16(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_goto_32(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_30T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_30T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/if.c b/src/arch/dalvik/opcodes/if.c
index 3e6f319..ad8b49a 100644
--- a/src/arch/dalvik/opcodes/if.c
+++ b/src/arch/dalvik/opcodes/if.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_if_eq(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_if_ge(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_if_gez(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_if_gt(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -292,7 +292,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -305,7 +305,7 @@ GArchInstruction *dalvik_read_instr_if_le(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -314,7 +314,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -329,7 +329,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -342,7 +342,7 @@ GArchInstruction *dalvik_read_instr_if_lez(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -351,7 +351,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -366,7 +366,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -379,7 +379,7 @@ GArchInstruction *dalvik_read_instr_if_lt(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -388,7 +388,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -403,7 +403,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -416,7 +416,7 @@ GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -425,7 +425,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -440,7 +440,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -453,7 +453,7 @@ GArchInstruction *dalvik_read_instr_if_ne(const bin_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_if_nez(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21T, addr))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/iget.c b/src/arch/dalvik/opcodes/iget.c
index 8fca24f..f83bb96 100644
--- a/src/arch/dalvik/opcodes/iget.c
+++ b/src/arch/dalvik/opcodes/iget.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_iget(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_iget_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_iget_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_iget_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/instanceof.c b/src/arch/dalvik/opcodes/instanceof.c
index 2054ca5..d65c6bd 100644
--- a/src/arch/dalvik/opcodes/instanceof.c
+++ b/src/arch/dalvik/opcodes/instanceof.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_instance_of(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/invoke.c b/src/arch/dalvik/opcodes/invoke.c
index 1f38d18..9133e79 100644
--- a/src/arch/dalvik/opcodes/invoke.c
+++ b/src/arch/dalvik/opcodes/invoke.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *data, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -292,7 +292,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -305,7 +305,7 @@ GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -314,7 +314,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -329,7 +329,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -342,7 +342,7 @@ GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -351,7 +351,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_35C | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -366,7 +366,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -379,7 +379,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -388,7 +388,7 @@ GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *data, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_3RC | DALVIK_OP_POOL(DPT_METHOD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/iput.c b/src/arch/dalvik/opcodes/iput.c
index ff99bae..434eec7 100644
--- a/src/arch/dalvik/opcodes/iput.c
+++ b/src/arch/dalvik/opcodes/iput.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_iput(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_iput_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_iput_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_iput_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/monitor.c b/src/arch/dalvik/opcodes/monitor.c
index 6f4bd34..866e984 100644
--- a/src/arch/dalvik/opcodes/monitor.c
+++ b/src/arch/dalvik/opcodes/monitor.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/move.c b/src/arch/dalvik/opcodes/move.c
index 0cb49f8..ba2d89b 100644
--- a/src/arch/dalvik/opcodes/move.c
+++ b/src/arch/dalvik/opcodes/move.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_move(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_move_exception(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_move_16(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_move_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_move_result(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *data, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -475,7 +475,7 @@ GArchInstruction *dalvik_read_instr_move_wide(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -484,7 +484,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_32X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -501,7 +501,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -514,7 +514,7 @@ GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -523,7 +523,7 @@ GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *data, off_t *
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/mul.c b/src/arch/dalvik/opcodes/mul.c
index 443df5e..67a343b 100644
--- a/src/arch/dalvik/opcodes/mul.c
+++ b/src/arch/dalvik/opcodes/mul.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-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 *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *data, off_t *p
* *
******************************************************************************/
-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 *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-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 *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_mul_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_mul_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-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 *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/neg.c b/src/arch/dalvik/opcodes/neg.c
index 6b41259..5f9a985 100644
--- a/src/arch/dalvik/opcodes/neg.c
+++ b/src/arch/dalvik/opcodes/neg.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_neg_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_neg_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_neg_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_neg_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/new.c b/src/arch/dalvik/opcodes/new.c
index 8f632f6..3320540 100644
--- a/src/arch/dalvik/opcodes/new.c
+++ b/src/arch/dalvik/opcodes/new.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_new_array(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_new_instance(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_TYPE)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/nop.c b/src/arch/dalvik/opcodes/nop.c
index 38dd193..b90c350 100644
--- a/src/arch/dalvik/opcodes/nop.c
+++ b/src/arch/dalvik/opcodes/nop.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_nop(const bin_t *data, off_t *pos, off_t len
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/not.c b/src/arch/dalvik/opcodes/not.c
index 91f69cf..41ae2d4 100644
--- a/src/arch/dalvik/opcodes/not.c
+++ b/src/arch/dalvik/opcodes/not.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_not_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_not_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/or.c b/src/arch/dalvik/opcodes/or.c
index 57d3119..8904f48 100644
--- a/src/arch/dalvik/opcodes/or.c
+++ b/src/arch/dalvik/opcodes/or.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_or_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_or_long(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/rem.c b/src/arch/dalvik/opcodes/rem.c
index 54537f8..0ba12de 100644
--- a/src/arch/dalvik/opcodes/rem.c
+++ b/src/arch/dalvik/opcodes/rem.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_rem_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *data, off_t *p
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_rem_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_rem_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_rem_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/ret.c b/src/arch/dalvik/opcodes/ret.c
index 0fc27a2..7e53ada 100644
--- a/src/arch/dalvik/opcodes/ret.c
+++ b/src/arch/dalvik/opcodes/ret.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_return(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_return_object(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_10X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_return_void(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_return_wide(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/rsub.c b/src/arch/dalvik/opcodes/rsub.c
index 73010a2..9ee9331 100644
--- a/src/arch/dalvik/opcodes/rsub.c
+++ b/src/arch/dalvik/opcodes/rsub.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/sget.c b/src/arch/dalvik/opcodes/sget.c
index d95f44f..bc1aca0 100644
--- a/src/arch/dalvik/opcodes/sget.c
+++ b/src/arch/dalvik/opcodes/sget.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_sget(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_sget_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_sget_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_sget_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/shl.c b/src/arch/dalvik/opcodes/shl.c
index 8c3e220..3ee88b8 100644
--- a/src/arch/dalvik/opcodes/shl.c
+++ b/src/arch/dalvik/opcodes/shl.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_shl_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_shl_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/shr.c b/src/arch/dalvik/opcodes/shr.c
index f29a9d4..1656164 100644
--- a/src/arch/dalvik/opcodes/shr.c
+++ b/src/arch/dalvik/opcodes/shr.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_shr_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_shr_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/sput.c b/src/arch/dalvik/opcodes/sput.c
index c281ea5..281df25 100644
--- a/src/arch/dalvik/opcodes/sput.c
+++ b/src/arch/dalvik/opcodes/sput.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_sput(const bin_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -107,7 +107,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -120,7 +120,7 @@ GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -129,7 +129,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -144,7 +144,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -157,7 +157,7 @@ GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -166,7 +166,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -181,7 +181,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -194,7 +194,7 @@ GArchInstruction *dalvik_read_instr_sput_char(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -203,7 +203,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -218,7 +218,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -231,7 +231,7 @@ GArchInstruction *dalvik_read_instr_sput_object(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -240,7 +240,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -255,7 +255,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -268,7 +268,7 @@ GArchInstruction *dalvik_read_instr_sput_short(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -277,7 +277,7 @@ GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21C | DALVIK_OP_POOL(DPT_FIELD)))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/sub.c b/src/arch/dalvik/opcodes/sub.c
index 2f2a6c8..98af25e 100644
--- a/src/arch/dalvik/opcodes/sub.c
+++ b/src/arch/dalvik/opcodes/sub.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, of
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *p
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_sub_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-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 *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/switch.c b/src/arch/dalvik/opcodes/switch.c
index 905ce74..8b3c7a6 100644
--- a/src/arch/dalvik/opcodes/switch.c
+++ b/src/arch/dalvik/opcodes/switch.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -70,7 +70,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -83,7 +83,7 @@ GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -92,7 +92,7 @@ GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_31T))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/throw.c b/src/arch/dalvik/opcodes/throw.c
index 196f986..18602bc 100644
--- a/src/arch/dalvik/opcodes/throw.c
+++ b/src/arch/dalvik/opcodes/throw.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_throw(const bin_t *data, off_t *pos, off_t l
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_11X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/to.c b/src/arch/dalvik/opcodes/to.c
index be0c8c9..a8d3962 100644
--- a/src/arch/dalvik/opcodes/to.c
+++ b/src/arch/dalvik/opcodes/to.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *data, off_t *pos, o
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -267,7 +267,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -280,7 +280,7 @@ GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -289,7 +289,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -306,7 +306,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -319,7 +319,7 @@ GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -328,7 +328,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -345,7 +345,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -358,7 +358,7 @@ GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -367,7 +367,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -384,7 +384,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -397,7 +397,7 @@ GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -406,7 +406,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -423,7 +423,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -436,7 +436,7 @@ GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *data, off_t *po
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -445,7 +445,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -462,7 +462,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -475,7 +475,7 @@ GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -484,7 +484,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -501,7 +501,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -514,7 +514,7 @@ GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -523,7 +523,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -540,7 +540,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -553,7 +553,7 @@ GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -562,7 +562,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -579,7 +579,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -592,7 +592,7 @@ GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -601,7 +601,7 @@ GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *data, off_t *pos, o
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/ushr.c b/src/arch/dalvik/opcodes/ushr.c
index 4b2fe80..ed377de 100644
--- a/src/arch/dalvik/opcodes/ushr.c
+++ b/src/arch/dalvik/opcodes/ushr.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *data, off_t *pos
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *data, off_t *pos, off
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *data, off_t *po
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/opcodes/xor.c b/src/arch/dalvik/opcodes/xor.c
index 48dcf99..bf41560 100644
--- a/src/arch/dalvik/opcodes/xor.c
+++ b/src/arch/dalvik/opcodes/xor.c
@@ -33,7 +33,7 @@
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -46,7 +46,7 @@
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -55,7 +55,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -72,7 +72,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -85,7 +85,7 @@ GArchInstruction *dalvik_read_instr_xor_int(const bin_t *data, off_t *pos, off_t
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -94,7 +94,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -111,7 +111,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -124,7 +124,7 @@ GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -133,7 +133,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22B))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -150,7 +150,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -163,7 +163,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -172,7 +172,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_22S))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -189,7 +189,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -202,7 +202,7 @@ GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *data, off_t *pos,
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -211,7 +211,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_23X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X))
{
g_object_unref(G_OBJECT(result));
return NULL;
@@ -228,7 +228,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite 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. *
@@ -241,7 +241,7 @@ GArchInstruction *dalvik_read_instr_xor_long(const bin_t *data, off_t *pos, off_
* *
******************************************************************************/
-GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
+GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt)
{
GArchInstruction *result; /* Instruction à retourner */
SourceEndian endian; /* Boutisme lié au binaire */
@@ -250,7 +250,7 @@ GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *data, off_t *pos
endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc));
- if (!dalvik_read_operands(result, fmt, data, pos, len, endian, DALVIK_OPT_12X))
+ if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X))
{
g_object_unref(G_OBJECT(result));
return NULL;
diff --git a/src/arch/dalvik/operand.c b/src/arch/dalvik/operand.c
index a2d04b0..ee033e7 100644
--- a/src/arch/dalvik/operand.c
+++ b/src/arch/dalvik/operand.c
@@ -72,7 +72,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *, const GDexFormat *
* format = format du fichier contenant le code. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* low = position éventuelle des 4 bits visés. [OUT] *
* endian = boutisme lié au binaire accompagnant. *
* model = type d'opérandes attendues. *
@@ -86,7 +86,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *, const GDexFormat *
* *
******************************************************************************/
-static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model, va_list ap)
+static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model, va_list ap)
{
bool result; /* Bilan à retourner */
DalvikOperandID *types; /* Liste des chargements */
@@ -281,64 +281,66 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
for (iter = types; *iter != G_TYPE_INVALID && result; iter++)
{
+ op = NULL; /* Nul de GCC */
+
switch (*iter)
{
case DOI_REGISTER_4:
- op = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+ op = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
break;
case DOI_REGISTER_8:
- op = g_dalvik_register_operand_new(data, pos, len, NULL, MDS_8_BITS, endian);
+ op = g_dalvik_register_operand_new(data, pos, end, NULL, MDS_8_BITS, endian);
break;
case DOI_REGISTER_16:
- op = g_dalvik_register_operand_new(data, pos, len, NULL, MDS_16_BITS, endian);
+ op = g_dalvik_register_operand_new(data, pos, end, NULL, MDS_16_BITS, endian);
break;
case DOI_IMMEDIATE_4:
- op = _g_imm_operand_new_from_data(MDS_4_BITS, data, pos, len, low, endian);
+ op = _g_imm_operand_new_from_data(MDS_4_BITS, data, pos, end, low, endian);
break;
case DOI_IMMEDIATE_8:
- op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, len, endian);
+ op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, end, endian);
break;
case DOI_IMMEDIATE_16:
- op = g_imm_operand_new_from_data(MDS_16_BITS, data, pos, len, endian);
+ op = g_imm_operand_new_from_data(MDS_16_BITS, data, pos, end, endian);
break;
case DOI_IMMEDIATE_32:
- op = g_imm_operand_new_from_data(MDS_32_BITS, data, pos, len, endian);
+ op = g_imm_operand_new_from_data(MDS_32_BITS, data, pos, end, endian);
break;
case DOI_IMMEDIATE_64:
- op = g_imm_operand_new_from_data(MDS_64_BITS, data, pos, len, endian);
+ op = g_imm_operand_new_from_data(MDS_64_BITS, data, pos, end, endian);
break;
case DOI_IMMEDIATE_H16:
- result = read_u16(&value16, data, pos, len, endian);
+ result = read_u16(&value16, data, pos, end, endian);
if (result)
op = g_imm_operand_new_from_value(MDS_32_BITS_SIGNED, ((uint32_t)value16) << 16);
break;
case DOI_POOL_CONST:
- op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+ op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
break;
case DOI_POOL_CONST_WIDE:
- op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_32_BITS, endian);
+ op = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_32_BITS, endian);
break;
case DOI_TARGET_8:
- op = g_dalvik_target_operand_new(data, pos, len, MDS_8_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+ op = g_dalvik_target_operand_new(data, pos, end, MDS_8_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
break;
case DOI_TARGET_16:
- op = g_dalvik_target_operand_new(data, pos, len, MDS_16_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+ op = g_dalvik_target_operand_new(data, pos, end, MDS_16_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
break;
case DOI_TARGET_32:
- op = g_dalvik_target_operand_new(data, pos, len, MDS_32_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
+ op = g_dalvik_target_operand_new(data, pos, end, MDS_32_BITS_SIGNED, endian, va_arg(ap, vmpa_t));
break;
default:
@@ -363,7 +365,7 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
* format = format du fichier contenant le code. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* low = position éventuelle des 4 bits visés. [OUT] *
* endian = boutisme lié au binaire accompagnant. *
* model = type d'opérandes attendues. *
@@ -376,7 +378,7 @@ static bool dalvik_read_basic_operands(GArchInstruction *instr, const GDexFormat
* *
******************************************************************************/
-static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model)
+static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model)
{
GArchOperand *opa; /* Opérande vA décodé */
uint8_t b; /* Nbre. de registres utilisés */
@@ -388,13 +390,13 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
- opa = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+ opa = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
- if (!read_u4(&b, data, pos, len, low, endian))
+ if (!read_u4(&b, data, pos, end, low, endian))
goto err_va;
- target1 = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+ target1 = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
if (target1 == NULL) goto err_target1;
@@ -416,7 +418,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
for (i = 0; i < MIN(b, 4); i++)
{
- op = g_dalvik_register_operand_new(data, pos, len, low, MDS_4_BITS, endian);
+ op = g_dalvik_register_operand_new(data, pos, end, low, MDS_4_BITS, endian);
if (op == NULL) goto err_registers;
g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op);
@@ -461,7 +463,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
* format = format du fichier contenant le code. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* low = position éventuelle des 4 bits visés. [OUT] *
* endian = boutisme lié au binaire accompagnant. *
* model = type d'opérandes attendues. *
@@ -474,7 +476,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, const GDexFormat
* *
******************************************************************************/
-static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian, DalvikOperandType model)
+static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian, DalvikOperandType model)
{
uint8_t a; /* Nbre. de registres utilisés */
uint16_t b; /* Indice dans la table const. */
@@ -484,13 +486,13 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
uint16_t c; /* Indice de registre */
GArchOperand *op; /* Opérande unique décodé */
- if (!read_u8(&a, data, pos, len, endian))
+ if (!read_u8(&a, data, pos, end, endian))
return false;
- if (!read_u16(&b, data, pos, len, endian))
+ if (!read_u16(&b, data, pos, end, endian))
return false;
- target = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, len, MDS_16_BITS, endian);
+ target = g_dalvik_pool_operand_new(format, DALVIK_OP_GET_POOL(model), data, pos, end, MDS_16_BITS, endian);
if (target == NULL) return false;
/* Mise en place des arguments */
@@ -500,7 +502,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
for (i = 0; i < a; i++)
{
- if (i == 0 && !read_u16(&c, data, pos, len, endian))
+ if (i == 0 && !read_u16(&c, data, pos, end, endian))
goto drvo_registers;
op = g_dalvik_register_operand_new_from_existing(g_dalvik_register_new(c + i));
@@ -542,7 +544,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
* format = format du fichier contenant le code. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* endian = boutisme lié au binaire accompagnant. *
* model = type d'opérandes attendues. *
* ... = éventuelles données complémentaires. *
@@ -555,7 +557,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, const GDexFor
* *
******************************************************************************/
-bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t len, SourceEndian endian, DalvikOperandType model, ...)
+bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, const bin_t *data, off_t *pos, off_t end, SourceEndian endian, DalvikOperandType model, ...)
{
bool result; /* Bilan à retourner */
@@ -602,18 +604,18 @@ bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, con
case DALVIK_OPT_32X:
case DALVIK_OPT_51L:
va_start(ap, model);
- result = dalvik_read_basic_operands(instr, format, data, pos, len, &low, endian, model, ap);
+ result = dalvik_read_basic_operands(instr, format, data, pos, end, &low, endian, model, ap);
va_end(ap);
break;
case DALVIK_OPT_35C:
- result = dalvik_read_fixed_operands(instr, format, data, pos, len, &low, endian, model);
+ result = dalvik_read_fixed_operands(instr, format, data, pos, end, &low, endian, model);
break;
case DALVIK_OPT_3RC:
case DALVIK_OPT_3RMS:
case DALVIK_OPT_3RFS:
- result = dalvik_read_variatic_operands(instr, format, data, pos, len, &low, endian, model);
+ result = dalvik_read_variatic_operands(instr, format, data, pos, end, &low, endian, model);
break;
default:
@@ -627,7 +629,7 @@ bool dalvik_read_operands(GArchInstruction *instr, const GDexFormat *format, con
- if (*pos < len)
+ if (*pos < end)
{
(*pos)++;
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index 1e69a18..2c1f653 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -118,7 +118,7 @@ static void g_dalvik_pool_operand_init(GDalvikPoolOperand *operand)
* type = type de table visée avec la référence. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* size = taille de l'opérande, et donc du registre. *
* endian = ordre des bits dans la source. *
* *
@@ -130,7 +130,7 @@ static void g_dalvik_pool_operand_init(GDalvikPoolOperand *operand)
* *
******************************************************************************/
-GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType type, const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, SourceEndian endian)
+GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType type, const bin_t *data, off_t *pos, off_t end, MemoryDataSize size, SourceEndian endian)
{
GDalvikPoolOperand *result; /* Structure à retourner */
uint8_t index8; /* Indice sur 8 bits */
@@ -140,10 +140,10 @@ GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType
switch (size)
{
case MDS_8_BITS:
- test = read_u8(&index8, data, pos, len, endian);
+ test = read_u8(&index8, data, pos, end, endian);
break;
case MDS_16_BITS:
- test = read_u16(&index16, data, pos, len, endian);
+ test = read_u16(&index16, data, pos, end, endian);
break;
default:
test = false;
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index 45e965c..00d5699 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -113,7 +113,7 @@ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *operand)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* low = position éventuelle des 4 bits visés. [OUT] *
* size = taille de l'opérande, et donc du registre. *
* endian = ordre des bits dans la source. *
@@ -126,7 +126,7 @@ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *operand)
* *
******************************************************************************/
-GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t len, bool *low, MemoryDataSize size, SourceEndian endian)
+GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t end, bool *low, MemoryDataSize size, SourceEndian endian)
{
GDalvikRegisterOperand *result; /* Structure à retourner */
uint8_t index8; /* Indice sur 8 bits */
@@ -136,13 +136,13 @@ GArchOperand *g_dalvik_register_operand_new(const bin_t *data, off_t *pos, off_t
switch (size)
{
case MDS_4_BITS:
- test = read_u4(&index8, data, pos, len, low, endian);
+ test = read_u4(&index8, data, pos, end, low, endian);
break;
case MDS_8_BITS:
- test = read_u8(&index8, data, pos, len, endian);
+ test = read_u8(&index8, data, pos, end, endian);
break;
case MDS_16_BITS:
- test = read_u16(&index16, data, pos, len, endian);
+ test = read_u16(&index16, data, pos, end, endian);
break;
default:
test = false;
diff --git a/src/arch/dalvik/operands/target.c b/src/arch/dalvik/operands/target.c
index 6fe4df4..f53bb7b 100644
--- a/src/arch/dalvik/operands/target.c
+++ b/src/arch/dalvik/operands/target.c
@@ -106,7 +106,7 @@ static void g_dalvik_target_operand_init(GDalvikTargetOperand *operand)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* size = taille de l'opérande. *
* endian = ordre des bits dans la source. *
* base = adresse de référence pour le calcul. *
@@ -119,7 +119,7 @@ static void g_dalvik_target_operand_init(GDalvikTargetOperand *operand)
* *
******************************************************************************/
-GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, SourceEndian endian, vmpa_t base)
+GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t end, MemoryDataSize size, SourceEndian endian, vmpa_t base)
{
GDalvikTargetOperand *result; /* Structure à retourner */
int8_t val8; /* Valeur sur 8 bits */
@@ -130,15 +130,15 @@ GArchOperand *g_dalvik_target_operand_new(const bin_t *data, off_t *pos, off_t l
switch (size)
{
case MDS_8_BITS_SIGNED:
- read_s8(&val8, data, pos, len, endian);
+ read_s8(&val8, data, pos, end, endian);
address = base + val8 * sizeof(uint16_t);
break;
case MDS_16_BITS_SIGNED:
- read_s16(&val16, data, pos, len, endian);
+ read_s16(&val16, data, pos, end, endian);
address = base + val16 * sizeof(uint16_t);
break;
case MDS_32_BITS_SIGNED:
- read_s32(&val32, data, pos, len, endian);
+ read_s32(&val32, data, pos, end, endian);
address = base + val32 * sizeof(uint16_t);
break;
default:
diff --git a/src/arch/dalvik/processor.c b/src/arch/dalvik/processor.c
index e105fcd..fdfb38d 100644
--- a/src/arch/dalvik/processor.c
+++ b/src/arch/dalvik/processor.c
@@ -55,6 +55,12 @@ static void g_dalvik_processor_class_init(GDalvikProcessorClass *);
/* Initialise une instance de processeur de VM Dalvik. */
static void g_dalvik_processor_init(GDalvikProcessor *);
+/* Supprime toutes les références externes. */
+static void g_dalvik_processor_dispose(GDalvikProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dalvik_processor_finalize(GDalvikProcessor *);
+
/* Fournit un contexte pour l'exécution du processeur Dalvik. */
static GDalvikContext *g_dalvik_processor_get_context(const GDalvikProcessor *);
@@ -87,6 +93,17 @@ G_DEFINE_TYPE(GDalvikProcessor, g_dalvik_processor, G_TYPE_ARCH_PROCESSOR);
static void g_dalvik_processor_class_init(GDalvikProcessorClass *klass)
{
+ GObjectClass *object; /* Autre version de la classe */
+ GArchProcessorClass *proc; /* Encore une autre vision... */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_processor_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_dalvik_processor_finalize;
+
+ proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+ proc->decode = (decode_instruction_fc)g_dalvik_processor_decode_instruction;
}
@@ -115,7 +132,44 @@ static void g_dalvik_processor_init(GDalvikProcessor *proc)
parent->get_ctx = (get_processor_context_fc)g_dalvik_processor_get_context;
parent->get_dec_ctx = (get_decomp_context_fc)g_dalvik_processor_get_decomp_context;
- parent->decode = (decode_instruction_fc)g_dalvik_processor_decode_instruction;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dalvik_processor_dispose(GDalvikProcessor *proc)
+{
+ G_OBJECT_CLASS(g_dalvik_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : bookmark = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dalvik_processor_finalize(GDalvikProcessor *proc)
+{
+ G_OBJECT_CLASS(g_dalvik_processor_parent_class)->finalize(G_OBJECT(proc));
}
@@ -186,7 +240,7 @@ static GDalvikDContext *g_dalvik_processor_get_decomp_context(const GDalvikProce
* Paramètres : proc = architecture visée par la procédure. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* *
* Description : Décode une pseudo-instruction dans un flux de données. *
@@ -197,7 +251,7 @@ static GDalvikDContext *g_dalvik_processor_get_decomp_context(const GDalvikProce
* *
******************************************************************************/
-static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcessor *proc, const bin_t *data, off_t *pos, off_t len, vmpa_t addr)
+static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcessor *proc, const bin_t *data, off_t *pos, off_t end, vmpa_t addr)
{
GArchInstruction *result; /* Instruction à renvoyer */
off_t tmp; /* Position modifiable */
@@ -208,18 +262,18 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
tmp = *pos;
- if (!read_u16(&ident, data, &tmp, len, SRE_LITTLE))
+ if (!read_u16(&ident, data, &tmp, end, SRE_LITTLE))
return NULL;
switch (ident)
{
case DPO_PACKED_SWITCH:
case DPO_SPARSE_SWITCH:
- result = g_dalvik_switch_instr_new(data, pos, len, addr, proc);
+ result = g_dalvik_switch_instr_new(data, pos, end, addr, proc);
break;
case DPO_FILL_ARRAY_DATA:
- result = g_dalvik_fill_instr_new(data, pos, len, addr, proc);
+ result = g_dalvik_fill_instr_new(data, pos, end, addr, proc);
break;
default:
@@ -239,7 +293,7 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
* ctx = contexte lié à l'exécution du processeur. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* format = format du fichier contenant le code. *
* *
@@ -251,7 +305,7 @@ static GArchInstruction *g_dalvik_guess_pseudo_instruction(const GDalvikProcesso
* *
******************************************************************************/
-static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProcessor *proc, GDalvikContext *ctx, const bin_t *data, off_t *pos, off_t len, vmpa_t addr, GDexFormat *format)
+static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProcessor *proc, GDalvikContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GDexFormat *format)
{
GArchInstruction *result; /* Instruction à renvoyer */
DalvikOpcodes id; /* Identifiant d'instruction */
@@ -480,17 +534,17 @@ static GArchInstruction *g_dalvik_processor_decode_instruction(const GDalvikProc
};
/* Pseudo-instruction... */
- result = g_dalvik_guess_pseudo_instruction(proc, data, pos, len, addr);
+ result = g_dalvik_guess_pseudo_instruction(proc, data, pos, end, addr);
/* ... ou instruction classique */
if (result == NULL)
{
- id = dalvik_guess_next_instruction(data, *pos, len);
+ id = dalvik_guess_next_instruction(data, *pos, end);
if (id != DOP_COUNT)
{
(*pos)++;
- result = decodings[id](data, pos, len, addr, proc, format);
+ result = decodings[id](data, pos, end, addr, proc, format);
}
}
diff --git a/src/arch/dalvik/pseudo/fill.c b/src/arch/dalvik/pseudo/fill.c
index 9fa4a59..702f4b9 100644
--- a/src/arch/dalvik/pseudo/fill.c
+++ b/src/arch/dalvik/pseudo/fill.c
@@ -110,7 +110,7 @@ static void g_dalvik_fill_instr_init(GDalvikFillInstr *instr)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* proc = architecture ciblée par le désassemblage. *
* *
@@ -122,21 +122,21 @@ static void g_dalvik_fill_instr_init(GDalvikFillInstr *instr)
* *
******************************************************************************/
-GArchInstruction *g_dalvik_fill_instr_new(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc)
+GArchInstruction *g_dalvik_fill_instr_new(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc)
{
GDalvikFillInstr *result; /* Structure à retourner */
uint16_t ident; /* Valeur lue dans le code */
result = g_object_new(G_TYPE_DALVIK_FILL_INSTR, NULL);
- if (!read_u16(&ident, data, pos, len, SRE_LITTLE))
+ if (!read_u16(&ident, data, pos, end, SRE_LITTLE))
goto gdfin_bad;
G_DALVIK_INSTRUCTION(result)->ptype = DPO_FILL_ARRAY_DATA;
- if (!read_u16(&result->array_width, data, pos, len, SRE_LITTLE))
+ if (!read_u16(&result->array_width, data, pos, end, SRE_LITTLE))
goto gdfin_bad;
- if (!read_u32(&result->array_size, data, pos, len, SRE_LITTLE))
+ if (!read_u32(&result->array_size, data, pos, end, SRE_LITTLE))
goto gdfin_bad;
*pos += result->array_width * result->array_size;
diff --git a/src/arch/dalvik/pseudo/switch.c b/src/arch/dalvik/pseudo/switch.c
index 5548258..c97c82b 100644
--- a/src/arch/dalvik/pseudo/switch.c
+++ b/src/arch/dalvik/pseudo/switch.c
@@ -109,7 +109,7 @@ static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *instr)
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* len = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* proc = architecture ciblée par le désassemblage. *
* *
@@ -121,14 +121,14 @@ static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *instr)
* *
******************************************************************************/
-GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, const GDalvikProcessor *proc)
+GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc)
{
GDalvikSwitchInstr *result; /* Structure à retourner */
uint16_t ident; /* Valeur lue dans le code */
result = g_object_new(G_TYPE_DALVIK_SWITCH_INSTR, NULL);
- if (!read_u16(&ident, data, pos, len, SRE_LITTLE))
+ if (!read_u16(&ident, data, pos, end, SRE_LITTLE))
goto gdsin_bad;
if (ident != DPO_PACKED_SWITCH && ident != DPO_SPARSE_SWITCH)
@@ -136,7 +136,7 @@ GArchInstruction *g_dalvik_switch_instr_new(const bin_t *data, off_t *pos, off_t
G_DALVIK_INSTRUCTION(result)->ptype = ident;
- if (!read_u16(&result->switch_size, data, pos, len, SRE_LITTLE))
+ if (!read_u16(&result->switch_size, data, pos, end, SRE_LITTLE))
goto gdsin_bad;
if (ident != DPO_PACKED_SWITCH)
diff --git a/src/arch/immediate.c b/src/arch/immediate.c
index d9e36f2..46abe62 100644
--- a/src/arch/immediate.c
+++ b/src/arch/immediate.c
@@ -148,7 +148,7 @@ static void g_imm_operand_init(GImmOperand *operand)
* Paramètres : size = taille de l'opérande souhaitée. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* end = limite des données à analyser. *
* low = position éventuelle des 4 bits visés. [OUT] *
* endian = ordre des bits dans la source. *
* *
@@ -160,7 +160,7 @@ static void g_imm_operand_init(GImmOperand *operand)
* *
******************************************************************************/
-GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *data, off_t *pos, off_t len, bool *low, SourceEndian endian)
+GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *data, off_t *pos, off_t end, bool *low, SourceEndian endian)
{
GImmOperand *result; /* Opérande à retourner */
@@ -171,52 +171,52 @@ GArchOperand *_g_imm_operand_new_from_data(MemoryDataSize size, const bin_t *dat
switch (size)
{
case MDS_4_BITS_UNSIGNED:
- if (!read_u4(&result->unsigned_imm.val8, data, pos, len, low, endian))
+ if (!read_u4(&result->unsigned_imm.val8, data, pos, end, low, endian))
goto gionfd_error;
break;
case MDS_8_BITS_UNSIGNED:
- if (!read_u8(&result->unsigned_imm.val8, data, pos, len, endian))
+ if (!read_u8(&result->unsigned_imm.val8, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_16_BITS_UNSIGNED:
- if (!read_u16(&result->unsigned_imm.val16, data, pos, len, endian))
+ if (!read_u16(&result->unsigned_imm.val16, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_32_BITS_UNSIGNED:
- if (!read_u32(&result->unsigned_imm.val32, data, pos, len, endian))
+ if (!read_u32(&result->unsigned_imm.val32, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_64_BITS_UNSIGNED:
- if (!read_u64(&result->unsigned_imm.val64, data, pos, len, endian))
+ if (!read_u64(&result->unsigned_imm.val64, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_4_BITS_SIGNED:
- if (!read_s4(&result->signed_imm.val8, data, pos, len, low, endian))
+ if (!read_s4(&result->signed_imm.val8, data, pos, end, low, endian))
goto gionfd_error;
break;
case MDS_8_BITS_SIGNED:
- if (!read_s8(&result->signed_imm.val8, data, pos, len, endian))
+ if (!read_s8(&result->signed_imm.val8, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_16_BITS_SIGNED:
- if (!read_s16(&result->signed_imm.val16, data, pos, len, endian))
+ if (!read_s16(&result->signed_imm.val16, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_32_BITS_SIGNED:
- if (!read_s32(&result->signed_imm.val32, data, pos, len, endian))
+ if (!read_s32(&result->signed_imm.val32, data, pos, end, endian))
goto gionfd_error;
break;
case MDS_64_BITS_SIGNED:
- if (!read_s64(&result->signed_imm.val64, data, pos, len, endian))
+ if (!read_s64(&result->signed_imm.val64, data, pos, end, endian))
goto gionfd_error;
break;
diff --git a/src/arch/jvm/processor.c b/src/arch/jvm/processor.c
index 10efc5b..5872fd9 100644
--- a/src/arch/jvm/processor.c
+++ b/src/arch/jvm/processor.c
@@ -52,6 +52,12 @@ static void g_jvm_processor_class_init(GJvmProcessorClass *);
/* Initialise une instance de processeur de JVM. */
static void g_jvm_processor_init(GJvmProcessor *);
+/* Supprime toutes les références externes. */
+static void g_jvm_processor_dispose(GJvmProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_jvm_processor_finalize(GJvmProcessor *);
+
/* Décode une instruction dans un flux de données. */
static GArchInstruction *g_jvm_processor_decode_instruction(const GJvmProcessor *, const bin_t *, off_t *, off_t, vmpa_t);
@@ -75,6 +81,17 @@ G_DEFINE_TYPE(GJvmProcessor, g_jvm_processor, G_TYPE_ARCH_PROCESSOR);
static void g_jvm_processor_class_init(GJvmProcessorClass *klass)
{
+ GObjectClass *object; /* Autre version de la classe */
+ GArchProcessorClass *proc; /* Encore une autre vision... */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_jvm_processor_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_jvm_processor_finalize;
+
+ proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+ proc->decode = (decode_instruction_fc)g_jvm_processor_decode_instruction;
}
@@ -100,7 +117,43 @@ static void g_jvm_processor_init(GJvmProcessor *proc)
parent->endianness = SRE_BIG;
parent->memsize = MDS_32_BITS;
- parent->decode = (decode_instruction_fc)g_jvm_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_jvm_processor_dispose(GJvmProcessor *proc)
+{
+ G_OBJECT_CLASS(g_jvm_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : bookmark = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_jvm_processor_finalize(GJvmProcessor *proc)
+{
+ G_OBJECT_CLASS(g_jvm_processor_parent_class)->finalize(G_OBJECT(proc));
}
diff --git a/src/arch/mips/processor.c b/src/arch/mips/processor.c
index aa288b1..15de6cc 100644
--- a/src/arch/mips/processor.c
+++ b/src/arch/mips/processor.c
@@ -51,6 +51,12 @@ static void g_mips_processor_class_init(GMipsProcessorClass *);
/* Initialise la classe des lignes de descriptions initiales. */
static void g_mips_processor_init(GMipsProcessor *);
+/* Supprime toutes les références externes. */
+static void g_mips_processor_dispose(GMipsProcessor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_mips_processor_finalize(GMipsProcessor *);
+
/* Décode une instruction dans un flux de données. */
static GArchInstruction *g_mips_processor_decode_instruction(const GMipsProcessor *, const bin_t *, off_t *, off_t, vmpa_t);
@@ -74,6 +80,17 @@ G_DEFINE_TYPE(GMipsProcessor, g_mips_processor, G_TYPE_ARCH_PROCESSOR);
static void g_mips_processor_class_init(GMipsProcessorClass *klass)
{
+ GObjectClass *object; /* Autre version de la classe */
+ GArchProcessorClass *proc; /* Encore une autre vision... */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_mips_processor_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_mips_processor_finalize;
+
+ proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+ proc->decode = (decode_instruction_fc)g_mips_processor_decode_instruction;
}
@@ -99,7 +116,43 @@ static void g_mips_processor_init(GMipsProcessor *proc)
parent->endianness = SRE_BIG;
parent->memsize = MDS_32_BITS;
- parent->decode = (decode_instruction_fc)g_mips_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_mips_processor_dispose(GMipsProcessor *proc)
+{
+ G_OBJECT_CLASS(g_mips_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : bookmark = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_mips_processor_finalize(GMipsProcessor *proc)
+{
+ G_OBJECT_CLASS(g_mips_processor_parent_class)->finalize(G_OBJECT(proc));
}
diff --git a/src/arch/processor-int.h b/src/arch/processor-int.h
index 82f402a..c8263f7 100644
--- a/src/arch/processor-int.h
+++ b/src/arch/processor-int.h
@@ -67,7 +67,6 @@ struct _GArchProcessor
get_processor_context_fc get_ctx; /* Obtention d'un contexte #1 */
get_decomp_context_fc get_dec_ctx; /* Obtention d'un contexte #2 */
- decode_instruction_fc decode; /* Traduction en instructions */
};
@@ -82,6 +81,8 @@ struct _GArchProcessorClass
{
GObjectClass parent; /* A laisser en premier */
+ decode_instruction_fc decode; /* Traduction en instructions */
+
};
diff --git a/src/arch/processor.c b/src/arch/processor.c
index ff2318d..8ca58a7 100644
--- a/src/arch/processor.c
+++ b/src/arch/processor.c
@@ -230,8 +230,7 @@ MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *proc)
* ctx = contexte lié à l'exécution du processeur. *
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* base = position physique du bloc de code courant. *
+* end = limite des données à analyser. *
* addr = adresse virtuelle de l'instruction. *
* format = format du fichier contenant le code. *
* *
@@ -243,7 +242,7 @@ MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *proc)
* *
******************************************************************************/
-GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t len, off_t base, vmpa_t addr, GBinFormat *format)
+GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc, GProcContext *ctx, const bin_t *data, off_t *pos, off_t end, vmpa_t addr, GBinFormat *format)
{
GArchInstruction *result; /* Instruction à renvoyer */
off_t old_pos; /* Sauvegarde de la position */
@@ -251,7 +250,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
old_pos = *pos;
- result = proc->decode(proc, ctx, data, pos, len, addr, format);
+ result = G_ARCH_PROCESSOR_GET_CLASS(proc)->decode(proc, ctx, data, pos, end, addr, format);
if (result == NULL || result == SKIPPED_INSTR)
{
@@ -260,7 +259,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
skipped = (result == SKIPPED_INSTR);
*pos = old_pos;
- result = g_db_instruction_new_from_data(data, pos, len, base, proc);
+ result = g_db_instruction_new_from_data(data, pos, end, addr, proc);
#ifdef DEBUG /* FIXME */
if (skipped)
@@ -268,7 +267,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
#endif
}
- g_arch_instruction_set_location(result, base + old_pos, *pos - old_pos, addr);
+ g_arch_instruction_set_location(result, old_pos, *pos - old_pos, addr);
return result;
diff --git a/src/arch/processor.h b/src/arch/processor.h
index b6d5f00..32dfbdb 100644
--- a/src/arch/processor.h
+++ b/src/arch/processor.h
@@ -39,7 +39,10 @@
#define G_TYPE_ARCH_PROCESSOR g_arch_processor_get_type()
#define G_ARCH_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arch_processor_get_type(), GArchProcessor))
#define G_IS_ARCH_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arch_processor_get_type()))
-#define G_ARCH_PROCESSOR_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_arch_processor_get_type(), GArchProcessorIface))
+#define G_ARCH_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
+#define G_IS_ARCH_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARCH_PROCESSOR))
+#define G_ARCH_PROCESSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
+
/* Ligne de représentation générique (instance) */
@@ -68,7 +71,7 @@ MemoryDataSize g_arch_processor_get_memory_size(const GArchProcessor *);
MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *);
/* Décode une instruction dans un flux de données. */
-GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *, GProcContext *, const bin_t *, off_t *, off_t, off_t, vmpa_t, GBinFormat *);
+GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *, GProcContext *, const bin_t *, off_t *, off_t, vmpa_t, GBinFormat *);
diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index 24d5792..c6972af 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -28,6 +28,8 @@
#include <malloc.h>
+#include "../common/io.h"
+
@@ -46,11 +48,11 @@
* *
******************************************************************************/
-vmpa2_t *make_vmpa(off_t phy, uint64_t virt)
+vmpa2t *make_vmpa(off_t phy, uint64_t virt)
{
- vmpa2_t *result; /* Structure à retourner */
+ vmpa2t *result; /* Structure à retourner */
- result = (vmpa2_t *)calloc(1, sizeof(vmpa2_t));
+ result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
result->physical = phy;
result->virtual = virt;
@@ -77,11 +79,182 @@ vmpa2_t *make_vmpa(off_t phy, uint64_t virt)
* *
******************************************************************************/
-void init_vmpa(vmpa2_t *addr, off_t phy, uint64_t virt)
+void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
{
addr->physical = phy;
addr->virtual = virt;
+
+
+ MDS_UNDEFINED;
+
+
+
+}
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : addr = élément à venir lire. [OUT] *
+* fd = flux ouvert en lecture pour l'importation. *
+* flags = éventuelles options d'envoi supplémentaires. *
+* *
+* Description : Lit la définition d'une adresse depuis un flux réseau. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool recv_vmpa(vmpa2t *addr, int fd, int flags)
+{
+ uint64_t val64; /* Valeur sur 64 bits */
+ bool status; /* Bilan d'une réception */
+
+ status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+ if (!status) return false;
+
+ addr->physical = be64toh(val64);
+
+ status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+ if (!status) return false;
+
+ addr->virtual = be64toh(val64);
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : addr = élément à venir écrire. *
+* fd = flux ouvert en écriture pour l'exportation. *
+* flags = éventuelles options d'envoi supplémentaires. *
+* *
+* Description : Ecrit la définition d'une adresse dans un flux réseau. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool send_vmpa(const vmpa2t *addr, int fd, int flags)
+{
+ bool status; /* Bilan d'une émission */
+
+ status = safe_send(fd, (uint64_t []) { htobe64(addr->physical) }, sizeof(uint64_t), flags);
+ if (!status) return false;
+
+ status = safe_send(fd, (uint64_t []) { htobe64(addr->virtual) }, sizeof(uint64_t), flags);
+ if (!status) return false;
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : addr = adresse virtuelle ou physique à traiter. *
+* msize = taille de cette adresse, réelle ou désirée. *
+* *
+* Description : Transforme une adresse physique en chaîne de caractères. *
+* *
+* Retour : Chaîne de caractères constituée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const char *vmpa2_phy_to_string(vmpa2t *addr, MemoryDataSize msize)
+{
+ if (addr->phy_cache[0] == '\0' || addr->last_phy_size != msize)
+ {
+ switch (msize)
+ {
+ case MDS_8_BITS:
+ snprintf(addr->phy_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
+ break;
+
+ case MDS_16_BITS:
+ snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
+ break;
+
+ case MDS_32_BITS:
+ snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
+ break;
+
+ case MDS_64_BITS:
+ snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
+ break;
+
+ default:
+ snprintf(addr->phy_cache, VMPA_MAX_SIZE, "???");
+ break;
+
+ }
+
+ addr->last_phy_size = msize;
+
+ }
+
+ return addr->phy_cache;
+
}
+/******************************************************************************
+* *
+* Paramètres : addr = adresse virtuelle ou physique à traiter. *
+* msize = taille de cette adresse, réelle ou désirée. *
+* *
+* Description : Transforme une adresse virtuelle en chaîne de caractères. *
+* *
+* Retour : Chaîne de caractères constituée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize)
+{
+ if (addr->virt_cache[0] == '\0' || addr->last_virt_size != msize)
+ {
+ switch (msize)
+ {
+ case MDS_8_BITS:
+ snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
+ break;
+
+ case MDS_16_BITS:
+ snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
+ break;
+
+ case MDS_32_BITS:
+ snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
+ break;
+
+ case MDS_64_BITS:
+ snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
+ break;
+
+ default:
+ snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
+ break;
+
+ }
+
+ addr->last_virt_size = msize;
+
+ }
+
+ return addr->virt_cache;
+
+}
diff --git a/src/arch/vmpa.h b/src/arch/vmpa.h
index fa14fda..5df9b8a 100644
--- a/src/arch/vmpa.h
+++ b/src/arch/vmpa.h
@@ -25,11 +25,22 @@
#define _ARCH_VMPA_H
+#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>
+#include "archbase.h"
+#include "../common/cpp.h"
+
+
+
+
+
+
+#define VMPA_MAX_SIZE (sizeof(STR(ULLONG_MAX)) + 1)
+
@@ -39,6 +50,11 @@ struct _vmpa2_t
off_t physical; /* Position physique */
uint64_t virtual; /* Adresse virtuelle */
+ MemoryDataSize last_phy_size; /* Dernière taille demandée #1 */
+ MemoryDataSize last_virt_size; /* Dernière taille demandée #2 */
+ char phy_cache[VMPA_MAX_SIZE]; /* Impression physique cachée */
+ char virt_cache[VMPA_MAX_SIZE]; /* Impression virtuelle cachée */
+
};
@@ -47,20 +63,36 @@ struct _vmpa2_t
typedef struct _vmpa2_t vmpa2_t;
+typedef struct _vmpa2_t vmpa2t;
+
+
/* Initialise une localisation dans l'espace mémoire/physique. */
-void init_vmpa(vmpa2_t *, off_t, uint64_t);
+void init_vmpa(vmpa2t *, off_t, uint64_t);
/* Crée une localisation dans l'adressage mémoire. */
-vmpa2_t *make_vmpa(off_t, uint64_t);
+vmpa2t *make_vmpa(off_t, uint64_t);
+
+
+
+#define cmp_vmpa(a, b) 0
+
+
+
+/* Lit la définition d'une adresse depuis un flux réseau. */
+bool recv_vmpa(vmpa2t *, int, int);
+/* Ecrit la définition d'une adresse dans un flux réseau. */
+bool send_vmpa(const vmpa2t *, int, int);
-#define load_vmpa_from_fd(vmpa, fd) true
+/* Transforme une adresse physique en chaîne de caractères. */
+const char *vmpa2_phy_to_string(vmpa2t *, MemoryDataSize);
-#define store_vmpa_to_fd(vmpa, fd) true
+/* Transforme une adresse virtuelle en chaîne de caractères. */
+const char *vmpa2_virt_to_string(vmpa2t *, MemoryDataSize);
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
index 7590532..38c3d20 100644
--- a/src/arch/x86/processor.c
+++ b/src/arch/x86/processor.c
@@ -45,12 +45,18 @@ struct _GX86ProcessorClass
};
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise la classe des processeurs x86. */
static void g_x86_processor_class_init(GX86ProcessorClass *);
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise une instance de processeur x86. */
static void g_x86_processor_init(GX86Processor *);
+/* Supprime toutes les références externes. */
+static void g_x86_processor_dispose(GX86Processor *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_x86_processor_finalize(GX86Processor *);
+
/* Décode une instruction dans un flux de données. */
static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor *, const bin_t *, off_t *, off_t, vmpa_t);
@@ -64,7 +70,7 @@ G_DEFINE_TYPE(GX86Processor, g_x86_processor, G_TYPE_ARCH_PROCESSOR);
* *
* Paramètres : klass = classe à initialiser. *
* *
-* Description : Initialise la classe des lignes de descriptions initiales. *
+* Description : Initialise la classe des processeurs x86. *
* *
* Retour : - *
* *
@@ -74,6 +80,17 @@ G_DEFINE_TYPE(GX86Processor, g_x86_processor, G_TYPE_ARCH_PROCESSOR);
static void g_x86_processor_class_init(GX86ProcessorClass *klass)
{
+ GObjectClass *object; /* Autre version de la classe */
+ GArchProcessorClass *proc; /* Encore une autre vision... */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_x86_processor_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_x86_processor_finalize;
+
+ proc = G_ARCH_PROCESSOR_CLASS(klass);
+
+ proc->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
}
@@ -82,7 +99,7 @@ static void g_x86_processor_class_init(GX86ProcessorClass *klass)
* *
* Paramètres : proc = instance à initialiser. *
* *
-* Description : Initialise la classe des lignes de descriptions initiales. *
+* Description : Initialise une instance de processeur x86. *
* *
* Retour : - *
* *
@@ -100,7 +117,43 @@ static void g_x86_processor_init(GX86Processor *proc)
parent->memsize = MDS_32_BITS;
parent->inssize = MDS_8_BITS;
- parent->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_processor_dispose(GX86Processor *proc)
+{
+ G_OBJECT_CLASS(g_x86_processor_parent_class)->dispose(G_OBJECT(proc));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : bookmark = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_x86_processor_finalize(GX86Processor *proc)
+{
+ G_OBJECT_CLASS(g_x86_processor_parent_class)->finalize(G_OBJECT(proc));
}