Saved some progress in the definition of basic blocks.

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

1 files changed, 521 insertions, 0 deletions

diff --git a/src/arch/arm/v7/fetch.c b/src/arch/arm/v7/fetch.c
new file mode 100644
index 0000000..18d61f0
--- /dev/null
+++ b/src/arch/arm/v7/fetch.c
@@ -0,0 +1,521 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * fetch.c - traitements complémentaires à la phase de désassemblage
+ *
+ * Copyright (C) 2014 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 "fetch.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+
+
+#include <i18n.h>
+
+
+#include "operands/offset.h"
+#include "../register.h"
+#include "../../raw.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                iset    = type de jeu d'instructions courant à faire suivre. *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_b_with_orig(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format, ArmV7InstrSet iset)
+{
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    virt_t pc;                              /* Position dans l'exécution   */
+    GArchOperand *op;                       /* Opérande numérique en place */
+    int32_t offset;                         /* Décallage encodé en dur     */
+    virt_t target;                          /* Adresse virtuelle visée     */
+
+    range = g_arch_instruction_get_range(instr);
+
+    pc = get_virt_addr(get_mrange_addr(range));
+
+
+
+
+    switch (iset)
+    {
+        case AV7IS_ARM:
+            pc += 8;
+            break;
+        case AV7IS_THUMB:
+            pc += 4;
+            break;
+        default:
+            assert(0);
+            break;
+    }
+
+
+
+    //pc += get_mrange_length(range);
+
+    op = g_arch_instruction_get_operand(instr, 0);
+
+    if (g_imm_operand_get_value(G_IMM_OPERAND(op), MDS_32_BITS_SIGNED, &offset))
+        g_imm_operand_set_value(G_IMM_OPERAND(op), MDS_32_BITS_UNSIGNED, pc + offset);
+
+    else assert(0);
+
+    printf("1... 0x%x (0x%x) + 0x%x\n",
+           (unsigned int)get_virt_addr(get_mrange_addr(range)),
+           (unsigned int)pc, (unsigned int)offset);
+
+    target = pc + offset;
+
+    //g_armv7_context_define_encoding(context, target, iset);
+    g_armv7_context_push_drop_point_ext(context, target, iset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                iset    = type de jeu d'instructions courant à faire suivre. *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_bl_with_orig(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format, ArmV7InstrSet iset)
+{
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    virt_t pc;                              /* Position dans l'exécution   */
+    GArchOperand *op;                       /* Opérande numérique en place */
+    int32_t offset;                         /* Décallage encodé en dur     */
+    virt_t target;                          /* Adresse virtuelle visée     */
+
+    range = g_arch_instruction_get_range(instr);
+
+    pc = get_virt_addr(get_mrange_addr(range));
+
+    /**
+     * Qu'on se trouve en mode Thumb ou ARM, l'instruction
+     * ne peut qu'être encodée sur 4 octets.
+     */
+
+    assert(get_mrange_length(range) == 4);
+
+    pc += 4;
+
+    op = g_arch_instruction_get_operand(instr, 0);
+
+    if (g_imm_operand_get_value(G_IMM_OPERAND(op), MDS_32_BITS_SIGNED, &offset))
+        g_imm_operand_set_value(G_IMM_OPERAND(op), MDS_32_BITS_UNSIGNED, pc + offset);
+
+    else assert(0);
+
+    printf("2... 0x%x (0x%x) + 0x%x\n",
+           (unsigned int)get_virt_addr(get_mrange_addr(range)),
+           (unsigned int)pc, (unsigned int)offset);
+
+
+
+    target = pc + offset;
+
+    //g_armv7_context_define_encoding(context, target, iset);
+    g_armv7_context_push_drop_point_ext(context, target, iset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                iset    = type de jeu d'instructions courant à inverser.     *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_blx_with_dest(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format, ArmV7InstrSet iset)
+{
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    virt_t pc;                              /* Position dans l'exécution   */
+    GArchOperand *op;                       /* Opérande numérique en place */
+    int32_t offset;                         /* Décallage encodé en dur     */
+    virt_t target;                          /* Adresse virtuelle visée     */
+
+    range = g_arch_instruction_get_range(instr);
+
+    pc = get_virt_addr(get_mrange_addr(range));
+
+    /**
+     * Qu'on se trouve en mode Thumb ou ARM, l'instruction
+     * ne peut qu'être encodée sur 4 octets.
+     */
+
+    assert(get_mrange_length(range) == 4);
+
+    pc += 4;
+    pc -= pc % 4;
+
+    op = g_arch_instruction_get_operand(instr, 0);
+
+    if (g_imm_operand_get_value(G_IMM_OPERAND(op), MDS_32_BITS_SIGNED, &offset))
+        g_imm_operand_set_value(G_IMM_OPERAND(op), MDS_32_BITS_UNSIGNED, pc + offset);
+
+    else assert(0);
+
+    printf("3... 0x%x (0x%x) + 0x%x\n",
+           (unsigned int)get_virt_addr(get_mrange_addr(range)),
+           (unsigned int)pc, (unsigned int)offset);
+
+
+
+    target = pc + offset;
+
+    //g_armv7_context_define_encoding(context, target, iset);
+    g_armv7_context_push_drop_point_ext(context, target, iset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                iset    = type de jeu d'instructions courant à faire suivre. *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_bx_with_orig(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format, ArmV7InstrSet iset)
+{
+    GArchOperand *op;                       /* Opérande numérique en place */
+    GArmRegister *reg;                      /* Registre matériel manipulé  */
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    virt_t pc;                              /* Position dans l'exécution   */
+
+    op = g_arch_instruction_get_operand(instr, 0);
+    assert(G_IS_REGISTER_OPERAND(op));
+
+    reg = G_ARM_REGISTER(g_register_operand_get_register(G_REGISTER_OPERAND(op)));
+
+    /**
+     * On ne sait agir qu'avec le seul contenu facilement prédictible : pc !
+     */
+
+    if (g_arm_register_get_index(reg) != 15 /* pc */)
+        return;
+
+    /**
+     * On bascule alors le mode de décodage à cette adresse...
+     */
+
+    range = g_arch_instruction_get_range(instr);
+
+    pc = get_virt_addr(get_mrange_addr(range));
+
+    switch (iset)
+    {
+        case AV7IS_ARM:
+            pc += 8;
+            //g_armv7_context_define_encoding(context, 
+            g_armv7_context_push_drop_point_ext(context, pc, AV7IS_THUMB);
+            break;
+        case AV7IS_THUMB:
+            pc += 4;
+            //g_armv7_context_define_encoding(context, 
+            g_armv7_context_push_drop_point_ext(context, pc, AV7IS_ARM);
+            break;
+        default:
+            assert(0);
+            break;
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_cb_n_z(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format)
+{
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    virt_t pc;                              /* Position dans l'exécution   */
+    GArchOperand *op;                       /* Opérande numérique en place */
+    uint32_t offset;                        /* Décallage encodé en dur     */
+    virt_t target;                          /* Adresse virtuelle visée     */
+
+    range = g_arch_instruction_get_range(instr);
+
+    pc = get_virt_addr(get_mrange_addr(range));
+
+
+    printf("PC :: 0x%08x\n", (unsigned int)pc);
+
+
+    /**
+     * En mode Thumb, pc a pour valeur l'adresse courante plus 4.
+     */
+
+    pc += 4;
+
+    op = g_arch_instruction_get_operand(instr, 1);
+
+    if (g_imm_operand_get_value(G_IMM_OPERAND(op), MDS_32_BITS_UNSIGNED, &offset))
+        g_imm_operand_set_value(G_IMM_OPERAND(op), MDS_32_BITS_UNSIGNED, pc + offset);
+
+    else assert(0);
+
+    target = pc + offset;
+
+    //g_armv7_context_define_encoding(context, target, AV7IS_THUMB);
+    g_armv7_context_push_drop_point_ext(context, target, AV7IS_THUMB);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction ARMv7 à traiter.                       *
+*                proc    = représentation de l'architecture utilisée.         *
+*                context = contexte associé à la phase de désassemblage.      *
+*                format  = acès aux données du binaire d'origine.             *
+*                iset    = type de jeu d'instructions courant à inverser.     *
+*                                                                             *
+*  Description : Complète un désassemblage accompli pour une instruction.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void help_fetching_with_instruction_ldr_literal_with_orig(GArchInstruction *instr, GArchProcessor *proc, GArmV7Context *context, GBinFormat *format, ArmV7InstrSet iset)
+{
+    const mrange_t *range;                  /* Emplacementt d'instruction  */
+    phys_t phys_pc;                         /* Position dans l'exécution   */
+    GArchOperand *op;                       /* Opérande de surcouche       */
+    GArchOperand *sub_op;                   /* Opérande numérique en place */
+    uint32_t offset;                        /* Décallage encodé en dur     */
+    bool ret;                               /* Bilan d'une récupération    */
+    off_t val_offset;                       /* Position de valeur à lire   */
+    vmpa2t sym_addr;                        /* Adresse de nouveau symbole  */
+    off_t length;                           /* Taille des données à lire   */
+    const bin_t *data;                      /* Données binaires à lire     */
+    uint32_t target;                        /* Adresse virtuelle visée     */
+    mrange_t sym_range;                     /* Espace du nouveau symbole   */
+    VMPA_BUFFER(loc);                       /* Adresse au format texte     */
+    size_t name_len;                        /* Taille de nomination finale */
+    char *name;                             /* Désignation humaine         */
+    GArchInstruction *sym_instr;            /* Instruction de symbole      */
+    GBinSymbol *symbol;                     /* Nouveau symbole construit   */
+    GDbComment *comment;                    /* Définition de commentaire   */
+    GArchOperand *new;                      /* Instruction de ciblage      */
+
+    /* Récupération de l'adresse visée par le chargement */
+
+    range = g_arch_instruction_get_range(instr);
+
+    phys_pc = get_phy_addr(get_mrange_addr(range));
+
+    phys_pc &= ~3;
+    //phys_pc = (phys_pc + 3) & ~3;
+
+    printf(">>>>>>> @pc @ 0x%08x\n", (unsigned int)phys_pc);
+
+
+    switch (iset)
+    {
+        case AV7IS_ARM:
+            phys_pc += 8;
+            break;
+        case AV7IS_THUMB:
+            phys_pc += 4;
+            break;
+        default:
+            assert(0);
+            break;
+    }
+
+    op = g_arch_instruction_get_operand(instr, 1);
+    assert(G_IS_ARMV7_OFFSET_OPERAND(op));
+
+    sub_op = g_armv7_offset_operand_get_value(G_ARMV7_OFFSET_OPERAND(op));
+
+    ret = g_imm_operand_get_value(G_IMM_OPERAND(sub_op), MDS_32_BITS_UNSIGNED, &offset);
+    if (!ret)
+    {
+        assert(0);
+        return;
+    }
+
+    /* Transformations et conservation d'une position de symbole */
+
+    if (g_armv7_offset_operand_is_positive(G_ARMV7_OFFSET_OPERAND(op)))
+        val_offset = phys_pc + offset;
+    else
+        val_offset = phys_pc - offset;
+
+    init_vmpa(&sym_addr, val_offset, VMPA_NO_VIRTUAL);
+    init_mrange(&sym_range, &sym_addr, 4);
+
+
+
+
+
+
+
+
+    /* Lecture de la valeur vers laquelle renvoyer */
+
+    data = g_binary_format_get_content(format, &length);
+
+
+    printf(">>>>>>> @reading @ 0x%08x (0x%x)\n", (unsigned int)val_offset, offset);
+
+
+    ret = read_u32(&target, data, &val_offset, length, SRE_LITTLE /* FIXME */);
+    if (!ret) return;
+
+
+    printf(">>>>>>> @got target :: 0x%08x\n", (unsigned int)target);
+
+
+
+
+
+    /* Réalise l'intégration du symbole associé */
+
+    sym_instr = g_raw_instruction_new_from_value(&sym_addr, MDS_32_BITS_UNSIGNED, target);
+
+    name_len = strlen(_("Value used @ %s")) + VMPA_MAX_LEN + 1;
+
+    name = (char *)calloc(name_len, sizeof(char));
+
+    vmpa2_virt_to_string(get_mrange_addr(range), MDS_32_BITS, loc, NULL);
+    snprintf(name, name_len, _("Value used @ %s"), loc);
+
+    ADD_RAW_AS_SYM(format, symbol, &sym_addr, sym_instr, comment, name);
+
+    free(name);
+
+
+
+    g_proc_context_push_new_symbol_at(G_PROC_CONTEXT(context), &sym_addr);
+    printf("repush :: from 0x%x :: %x / %x\n",
+           (unsigned int)get_phy_addr(get_mrange_addr(range)),
+           (unsigned int)sym_addr.physical, (unsigned int)sym_addr.virtual);
+
+
+    printf("add sym %p\n", symbol);
+
+
+
+    //g_proc_context_push_new_symbol_at(context, &sym_addr);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //g_imm_operand_set_value(G_IMM_OPERAND(sub_op), MDS_32_BITS_UNSIGNED, target);
+
+
+
+    if (target < 0x8000) return;
+
+
+
+    new = g_imm_operand_new_from_value(MDS_32_BITS_UNSIGNED, target);
+    g_arch_instruction_replace_operand(instr, new, op);
+
+
+
+
+    //exit(0);
+
+
+
+    //target = pc + offset;
+
+    //g_armv7_context_define_encoding(context, target, AV7IS_THUMB);
+    g_armv7_context_push_drop_point_ext(context, target, AV7IS_THUMB);
+
+
+    //exit(0);
+
+}