diff options
Diffstat (limited to 'src/arch/dalvik/opcodes')
38 files changed, 11 insertions, 10157 deletions
diff --git a/src/arch/dalvik/opcodes/Makefile.am b/src/arch/dalvik/opcodes/Makefile.am index 8632c0e..e4f90da 100644 --- a/src/arch/dalvik/opcodes/Makefile.am +++ b/src/arch/dalvik/opcodes/Makefile.am @@ -1,44 +1,17 @@ +# Initialement, ce Makefile est conçu sans définition de am__depfiles_maybe. +# Est-ce parce que GENERATED_FILES est vide et qu'il n'y a donc pas de code +# source ? En tout cas, au premier écrasement de gencode.mk, tous les fichiers +# sont regénérés, et am__depfiles_maybe apparaît enfin. Mais trop tard : +# des fichiers .Plo sont attendus mais non créés par l'ancien Makefile. +# On force les choses ici. +am__depfiles_maybe = depfiles + +include gencode.mk + noinst_LTLIBRARIES = libarchdalvikopcodes.la -libarchdalvikopcodes_la_SOURCES = \ - add.c \ - aget.c \ - and.c \ - aput.c \ - array.c \ - check.c \ - cmp.c \ - const.c \ - div.c \ - goto.c \ - if.c \ - iget.c \ - instanceof.c \ - invoke.c \ - iput.c \ - monitor.c \ - move.c \ - mul.c \ - neg.c \ - new.c \ - nop.c \ - not.c \ - opcodes.h \ - or.c \ - rem.c \ - ret.c \ - rsub.c \ - sget.c \ - shl.c \ - shr.c \ - sput.c \ - sub.c \ - switch.c \ - throw.c \ - to.c \ - ushr.c \ - xor.c +libarchdalvikopcodes_la_SOURCES = $(GENERATED_FILES) libarchdalvikopcodes_la_LIBADD = diff --git a/src/arch/dalvik/opcodes/add.c b/src/arch/dalvik/opcodes/add.c deleted file mode 100644 index 4d93df9..0000000 --- a/src/arch/dalvik/opcodes/add.c +++ /dev/null @@ -1,419 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * add.c - décodage des opérations d'addition - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_add_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_ADD_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-double/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_ADD_DOUBLE_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ADD_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ADD_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ADD_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ADD_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_add_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_ADD_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-float/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_ADD_FLOAT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_add_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_ADD_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'add-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ADD_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/aget.c b/src/arch/dalvik/opcodes/aget.c deleted file mode 100644 index e5033aa..0000000 --- a/src/arch/dalvik/opcodes/aget.c +++ /dev/null @@ -1,302 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * aget.c - décodage des instructions manipulant des tableaux (chargement) - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aget-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AGET_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/and.c b/src/arch/dalvik/opcodes/and.c deleted file mode 100644 index d5162bf..0000000 --- a/src/arch/dalvik/opcodes/and.c +++ /dev/null @@ -1,263 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * and.c - décodage des opérations de ET logiques - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'and-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_AND_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/aput.c b/src/arch/dalvik/opcodes/aput.c deleted file mode 100644 index 6cdde65..0000000 --- a/src/arch/dalvik/opcodes/aput.c +++ /dev/null @@ -1,288 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * aput.c - décodage des instructions manipulant des tableaux (enregistrement) - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'aput-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_APUT_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/array.c b/src/arch/dalvik/opcodes/array.c deleted file mode 100644 index efa40b7..0000000 --- a/src/arch/dalvik/opcodes/array.c +++ /dev/null @@ -1,179 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * array.c - décodage de l'opération récupérant la longueur d'un tableau - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'array-length'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_ARRAY_LENGTH); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'fill-array-data'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_FILL_ARRAY_DATA); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'filled-new-array'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_FILLED_NEW_ARRAY); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'filled-new-array/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_FILLED_NEW_ARRAY_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/check.c b/src/arch/dalvik/opcodes/check.c deleted file mode 100644 index 725f336..0000000 --- a/src/arch/dalvik/opcodes/check.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * check.c - décodage des vérifications de types - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'check-cast'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CHECK_CAST); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/cmp.c b/src/arch/dalvik/opcodes/cmp.c deleted file mode 100644 index e6de13c..0000000 --- a/src/arch/dalvik/opcodes/cmp.c +++ /dev/null @@ -1,224 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * cmp.c - décodage des instructions de comparaison - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'cmp-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CMP_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'cmpg-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CMPG_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'cmpg-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CMPG_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'cmpl-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CMPL_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'cmpl-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CMPL_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/const.c b/src/arch/dalvik/opcodes/const.c deleted file mode 100644 index 5097804..0000000 --- a/src/arch/dalvik/opcodes/const.c +++ /dev/null @@ -1,458 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * const.c - décodage des chargements de constantes - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const/4'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_4); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11N)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-class'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_CLASS); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const/high16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_HIGH16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-string'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_STRING); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-string/jumbo'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_STRING_JUMBO); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_51L)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-wide/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_WIDE_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-wide/32'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_WIDE_32); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31I)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'const-wide/high16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_CONST_WIDE_HIGH16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21H)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/div.c b/src/arch/dalvik/opcodes/div.c deleted file mode 100644 index a20968b..0000000 --- a/src/arch/dalvik/opcodes/div.c +++ /dev/null @@ -1,419 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * div.c - décodage des opérations de divisions - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-double/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_DOUBLE_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-float/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_FLOAT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'div-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_DIV_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/goto.c b/src/arch/dalvik/opcodes/goto.c deleted file mode 100644 index f74774a..0000000 --- a/src/arch/dalvik/opcodes/goto.c +++ /dev/null @@ -1,140 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * goto.c - décodage des branchements inconditionnels - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'goto'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_GOTO); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'goto/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_GOTO_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_20T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'goto/32'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_GOTO_32); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_30T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/if.c b/src/arch/dalvik/opcodes/if.c deleted file mode 100644 index ad8b49a..0000000 --- a/src/arch/dalvik/opcodes/if.c +++ /dev/null @@ -1,473 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * if.c - décodage des branchements conditionnels - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-eq'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_EQ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-eqz'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_EQZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-ge'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_GE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-gez'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_GEZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-gt'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_GT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-gtz'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_GTZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-le'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_LE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-lez'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_LEZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-lt'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_LT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-ltz'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_LTZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-ne'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_NE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'if-nez'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IF_NEZ); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_21T, addr)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/iget.c b/src/arch/dalvik/opcodes/iget.c deleted file mode 100644 index f83bb96..0000000 --- a/src/arch/dalvik/opcodes/iget.c +++ /dev/null @@ -1,302 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * iget.c - décodage des chargements de champs d'instance - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iget-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IGET_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/instanceof.c b/src/arch/dalvik/opcodes/instanceof.c deleted file mode 100644 index d65c6bd..0000000 --- a/src/arch/dalvik/opcodes/instanceof.c +++ /dev/null @@ -1,68 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * instanceof.c - décodage des opérations d'interrogation sur une instance - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'instance-of'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INSTANCE_OF); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/invoke.c b/src/arch/dalvik/opcodes/invoke.c deleted file mode 100644 index 9133e79..0000000 --- a/src/arch/dalvik/opcodes/invoke.c +++ /dev/null @@ -1,399 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * invoke.c - décodage des appels de méthode - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-direct'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_DIRECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-direct/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_DIRECT_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-interface'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_INTERFACE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-interface/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_INTERFACE_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-static'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_STATIC); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-static/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_STATIC_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-super'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_SUPER); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-super/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_SUPER_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-virtual'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_VIRTUAL); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'invoke-virtual/range'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_INVOKE_VIRTUAL_RANGE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/iput.c b/src/arch/dalvik/opcodes/iput.c deleted file mode 100644 index 434eec7..0000000 --- a/src/arch/dalvik/opcodes/iput.c +++ /dev/null @@ -1,288 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * iput.c - décodage des enregistrements de champs d'instance - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'iput-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_IPUT_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/monitor.c b/src/arch/dalvik/opcodes/monitor.c deleted file mode 100644 index 866e984..0000000 --- a/src/arch/dalvik/opcodes/monitor.c +++ /dev/null @@ -1,103 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * monitor.c - décodage des opérations de débogage - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'monitor-enter'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MONITOR_ENTER); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'monitor-exit'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MONITOR_EXIT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/move.c b/src/arch/dalvik/opcodes/move.c deleted file mode 100644 index ba2d89b..0000000 --- a/src/arch/dalvik/opcodes/move.c +++ /dev/null @@ -1,536 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * move.c - décodage des opérations de déplacement - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-exception'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_EXCEPTION); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move/from16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_FROM_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-object/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_OBJECT_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-object/from16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_OBJECT_FROM_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-result'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_RESULT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-result-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_RESULT_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-result-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_RESULT_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-wide/16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_WIDE_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_32X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'move-wide/from16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MOVE_WIDE_FROM_16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/mul.c b/src/arch/dalvik/opcodes/mul.c deleted file mode 100644 index 67a343b..0000000 --- a/src/arch/dalvik/opcodes/mul.c +++ /dev/null @@ -1,419 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * mul.c - décodage des opérations de multiplications - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_mul_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_MUL_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-double/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_DOUBLE_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_mul_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_MUL_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-float/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_MUL_FLOAT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_MUL_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'mul-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_MUL_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/neg.c b/src/arch/dalvik/opcodes/neg.c deleted file mode 100644 index 5f9a985..0000000 --- a/src/arch/dalvik/opcodes/neg.c +++ /dev/null @@ -1,185 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * neg.c - décodage des instructions de négations - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'neg-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEG_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'neg-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEG_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'neg-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEG_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'neg-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEG_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/new.c b/src/arch/dalvik/opcodes/new.c deleted file mode 100644 index 3320540..0000000 --- a/src/arch/dalvik/opcodes/new.c +++ /dev/null @@ -1,107 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * new.c - décodage des créations de nouvelles instances - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'new-array'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEW_ARRAY); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'new-instance'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NEW_INSTANCE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/nop.c b/src/arch/dalvik/opcodes/nop.c deleted file mode 100644 index b90c350..0000000 --- a/src/arch/dalvik/opcodes/nop.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * ret.c - décodage de l'instruction nulle - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'nop'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NOP); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/not.c b/src/arch/dalvik/opcodes/not.c deleted file mode 100644 index 41ae2d4..0000000 --- a/src/arch/dalvik/opcodes/not.c +++ /dev/null @@ -1,107 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * not.c - décodage des instructions de négations booléennes - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'not-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NOT_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'not-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_NOT_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/opcodes.h b/src/arch/dalvik/opcodes/opcodes.h deleted file mode 100644 index 3f89970..0000000 --- a/src/arch/dalvik/opcodes/opcodes.h +++ /dev/null @@ -1,693 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * opcodes.h - prototypes pour la liste de tous les opcodes de l'architecture Dalvik - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _ARCH_DALVIK_OPCODES_H -#define _ARCH_DALVIK_OPCODES_H - - -#include "../instruction.h" -#include "../processor.h" -#include "../../../format/dex/dex.h" - - - -/* Prototype de décodage d'une instruction Dalvik. */ -typedef GArchInstruction * (* dalvik_read_instr) (const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-double'. */ -GArchInstruction *dalvik_read_instr_add_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-double/2addr'. */ -GArchInstruction *dalvik_read_instr_add_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-int'. */ -GArchInstruction *dalvik_read_instr_add_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-int/2addr'. */ -GArchInstruction *dalvik_read_instr_add_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-int/lit8'. */ -GArchInstruction *dalvik_read_instr_add_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-int/lit16'. */ -GArchInstruction *dalvik_read_instr_add_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-float'. */ -GArchInstruction *dalvik_read_instr_add_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-float/2addr'. */ -GArchInstruction *dalvik_read_instr_add_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-long'. */ -GArchInstruction *dalvik_read_instr_add_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'add-long/2addr'. */ -GArchInstruction *dalvik_read_instr_add_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget'. */ -GArchInstruction *dalvik_read_instr_aget(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-boolean'. */ -GArchInstruction *dalvik_read_instr_aget_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-byte'. */ -GArchInstruction *dalvik_read_instr_aget_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-char'. */ -GArchInstruction *dalvik_read_instr_aget_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-object'. */ -GArchInstruction *dalvik_read_instr_aget_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-short'. */ -GArchInstruction *dalvik_read_instr_aget_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aget-wide'. */ -GArchInstruction *dalvik_read_instr_aget_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-int'. */ -GArchInstruction *dalvik_read_instr_and_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-int/2addr'. */ -GArchInstruction *dalvik_read_instr_and_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-int/lit8'. */ -GArchInstruction *dalvik_read_instr_and_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-int/lit16'. */ -GArchInstruction *dalvik_read_instr_and_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-long'. */ -GArchInstruction *dalvik_read_instr_and_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'and-long/2addr'. */ -GArchInstruction *dalvik_read_instr_and_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput'. */ -GArchInstruction *dalvik_read_instr_aput(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-boolean'. */ -GArchInstruction *dalvik_read_instr_aput_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-byte'. */ -GArchInstruction *dalvik_read_instr_aput_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-char'. */ -GArchInstruction *dalvik_read_instr_aput_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-object'. */ -GArchInstruction *dalvik_read_instr_aput_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-short'. */ -GArchInstruction *dalvik_read_instr_aput_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'aput-wide'. */ -GArchInstruction *dalvik_read_instr_aput_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'array-length'. */ -GArchInstruction *dalvik_read_instr_array_length(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'check-cast'. */ -GArchInstruction *dalvik_read_instr_check_cast(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'cmp-long'. */ -GArchInstruction *dalvik_read_instr_cmp_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'cmpg-double'. */ -GArchInstruction *dalvik_read_instr_cmpg_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'cmpg-float'. */ -GArchInstruction *dalvik_read_instr_cmpg_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'cmpl-double'. */ -GArchInstruction *dalvik_read_instr_cmpl_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'cmpl-float'. */ -GArchInstruction *dalvik_read_instr_cmpl_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const'. */ -GArchInstruction *dalvik_read_instr_const(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const/16'. */ -GArchInstruction *dalvik_read_instr_const_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const/4'. */ -GArchInstruction *dalvik_read_instr_const_4(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-class'. */ -GArchInstruction *dalvik_read_instr_const_class(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const/high16'. */ -GArchInstruction *dalvik_read_instr_const_high16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-string'. */ -GArchInstruction *dalvik_read_instr_const_string(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-string/jumbo'. */ -GArchInstruction *dalvik_read_instr_const_string_jumbo(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-wide'. */ -GArchInstruction *dalvik_read_instr_const_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-wide/16'. */ -GArchInstruction *dalvik_read_instr_const_wide_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-wide/32'. */ -GArchInstruction *dalvik_read_instr_const_wide_32(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'const-wide/high16'. */ -GArchInstruction *dalvik_read_instr_const_wide_high16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-double'. */ -GArchInstruction *dalvik_read_instr_div_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-double/2addr'. */ -GArchInstruction *dalvik_read_instr_div_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-float'. */ -GArchInstruction *dalvik_read_instr_div_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-float/2addr'. */ -GArchInstruction *dalvik_read_instr_div_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-int'. */ -GArchInstruction *dalvik_read_instr_div_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-int/2addr'. */ -GArchInstruction *dalvik_read_instr_div_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-int/lit8'. */ -GArchInstruction *dalvik_read_instr_div_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-int/lit16'. */ -GArchInstruction *dalvik_read_instr_div_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-long'. */ -GArchInstruction *dalvik_read_instr_div_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'div-long/2addr'. */ -GArchInstruction *dalvik_read_instr_div_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'fill-array-data'. */ -GArchInstruction *dalvik_read_instr_fill_array_data(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'filled-new-array'. */ -GArchInstruction *dalvik_read_instr_filled_new_array(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'filled-new-array/range'. */ -GArchInstruction *dalvik_read_instr_filled_new_array_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'goto'. */ -GArchInstruction *dalvik_read_instr_goto(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'goto/16'. */ -GArchInstruction *dalvik_read_instr_goto_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'goto/32'. */ -GArchInstruction *dalvik_read_instr_goto_32(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-eq'. */ -GArchInstruction *dalvik_read_instr_if_eq(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-eqz'. */ -GArchInstruction *dalvik_read_instr_if_eqz(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-ge'. */ -GArchInstruction *dalvik_read_instr_if_ge(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-gez'. */ -GArchInstruction *dalvik_read_instr_if_gez(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-gt'. */ -GArchInstruction *dalvik_read_instr_if_gt(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-gtz'. */ -GArchInstruction *dalvik_read_instr_if_gtz(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-le'. */ -GArchInstruction *dalvik_read_instr_if_le(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-lez'. */ -GArchInstruction *dalvik_read_instr_if_lez(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-lt'. */ -GArchInstruction *dalvik_read_instr_if_lt(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-ltz'. */ -GArchInstruction *dalvik_read_instr_if_ltz(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-ne'. */ -GArchInstruction *dalvik_read_instr_if_ne(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'if-nez'. */ -GArchInstruction *dalvik_read_instr_if_nez(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget'. */ -GArchInstruction *dalvik_read_instr_iget(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-boolean'. */ -GArchInstruction *dalvik_read_instr_iget_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-byte'. */ -GArchInstruction *dalvik_read_instr_iget_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-char'. */ -GArchInstruction *dalvik_read_instr_iget_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-object'. */ -GArchInstruction *dalvik_read_instr_iget_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-short'. */ -GArchInstruction *dalvik_read_instr_iget_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iget-wide'. */ -GArchInstruction *dalvik_read_instr_iget_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'instance-of'. */ -GArchInstruction *dalvik_read_instr_instance_of(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-direct'. */ -GArchInstruction *dalvik_read_instr_invoke_direct(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-direct/range'. */ -GArchInstruction *dalvik_read_instr_invoke_direct_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-interface'. */ -GArchInstruction *dalvik_read_instr_invoke_interface(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-interface/range'. */ -GArchInstruction *dalvik_read_instr_invoke_interface_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-static'. */ -GArchInstruction *dalvik_read_instr_invoke_static(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-static/range'. */ -GArchInstruction *dalvik_read_instr_invoke_static_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-super'. */ -GArchInstruction *dalvik_read_instr_invoke_super(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-super/range'. */ -GArchInstruction *dalvik_read_instr_invoke_super_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-virtual'. */ -GArchInstruction *dalvik_read_instr_invoke_virtual(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'invoke-virtual/range'. */ -GArchInstruction *dalvik_read_instr_invoke_virtual_range(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput'. */ -GArchInstruction *dalvik_read_instr_iput(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-boolean'. */ -GArchInstruction *dalvik_read_instr_iput_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-byte'. */ -GArchInstruction *dalvik_read_instr_iput_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-char'. */ -GArchInstruction *dalvik_read_instr_iput_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-object'. */ -GArchInstruction *dalvik_read_instr_iput_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-short'. */ -GArchInstruction *dalvik_read_instr_iput_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'iput-wide'. */ -GArchInstruction *dalvik_read_instr_iput_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'monitor-enter'. */ -GArchInstruction *dalvik_read_instr_monitor_enter(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'monitor-exit'. */ -GArchInstruction *dalvik_read_instr_monitor_exit(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move'. */ -GArchInstruction *dalvik_read_instr_move(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-exception'. */ -GArchInstruction *dalvik_read_instr_move_exception(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move/16'. */ -GArchInstruction *dalvik_read_instr_move_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move/from16'. */ -GArchInstruction *dalvik_read_instr_move_from_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-object'. */ -GArchInstruction *dalvik_read_instr_move_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-object/16'. */ -GArchInstruction *dalvik_read_instr_move_object_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-object/from16'. */ -GArchInstruction *dalvik_read_instr_move_object_from_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-result'. */ -GArchInstruction *dalvik_read_instr_move_result(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-result-object'. */ -GArchInstruction *dalvik_read_instr_move_result_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-result-wide'. */ -GArchInstruction *dalvik_read_instr_move_result_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-wide'. */ -GArchInstruction *dalvik_read_instr_move_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-wide/16'. */ -GArchInstruction *dalvik_read_instr_move_wide_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'move-wide/from16'. */ -GArchInstruction *dalvik_read_instr_move_wide_from_16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-double'. */ -GArchInstruction *dalvik_read_instr_mul_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-double/2addr'. */ -GArchInstruction *dalvik_read_instr_mul_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-float'. */ -GArchInstruction *dalvik_read_instr_mul_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-float/2addr'. */ -GArchInstruction *dalvik_read_instr_mul_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-int'. */ -GArchInstruction *dalvik_read_instr_mul_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-int/2addr'. */ -GArchInstruction *dalvik_read_instr_mul_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-int/lit8'. */ -GArchInstruction *dalvik_read_instr_mul_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-int/lit16'. */ -GArchInstruction *dalvik_read_instr_mul_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-long'. */ -GArchInstruction *dalvik_read_instr_mul_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'mul-long/2addr'. */ -GArchInstruction *dalvik_read_instr_mul_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'neg-double'. */ -GArchInstruction *dalvik_read_instr_neg_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'neg-float'. */ -GArchInstruction *dalvik_read_instr_neg_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'neg-int'. */ -GArchInstruction *dalvik_read_instr_neg_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'neg-long'. */ -GArchInstruction *dalvik_read_instr_neg_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'new-array'. */ -GArchInstruction *dalvik_read_instr_new_array(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'new-instance'. */ -GArchInstruction *dalvik_read_instr_new_instance(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'nop'. */ -GArchInstruction *dalvik_read_instr_nop(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'not-int'. */ -GArchInstruction *dalvik_read_instr_not_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'not-long'. */ -GArchInstruction *dalvik_read_instr_not_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-int'. */ -GArchInstruction *dalvik_read_instr_or_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-int/2addr'. */ -GArchInstruction *dalvik_read_instr_or_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-int/lit8'. */ -GArchInstruction *dalvik_read_instr_or_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-int/lit16'. */ -GArchInstruction *dalvik_read_instr_or_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-long'. */ -GArchInstruction *dalvik_read_instr_or_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'or-long/2addr'. */ -GArchInstruction *dalvik_read_instr_or_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'packed-switch'. */ -GArchInstruction *dalvik_read_instr_packed_switch(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-double'. */ -GArchInstruction *dalvik_read_instr_rem_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-double/2addr'. */ -GArchInstruction *dalvik_read_instr_rem_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-float'. */ -GArchInstruction *dalvik_read_instr_rem_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-float/2addr'. */ -GArchInstruction *dalvik_read_instr_rem_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-int'. */ -GArchInstruction *dalvik_read_instr_rem_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-int/2addr'. */ -GArchInstruction *dalvik_read_instr_rem_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-int/lit8'. */ -GArchInstruction *dalvik_read_instr_rem_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-int/lit16'. */ -GArchInstruction *dalvik_read_instr_rem_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-long'. */ -GArchInstruction *dalvik_read_instr_rem_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rem-long/2addr'. */ -GArchInstruction *dalvik_read_instr_rem_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rsub-int'. */ -GArchInstruction *dalvik_read_instr_rsub_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'rsub-int/lit8'. */ -GArchInstruction *dalvik_read_instr_rsub_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'return'. */ -GArchInstruction *dalvik_read_instr_return(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'return-object'. */ -GArchInstruction *dalvik_read_instr_return_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'return-void'. */ -GArchInstruction *dalvik_read_instr_return_void(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'return-wide'. */ -GArchInstruction *dalvik_read_instr_return_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget'. */ -GArchInstruction *dalvik_read_instr_sget(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-boolean'. */ -GArchInstruction *dalvik_read_instr_sget_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-byte'. */ -GArchInstruction *dalvik_read_instr_sget_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-char'. */ -GArchInstruction *dalvik_read_instr_sget_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-object'. */ -GArchInstruction *dalvik_read_instr_sget_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-short'. */ -GArchInstruction *dalvik_read_instr_sget_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sget-wide'. */ -GArchInstruction *dalvik_read_instr_sget_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shl-int'. */ -GArchInstruction *dalvik_read_instr_shl_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shl-int/2addr'. */ -GArchInstruction *dalvik_read_instr_shl_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shl-int/lit8'. */ -GArchInstruction *dalvik_read_instr_shl_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shl-long'. */ -GArchInstruction *dalvik_read_instr_shl_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shl-long/2addr'. */ -GArchInstruction *dalvik_read_instr_shl_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shr-int'. */ -GArchInstruction *dalvik_read_instr_shr_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shr-int/2addr'. */ -GArchInstruction *dalvik_read_instr_shr_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shr-int/lit8'. */ -GArchInstruction *dalvik_read_instr_shr_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shr-long'. */ -GArchInstruction *dalvik_read_instr_shr_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'shr-long/2addr'. */ -GArchInstruction *dalvik_read_instr_shr_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sparse-switch'. */ -GArchInstruction *dalvik_read_instr_sparse_switch(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput'. */ -GArchInstruction *dalvik_read_instr_sput(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-boolean'. */ -GArchInstruction *dalvik_read_instr_sput_boolean(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-byte'. */ -GArchInstruction *dalvik_read_instr_sput_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-char'. */ -GArchInstruction *dalvik_read_instr_sput_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-object'. */ -GArchInstruction *dalvik_read_instr_sput_object(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-short'. */ -GArchInstruction *dalvik_read_instr_sput_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sput-wide'. */ -GArchInstruction *dalvik_read_instr_sput_wide(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-double'. */ -GArchInstruction *dalvik_read_instr_sub_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-double/2addr'. */ -GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-float'. */ -GArchInstruction *dalvik_read_instr_sub_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-float/2addr'. */ -GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-int'. */ -GArchInstruction *dalvik_read_instr_sub_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-int/2addr'. */ -GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-long'. */ -GArchInstruction *dalvik_read_instr_sub_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'sub-long/2addr'. */ -GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-byte'. */ -GArchInstruction *dalvik_read_instr_to_int_byte(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-char'. */ -GArchInstruction *dalvik_read_instr_to_int_char(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-double'. */ -GArchInstruction *dalvik_read_instr_to_int_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-float'. */ -GArchInstruction *dalvik_read_instr_to_int_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-long'. */ -GArchInstruction *dalvik_read_instr_to_int_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'int-to-short'. */ -GArchInstruction *dalvik_read_instr_to_int_short(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'double-to-float'. */ -GArchInstruction *dalvik_read_instr_to_double_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'double-to-int'. */ -GArchInstruction *dalvik_read_instr_to_double_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'double-to-long'. */ -GArchInstruction *dalvik_read_instr_to_double_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'float-to-double'. */ -GArchInstruction *dalvik_read_instr_to_float_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'float-to-int'. */ -GArchInstruction *dalvik_read_instr_to_float_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'float-to-long'. */ -GArchInstruction *dalvik_read_instr_to_float_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'long-to-double'. */ -GArchInstruction *dalvik_read_instr_to_long_double(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'long-to-float'. */ -GArchInstruction *dalvik_read_instr_to_long_float(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'long-to-int'. */ -GArchInstruction *dalvik_read_instr_to_long_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'throw'. */ -GArchInstruction *dalvik_read_instr_throw(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'ushr-int'. */ -GArchInstruction *dalvik_read_instr_ushr_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'ushr-int/2addr'. */ -GArchInstruction *dalvik_read_instr_ushr_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'ushr-int/lit8'. */ -GArchInstruction *dalvik_read_instr_ushr_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'ushr-long'. */ -GArchInstruction *dalvik_read_instr_ushr_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'ushr-long/2addr'. */ -GArchInstruction *dalvik_read_instr_ushr_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-int'. */ -GArchInstruction *dalvik_read_instr_xor_int(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-int/2addr'. */ -GArchInstruction *dalvik_read_instr_xor_int_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-int/lit8'. */ -GArchInstruction *dalvik_read_instr_xor_int_lit8(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-int/lit16'. */ -GArchInstruction *dalvik_read_instr_xor_int_lit16(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-long'. */ -GArchInstruction *dalvik_read_instr_xor_long(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - -/* Décode une instruction de type 'xor-long/2addr'. */ -GArchInstruction *dalvik_read_instr_xor_long_2addr(const bin_t *, off_t *, off_t, vmpa_t, const GDalvikProcessor *, const GDexFormat *); - - - -#endif /* _ARCH_DALVIK_OPCODES_H */ diff --git a/src/arch/dalvik/opcodes/or.c b/src/arch/dalvik/opcodes/or.c deleted file mode 100644 index 8904f48..0000000 --- a/src/arch/dalvik/opcodes/or.c +++ /dev/null @@ -1,263 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * or.c - décodage des opérations de OU logiques - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'or-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_OR_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/rem.c b/src/arch/dalvik/opcodes/rem.c deleted file mode 100644 index 0ba12de..0000000 --- a/src/arch/dalvik/opcodes/rem.c +++ /dev/null @@ -1,419 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * rem.c - décodage des opérations de restes de division - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-double/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_DOUBLE_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-float/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_FLOAT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rem-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_REM_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/ret.c b/src/arch/dalvik/opcodes/ret.c deleted file mode 100644 index 7e53ada..0000000 --- a/src/arch/dalvik/opcodes/ret.c +++ /dev/null @@ -1,177 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * ret.c - décodage des ordres de retour - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'return'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RETURN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'return-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RETURN_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'return-void'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RETURN_VOID); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_10X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'return-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RETURN_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/rsub.c b/src/arch/dalvik/opcodes/rsub.c deleted file mode 100644 index 9ee9331..0000000 --- a/src/arch/dalvik/opcodes/rsub.c +++ /dev/null @@ -1,107 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * rsub.c - décodage des opérations de soustractions inverses - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rsub-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RSUB_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'rsub-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_RSUB_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/sget.c b/src/arch/dalvik/opcodes/sget.c deleted file mode 100644 index bc1aca0..0000000 --- a/src/arch/dalvik/opcodes/sget.c +++ /dev/null @@ -1,302 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * sget.c - décodage des instructions manipulant des champs statiques (chargement) - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sget-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SGET_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/shl.c b/src/arch/dalvik/opcodes/shl.c deleted file mode 100644 index 3ee88b8..0000000 --- a/src/arch/dalvik/opcodes/shl.c +++ /dev/null @@ -1,224 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * shl.c - décodage des opérations de décalage à gauche - * - * Copyright (C) 2011-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shl-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHL_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shl-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHL_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shl-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHL_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shl-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHL_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shl-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHL_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/shr.c b/src/arch/dalvik/opcodes/shr.c deleted file mode 100644 index 1656164..0000000 --- a/src/arch/dalvik/opcodes/shr.c +++ /dev/null @@ -1,224 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * shr.c - décodage des opérations de décalage à droite signé - * - * Copyright (C) 2011-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shr-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHR_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shr-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHR_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shr-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHR_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shr-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHR_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'shr-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SHR_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/sput.c b/src/arch/dalvik/opcodes/sput.c deleted file mode 100644 index 281df25..0000000 --- a/src/arch/dalvik/opcodes/sput.c +++ /dev/null @@ -1,288 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * sput.c - décodage des instructions manipulant des champs statiques (enregistrement) - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-boolean'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_BOOLEAN); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-object'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_OBJECT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sput-wide'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPUT_WIDE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - 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; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/sub.c b/src/arch/dalvik/opcodes/sub.c deleted file mode 100644 index 98af25e..0000000 --- a/src/arch/dalvik/opcodes/sub.c +++ /dev/null @@ -1,341 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * sub.c - décodage des opérations de soustraction - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_double(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-double/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_double_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_DOUBLE_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_float(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-float/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_float_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_FLOAT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SUB_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_int_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_long(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sub-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchInstruction *dalvik_read_instr_sub_long_2addr(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GDalvikProcessor *proc, const GDexFormat *fmt) -{ - GArchInstruction *result; /* Instruction à retourner */ - SourceEndian endian; /* Boutisme lié au binaire */ - - result = g_dalvik_instruction_new(DOP_SUB_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/switch.c b/src/arch/dalvik/opcodes/switch.c deleted file mode 100644 index 8b3c7a6..0000000 --- a/src/arch/dalvik/opcodes/switch.c +++ /dev/null @@ -1,103 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * switch.c - décompilation des branchements multiples - * - * Copyright (C) 2011-2013 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'packed-switch'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_PACKED_SWITCH); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'sparse-switch'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_SPARSE_SWITCH); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_31T)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/throw.c b/src/arch/dalvik/opcodes/throw.c deleted file mode 100644 index 18602bc..0000000 --- a/src/arch/dalvik/opcodes/throw.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * monitor.c - décodage des opérations d'envoi d'exceptions - * - * Copyright (C) 2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'throw'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_THROW); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_11X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - return result; - -} diff --git a/src/arch/dalvik/opcodes/to.c b/src/arch/dalvik/opcodes/to.c deleted file mode 100644 index a8d3962..0000000 --- a/src/arch/dalvik/opcodes/to.c +++ /dev/null @@ -1,614 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * to.c - décodage des instructions de conversions forcées - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-byte'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_BYTE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-char'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_CHAR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'int-to-short'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_INT_SHORT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'double-to-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_DOUBLE_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'double-to-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_DOUBLE_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'double-to-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_DOUBLE_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'float-to-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_FLOAT_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'float-to-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_FLOAT_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'float-to-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_FLOAT_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'long-to-double'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_LONG_DOUBLE); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'long-to-float'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_LONG_FLOAT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'long-to-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_TO_LONG_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/ushr.c b/src/arch/dalvik/opcodes/ushr.c deleted file mode 100644 index ed377de..0000000 --- a/src/arch/dalvik/opcodes/ushr.c +++ /dev/null @@ -1,224 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * ushr.c - décodage des opérations de décalage à droite non signé - * - * Copyright (C) 2011-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'ushr-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_USHR_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'ushr-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_USHR_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'ushr-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_USHR_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'ushr-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_USHR_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'ushr-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_USHR_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} diff --git a/src/arch/dalvik/opcodes/xor.c b/src/arch/dalvik/opcodes/xor.c deleted file mode 100644 index bf41560..0000000 --- a/src/arch/dalvik/opcodes/xor.c +++ /dev/null @@ -1,263 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * xor.c - décodage des opérations de OU exclusifs et logiques - * - * Copyright (C) 2010-2012 Cyrille Bagard - * - * This file is part of Chrysalide. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "opcodes.h" - - -#include "../instruction.h" -#include "../operand.h" - - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-int'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_INT); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-int/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_INT_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-int/lit8'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_INT_LIT8); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22B)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-int/lit16'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_INT_LIT16); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_22S)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-long'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_LONG); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_23X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* 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. * -* * -* Description : Décode une instruction de type 'xor-long/2addr'. * -* * -* Retour : Instruction mise en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - - result = g_dalvik_instruction_new(DOP_XOR_LONG_2ADDR); - - endian = g_arch_processor_get_endianness(G_ARCH_PROCESSOR(proc)); - - if (!dalvik_read_operands(result, fmt, data, pos, end, endian, DALVIK_OPT_12X)) - { - g_object_unref(G_OBJECT(result)); - return NULL; - } - - dalvik_mark_first_operand_as_written(result); - - return result; - -} |