summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog20
-rw-r--r--src/analysis/disass/Makefile.am2
-rw-r--r--src/analysis/disass/block.c546
-rw-r--r--src/analysis/disass/block.h111
-rw-r--r--src/analysis/disass/dragon.c44
-rw-r--r--src/analysis/disass/dragon.h4
-rw-r--r--src/analysis/disass/rank.c128
-rw-r--r--src/analysis/disass/routines.c5
-rw-r--r--src/analysis/routine.c6
-rw-r--r--src/analysis/routine.h6
10 files changed, 864 insertions, 8 deletions
diff --git a/ChangeLog b/ChangeLog
index 444dbb0..c8bb2c7 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,25 @@
16-05-28 Cyrille Bagard <nocbos@gmail.com>
+ * src/analysis/disass/Makefile.am:
+ Add the 'block.[ch]' files to libanalysisdisass_la_SOURCES, and remove
+ the 'macro.[ch]' ones.
+
+ * src/analysis/disass/block.c:
+ * src/analysis/disass/block.h:
+ New entries: build the basic blocks list simply at loading.
+
+ * src/analysis/disass/dragon.c:
+ * src/analysis/disass/dragon.h:
+ Translate dragon nodes into basic blocks.
+
+ * src/analysis/disass/rank.c:
+ * src/analysis/disass/routines.c:
+ * src/analysis/routine.c:
+ * src/analysis/routine.h:
+ Update code.
+
+16-05-28 Cyrille Bagard <nocbos@gmail.com>
+
* configure.ac:
Remove the Makefile from the 'plugins/python/androperms' directory.
diff --git a/src/analysis/disass/Makefile.am b/src/analysis/disass/Makefile.am
index 7223e5a..b6d123c 100644
--- a/src/analysis/disass/Makefile.am
+++ b/src/analysis/disass/Makefile.am
@@ -3,6 +3,7 @@ noinst_LTLIBRARIES = libanalysisdisass.la
libanalysisdisass_la_SOURCES = \
area.h area.c \
+ block.h block.c \
disassembler.h disassembler.c \
dragon.h dragon.c \
fetch.h fetch.c \
@@ -10,7 +11,6 @@ libanalysisdisass_la_SOURCES = \
limit.h limit.c \
links.h links.c \
loop.h loop.c \
- macro.h macro.c \
output.h output.c \
rank.h rank.c \
routines.h routines.c
diff --git a/src/analysis/disass/block.c b/src/analysis/disass/block.c
new file mode 100644
index 0000000..ff780e6
--- /dev/null
+++ b/src/analysis/disass/block.c
@@ -0,0 +1,546 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * block.c - encadrement des instructions par blocs
+ *
+ * Copyright (C) 2012-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 "block.h"
+
+
+#include <assert.h>
+
+
+
+/* ------------------------ MISE EN PLACE DES BLOCS BASIQUES ------------------------ */
+
+
+/* Description d'un bloc basique d'instructions (instance) */
+struct _GBasicBlock
+{
+ GObject parent; /* A laisser en premier */
+
+ GArchInstruction *first; /* Première instruction */
+ GArchInstruction *last; /* Dernière instruction */
+
+ unsigned int rank; /* Rang dans l'exécution */
+
+};
+
+/* Description d'un bloc basique d'instructions (classe) */
+struct _GBasicBlockClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des blocs d'instructions basique. */
+static void g_basic_block_class_init(GBasicBlockClass *);
+
+/* Initialise un bloc d'instructions basique. */
+static void g_basic_block_init(GBasicBlock *);
+
+/* Supprime toutes les références externes. */
+static void g_basic_block_dispose(GBasicBlock *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_basic_block_finalize(GBasicBlock *);
+
+
+
+/* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
+
+
+/* Description d'une liste de blocs basiques (instance) */
+struct _GBlockList
+{
+ GObject parent; /* A laisser en premier */
+
+ GBasicBlock **blocks; /* Blocs basiques rassemblés */
+ size_t count; /* Quantité de ces blocs */
+
+};
+
+/* Description d'une liste de blocs basiques (classe) */
+struct _GBlockListClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des listes de blocs basiques. */
+static void g_block_list_class_init(GBlockListClass *);
+
+/* Initialise une liste de blocs basiques. */
+static void g_block_list_init(GBlockList *);
+
+/* Supprime toutes les références externes. */
+static void g_block_list_dispose(GBlockList *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_block_list_finalize(GBlockList *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* MISE EN PLACE DES BLOCS BASIQUES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un bloc d'instructions basique. */
+G_DEFINE_TYPE(GBasicBlock, g_basic_block, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe à initialiser. *
+* *
+* Description : Initialise la classe des blocs d'instructions basique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_block_class_init(GBasicBlockClass *class)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(class);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_basic_block_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_basic_block_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance à initialiser. *
+* *
+* Description : Initialise un bloc d'instructions basique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_block_init(GBasicBlock *block)
+{
+ block->rank = -1;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_block_dispose(GBasicBlock *block)
+{
+ g_object_ref(G_OBJECT(block->first));
+ g_object_ref(G_OBJECT(block->last));
+
+ G_OBJECT_CLASS(g_basic_block_parent_class)->dispose(G_OBJECT(block));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_block_finalize(GBasicBlock *block)
+{
+ G_OBJECT_CLASS(g_basic_block_parent_class)->finalize(G_OBJECT(block));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : first = première instruction du bloc. *
+* last = dernière instruction du bloc. *
+* *
+* Description : Crée un bloc basique d'exécution d'instructions. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBasicBlock *g_basic_block_new(GArchInstruction *first, GArchInstruction *last)
+{
+ GBasicBlock *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_BASIC_BLOCK, NULL);
+
+ result->first = first;
+ result->last = last;
+
+ g_object_ref(G_OBJECT(result->first));
+ g_object_ref(G_OBJECT(result->last));
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'instructions à consulter. *
+* first = instruction de départ du bloc. [OUT] *
+* last = dernière instruction du bloc. [OUT] *
+* *
+* Description : Fournit les instructions limites d'un bloc basique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_basic_block_get_boundary(const GBasicBlock *block, GArchInstruction **first, GArchInstruction **last)
+{
+ if (first != NULL)
+ *first = block->first;
+
+ if (last != NULL)
+ *last = block->last;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'instructions à consulter. *
+* start = adresse de départ du bloc. [OUT] *
+* end = dernière adresse du bloc. [OUT] *
+* *
+* Description : Fournit les adresses limites d'un bloc basique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_basic_block_get_boundary_addresses(const GBasicBlock *block, vmpa2t *start, vmpa2t *end)
+{
+ const mrange_t *range; /* Couverture d'instruction */
+
+ if (start != NULL)
+ {
+ range = g_arch_instruction_get_range(block->first);
+ copy_vmpa(start, get_mrange_addr(range));
+ }
+
+ if (end != NULL)
+ {
+ range = g_arch_instruction_get_range(block->last);
+ copy_vmpa(end, get_mrange_addr(range));
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'instructions à consulter. *
+* *
+* Description : Fournit le rang du bloc basique dans le flot d'exécution. *
+* *
+* Retour : Indice supérieur ou égal à zéro. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+unsigned int g_basic_block_get_rank(const GBasicBlock *block)
+{
+ return block->rank;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = bloc d'instructions à consulter. *
+* rank = Indice supérieur à zéro à prendre en compte. *
+* *
+* Description : Définit le rang du bloc basique dans le flot d'exécution. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_basic_block_set_rank(GBasicBlock *block, unsigned int rank)
+{
+ block->rank = rank;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* REGROUPEMENT EN LISTE DE BLOCS */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une liste de blocs basiques. */
+G_DEFINE_TYPE(GBlockList, g_block_list, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe à initialiser. *
+* *
+* Description : Initialise la classe des listes de blocs basiques. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_block_list_class_init(GBlockListClass *class)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(class);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_block_list_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_block_list_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance à initialiser. *
+* *
+* Description : Initialise une liste de blocs basiques. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_block_list_init(GBlockList *list)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_block_list_dispose(GBlockList *list)
+{
+ size_t i; /* Boucle de parcours */
+
+ for (i = 0; i < list->count; i++)
+ if (list->blocks[i] != NULL)
+ g_object_unref(G_OBJECT(list->blocks[i]));
+
+ G_OBJECT_CLASS(g_block_list_parent_class)->dispose(G_OBJECT(list));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : block = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_block_list_finalize(GBlockList *list)
+{
+ G_OBJECT_CLASS(g_block_list_parent_class)->finalize(G_OBJECT(list));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : count = quantité finale de blocs présentie. *
+* *
+* Description : Crée une liste de blocs basiques. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBlockList *g_block_list_new(size_t count)
+{
+ GBlockList *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_BASIC_BLOCK, NULL);
+
+ result->blocks = (GBasicBlock **)calloc(count, sizeof(GBasicBlock *));
+
+ result->count = count;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = liste de blocs basiques à consulter. *
+* *
+* Description : Compte le nombre de blocs basiques représentés. *
+* *
+* Retour : Quantité de blocs basiques rassemblés. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_block_list_count_blocks(const GBlockList *list)
+{
+ return list->count;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = liste de blocs basiques à compléter. *
+* block = bloc d'instructions basique à intégrer. *
+* index = indice de la position d'insertion du bloc. *
+* *
+* Description : Ajoute un bloc basique à une liste définie. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_block_list_add_block(GBlockList *list, GBasicBlock *block, size_t index)
+{
+ assert(index < list->count);
+ assert(list->blocks[index] == NULL);
+
+ list->blocks[index] = block;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = liste de blocs basiques à consulter. *
+* index = indice de la position du bloc recherché. *
+* *
+* Description : Fournit un bloc basique à d'une liste définie. *
+* *
+* Retour : Bloc d'instructions basique trouvé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBasicBlock *g_block_list_get_block(GBlockList *list, size_t index)
+{
+ assert(index < list->count);
+
+ return list->blocks[index];
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = liste de blocs basiques à consulter. *
+* instr = instruction de début de bloc recherchée. *
+* *
+* Description : Recherche un bloc basique selon une première instruction. *
+* *
+* Retour : Bloc basique trouvé ou NULL si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBasicBlock *g_block_list_find_by_starting_instr(const GBlockList *list, GArchInstruction *instr)
+{
+ GBasicBlock *result; /* Trouvaille à retourner */
+ size_t i; /* Boucle de parcours */
+ GBasicBlock *block; /* Bloc basique analysé */
+ GArchInstruction *first; /* Première instruction du bloc*/
+
+ result = NULL;
+
+ for (i = 0; i < list->count && result == NULL; i++)
+ {
+ block = list->blocks[i];
+
+ g_basic_block_get_boundary(block, &first, NULL);
+
+ if (instr == first)
+ result = block;
+
+ }
+
+ return result;
+
+}
diff --git a/src/analysis/disass/block.h b/src/analysis/disass/block.h
new file mode 100644
index 0000000..8d38976
--- /dev/null
+++ b/src/analysis/disass/block.h
@@ -0,0 +1,111 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * block.h - prototypes pour l'encadrement des instructions par blocs
+ *
+ * Copyright (C) 2012-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/>.
+ */
+
+
+#ifndef _ANALYSIS_DISASS_BLOCK_H
+#define _ANALYSIS_DISASS_BLOCK_H
+
+
+#include <glib-object.h>
+
+
+#include "../../arch/instruction.h"
+
+
+
+/* ------------------------ MISE EN PLACE DES BLOCS BASIQUES ------------------------ */
+
+
+#define G_TYPE_BASIC_BLOCK g_basic_block_get_type()
+#define G_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_basic_block_get_type(), GBasicBlock))
+#define G_IS_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_basic_block_get_type()))
+#define G_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BASIC_BLOCK, GBasicBlockClass))
+#define G_IS_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BASIC_BLOCK))
+#define G_BASIC_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BASIC_BLOCK, GBasicBlockClass))
+
+
+/* Description d'un bloc basique d'instructions (instance) */
+typedef struct _GBasicBlock GBasicBlock;
+
+/* Description d'un bloc basique d'instructions (classe) */
+typedef struct _GBasicBlockClass GBasicBlockClass;
+
+
+/* Indique le type défini pour un bloc d'instructions basique. */
+GType g_basic_block_get_type(void);
+
+/* Crée un bloc basique d'exécution d'instructions. */
+GBasicBlock *g_basic_block_new(GArchInstruction *, GArchInstruction *);
+
+/* Fournit les instructions limites d'un bloc basique. */
+void g_basic_block_get_boundary(const GBasicBlock *, GArchInstruction **, GArchInstruction **);
+
+/* Fournit les adresses limites d'un bloc basique. */
+void g_basic_block_get_boundary_addresses(const GBasicBlock *, vmpa2t *, vmpa2t *);
+
+/* Fournit le rang du bloc basique dans le flot d'exécution. */
+unsigned int g_basic_block_get_rank(const GBasicBlock *);
+
+/* Définit le rang du bloc basique dans le flot d'exécution. */
+void g_basic_block_set_rank(GBasicBlock *, unsigned int);
+
+
+
+/* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
+
+
+#define G_TYPE_BLOCK_LIST g_block_list_get_type()
+#define G_BLOCK_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_block_list_get_type(), GBasicBlock))
+#define G_IS_BLOCK_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_block_list_get_type()))
+#define G_BLOCK_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BLOCK_LIST, GBasicBlockClass))
+#define G_IS_BLOCK_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BLOCK_LIST))
+#define G_BLOCK_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BLOCK_LIST, GBasicBlockClass))
+
+
+/* Description d'une liste de blocs basiques (instance) */
+typedef struct _GBlockList GBlockList;
+
+/* Description d'une liste de blocs basiques (classe) */
+typedef struct _GBlockListClass GBlockListClass;
+
+
+/* Indique le type défini pour une liste de blocs basiques. */
+GType g_block_list_get_type(void);
+
+/* Crée une liste de blocs basiques. */
+GBlockList *g_block_list_new(size_t);
+
+/* Compte le nombre de blocs basiques représentés. */
+size_t g_block_list_count_blocks(const GBlockList *);
+
+/* Ajoute un bloc basique à une liste définie. */
+void g_block_list_add_block(GBlockList *, GBasicBlock *, size_t);
+
+/* Fournit un bloc basique à d'une liste définie. */
+GBasicBlock *g_block_list_get_block(GBlockList *, size_t );
+
+/* Recherche un bloc basique selon une première instruction. */
+GBasicBlock *g_block_list_find_by_starting_instr(const GBlockList *, GArchInstruction *);
+
+
+
+#endif /* _ANALYSIS_DISASS_BLOCK_H */
diff --git a/src/analysis/disass/dragon.c b/src/analysis/disass/dragon.c
index 75b8bb7..98b1cd6 100644
--- a/src/analysis/disass/dragon.c
+++ b/src/analysis/disass/dragon.c
@@ -735,3 +735,47 @@ dragon_node *find_knight_node_for_instruction(const dragon_knight *knight, bool
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : knight = rassemblement des complexités de code. *
+* *
+* Description : Traduit une complexité de noeuds en liste de blocs basiques. *
+* *
+* Retour : Liste de blocs basiques créés. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBlockList *translate_dragon_knight(const dragon_knight *knight)
+{
+ GBlockList *result; /* Liste à retourner */
+ dragon_node *nodes; /* Liste des noeuds détectés */
+ size_t count; /* Taille de cette liste */
+ size_t i; /* Boucle de parcours */
+ dragon_node *node; /* Noeud à traiter */
+ GArchInstruction *first; /* Première instruction */
+ GArchInstruction *last; /* Dernière instruction */
+ GBasicBlock *block; /* Nouveau bloc basique */
+
+ get_dragon_knight_content(knight, &nodes, &count);
+
+ result = g_block_list_new(count);
+
+ for (i = 0; i < count; i++)
+ {
+ node = get_dragon_node(nodes, i);
+
+ get_dragon_node_bounding_instructions(node, &first, &last);
+
+ block = g_basic_block_new(first, last);
+
+ g_block_list_add_block(result, block, i);
+
+ }
+
+ return result;
+
+}
diff --git a/src/analysis/disass/dragon.h b/src/analysis/disass/dragon.h
index 3449e6f..9e206f3 100644
--- a/src/analysis/disass/dragon.h
+++ b/src/analysis/disass/dragon.h
@@ -25,6 +25,7 @@
#define _ANALYSIS_DISASS_DRAGON_H
+#include "block.h"
#include "../../arch/processor.h"
#include "../../common/bits.h"
@@ -88,6 +89,9 @@ size_t get_dragon_knight_node_index(const dragon_knight *, dragon_node *);
/* Recherche un noeud selon son intruction de départ. */
dragon_node *find_knight_node_for_instruction(const dragon_knight *, bool, const GArchInstruction *);
+/* Traduit une complexité de noeuds en liste de blocs basiques. */
+GBlockList *translate_dragon_knight(const dragon_knight *);
+
#endif /* _ANALYSIS_DISASS_DRAGON_H */
diff --git a/src/analysis/disass/rank.c b/src/analysis/disass/rank.c
index 85d9e66..3694d04 100644
--- a/src/analysis/disass/rank.c
+++ b/src/analysis/disass/rank.c
@@ -24,6 +24,10 @@
#include "rank.h"
+
+
+#if 0
+
#include <assert.h>
#include <sys/param.h>
@@ -263,3 +267,127 @@ void rank_routine_blocks(GBinRoutine *routine)
}
+
+
+
+#endif
+
+
+
+
+
+
+
+#include <assert.h>
+
+
+
+/* Classe les blocs basiques d'une routine. */
+void rank_routine_block(const GBlockList *, GBasicBlock *);
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : list = ensemble de blocs basiques à traiter. *
+* block = bloc d'analyse courant. *
+* *
+* Description : Classe les blocs basiques d'une routine. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void rank_routine_block(const GBlockList *list, GBasicBlock *block)
+{
+ unsigned int next; /* Rang suivant obtenu */
+ GArchInstruction *last; /* Dernière instruction du bloc*/
+ GArchInstruction **dests; /* Instr. visée par une autre */
+ InstructionLinkType *types; /* Type de lien entre lignes */
+ size_t dcount; /* Nombre de liens de dest. */
+ size_t i; /* Boucle de parcours */
+ GBasicBlock *target; /* Bloc ciblé par un lien */
+ unsigned int rank; /* Rang à constituer */
+
+ next = g_basic_block_get_rank(block) + 1;
+
+ g_basic_block_get_boundary(block, NULL, &last);
+
+ g_arch_instruction_rlock_dest(last);
+ dcount = g_arch_instruction_get_destinations(last, &dests, &types, NULL);
+
+ for (i = 0; i < dcount; i++)
+ {
+ /* La boucle de remontée n'abaisse pas les rangs */
+ if (types[i] == ILT_LOOP) continue;
+
+ target = g_block_list_find_by_starting_instr(list, dests[i]);
+
+ /**
+ * Les sauts ne se font pas toujours à l'intérieur d'une même fonction.
+ * Par exemple sous ARM :
+ *
+ * 00008358 <call_gmon_start>:
+ * ....
+ * 8362: f7ff bfcf b.w 8304 <_init+0x38>
+ * ....
+ *
+ */
+
+ if (target != NULL)
+ {
+ rank = g_basic_block_get_rank(target);
+
+ if (next > rank)
+ {
+ g_basic_block_set_rank(target, rank);
+
+ rank_routine_block(list, target);
+
+ }
+
+ }
+
+ }
+
+ g_arch_instruction_runlock_dest(last);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : routine = routine regroupant les blocs à traiter. *
+* *
+* Description : Classe les blocs des routines. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void rank_routine_blocks(GBinRoutine *routine)
+{
+ GBlockList *blocks; /* Ensemble des blocs d'instr. */
+ GBasicBlock *start; /* Bloc basique de départ */
+
+ blocks = g_binary_routine_get_basic_blocks(routine);
+
+ start = g_block_list_get_block(blocks, 0 /* FIXME */);
+ assert(start != NULL);
+
+
+
+
+ rank_routine_block(blocks, start);
+
+
+
+
+
+
+}
diff --git a/src/analysis/disass/routines.c b/src/analysis/disass/routines.c
index de515d0..9f9c3b6 100644
--- a/src/analysis/disass/routines.c
+++ b/src/analysis/disass/routines.c
@@ -292,6 +292,7 @@ void g_routines_study_handle_blocks(GRoutinesStudy *study, size_t index)
const vmpa2t *start; /* Adresse de départ */
const instr_coverage *coverage; /* Instructions couvertes */
dragon_knight *knight; /* Complexité de code posée */
+ GBlockList *blocks; /* Liste de blocs basiques */
routine = study->routines[index];
@@ -320,7 +321,9 @@ void g_routines_study_handle_blocks(GRoutinesStudy *study, size_t index)
detect_loops_in_code(knight);
- group_routine_instructions(routine, knight);
+ blocks = translate_dragon_knight(knight);
+
+ g_binary_routine_set_basic_blocks(routine, blocks);
rank_routine_blocks(routine);
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index a91e53a..559b9bf 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -56,7 +56,7 @@ struct _GBinRoutine
size_t locals_count; /* Nombre de variables locales */
GArchInstruction *instr; /* Instructions natives */
- GInstrBlock *blocks; /* Blocs basiques d'instruct° */
+ GBlockList *blocks; /* Blocs basiques d'instruct° */
GDecInstruction *dinstr; /* Instructions décompilées */
};
@@ -757,7 +757,7 @@ void g_binary_routine_set_instructions(GBinRoutine *routine, GArchInstruction *i
* *
******************************************************************************/
-GInstrBlock *g_binary_routine_get_basic_blocks(const GBinRoutine *routine)
+GBlockList *g_binary_routine_get_basic_blocks(const GBinRoutine *routine)
{
return routine->blocks;
@@ -777,7 +777,7 @@ GInstrBlock *g_binary_routine_get_basic_blocks(const GBinRoutine *routine)
* *
******************************************************************************/
-void g_binary_routine_set_basic_blocks(GBinRoutine *routine, GInstrBlock *blocks)
+void g_binary_routine_set_basic_blocks(GBinRoutine *routine, GBlockList *blocks)
{
if (routine->blocks != NULL)
g_object_unref(G_OBJECT(routine->blocks));
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 177547b..9ee2c2f 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -30,8 +30,8 @@
#include <sys/types.h>
-#include "block.h"
#include "variable.h"
+#include "disass/block.h"
//#include "../arch/instruction.h"
#include "../decomp/instruction.h"
@@ -164,10 +164,10 @@ GArchInstruction *g_binary_routine_get_instructions(const GBinRoutine *);
void g_binary_routine_set_instructions(GBinRoutine *, GArchInstruction *);
/* Fournit les blocs basiques de la routine. */
-GInstrBlock *g_binary_routine_get_basic_blocks(const GBinRoutine *);
+GBlockList *g_binary_routine_get_basic_blocks(const GBinRoutine *);
/* Définit les blocs basiques de la routine. */
-void g_binary_routine_set_basic_blocks(GBinRoutine *, GInstrBlock *);
+void g_binary_routine_set_basic_blocks(GBinRoutine *, GBlockList *);
/* Fournit les instructions décompilées correspondantes. */
GDecInstruction *g_binary_routine_get_decomp_instructions(const GBinRoutine *);
generated by cgit v0.11.2-87-g4458 at 2024-12-24 03:40:20 (GMT)