Defined a new and simpler way to produce graphical view of basic blocks.

3 files changed, 64 insertions, 5 deletions

diff --git a/src/analysis/disass/block.c b/src/analysis/disass/block.c
index ff780e6..1babe95 100644
--- a/src/analysis/disass/block.c
+++ b/src/analysis/disass/block.c
@@ -41,6 +41,8 @@ struct _GBasicBlock
 
     unsigned int rank;                      /* Rang dans l'exécution       */
 
+    bitfield_t *domination;                 /* Blocs dominés de l'ensemble */
+
 };
 
 /* Description d'un bloc basique d'instructions (classe) */
@@ -188,6 +190,8 @@ static void g_basic_block_dispose(GBasicBlock *block)
 
 static void g_basic_block_finalize(GBasicBlock *block)
 {
+    delete_bit_field(block->domination);
+
     G_OBJECT_CLASS(g_basic_block_parent_class)->finalize(G_OBJECT(block));
 
 }
@@ -197,6 +201,7 @@ static void g_basic_block_finalize(GBasicBlock *block)
 *                                                                             *
 *  Paramètres  : first = première instruction du bloc.                        *
 *                last  = dernière instruction du bloc.                        *
+*                bits  = liste des blocs dominés.                             *
 *                                                                             *
 *  Description : Crée un bloc basique d'exécution d'instructions.             *
 *                                                                             *
@@ -206,7 +211,7 @@ static void g_basic_block_finalize(GBasicBlock *block)
 *                                                                             *
 ******************************************************************************/
 
-GBasicBlock *g_basic_block_new(GArchInstruction *first, GArchInstruction *last)
+GBasicBlock *g_basic_block_new(GArchInstruction *first, GArchInstruction *last, const bitfield_t *bits)
 {
     GBasicBlock *result;                     /* Structure à retourner       */
 
@@ -218,6 +223,8 @@ GBasicBlock *g_basic_block_new(GArchInstruction *first, GArchInstruction *last)
     g_object_ref(G_OBJECT(result->first));
     g_object_ref(G_OBJECT(result->last));
 
+    result->domination = dup_bit_field(bits);
+
     return result;
 
 }
@@ -320,6 +327,25 @@ void g_basic_block_set_rank(GBasicBlock *block, unsigned int rank)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instructions à consulter.                     *
+*                                                                             *
+*  Description : Indique la liste des blocs de code dominés.                  *
+*                                                                             *
+*  Retour      : Champ de bits représentant des blocs.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const bitfield_t *g_basic_block_get_domination(const GBasicBlock *block)
+{
+    return block->domination;
+
+}
+
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                           REGROUPEMENT EN LISTE DE BLOCS                           */
@@ -499,7 +525,7 @@ void g_block_list_add_block(GBlockList *list, GBasicBlock *block, size_t index)
 *                                                                             *
 ******************************************************************************/
 
-GBasicBlock *g_block_list_get_block(GBlockList *list, size_t index)
+GBasicBlock *g_block_list_get_block(const GBlockList *list, size_t index)
 {
     assert(index < list->count);
 
@@ -511,6 +537,32 @@ GBasicBlock *g_block_list_get_block(GBlockList *list, size_t index)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : list  = liste de blocs basiques à consulter.                 *
+*                block = bloc d'instructions basique à considérer.            *
+*                                                                             *
+*  Description : Fournit l'indice d'un bloc basique d'une liste de blocs.     *
+*                                                                             *
+*  Retour      : Indice de la position du bloc fourni en cas de succès.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_block_list_get_index(const GBlockList *list, GBasicBlock *block)
+{
+    size_t result;                          /* Indice trouvé à retourner   */
+
+    for (result = 0; result < list->count; result++)
+        if (list->blocks[result] == block)
+            break;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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.    *
diff --git a/src/analysis/disass/block.h b/src/analysis/disass/block.h
index 8d38976..755dbe6 100644
--- a/src/analysis/disass/block.h
+++ b/src/analysis/disass/block.h
@@ -29,6 +29,7 @@
 
 
 #include "../../arch/instruction.h"
+#include "../../common/bits.h"
 
 
 
@@ -54,7 +55,7 @@ typedef struct _GBasicBlockClass GBasicBlockClass;
 GType g_basic_block_get_type(void);
 
 /* Crée un bloc basique d'exécution d'instructions. */
-GBasicBlock *g_basic_block_new(GArchInstruction *, GArchInstruction *);
+GBasicBlock *g_basic_block_new(GArchInstruction *, GArchInstruction *, const bitfield_t *);
 
 /* Fournit les instructions limites d'un bloc basique. */
 void g_basic_block_get_boundary(const GBasicBlock *, GArchInstruction **, GArchInstruction **);
@@ -68,6 +69,9 @@ 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);
 
+/* Indique la liste des blocs de code dominés. */
+const bitfield_t *g_basic_block_get_domination(const GBasicBlock *);
+
 
 
 /* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
@@ -101,7 +105,10 @@ size_t g_block_list_count_blocks(const GBlockList *);
 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 );
+GBasicBlock *g_block_list_get_block(const GBlockList *, size_t );
+
+/* Fournit l'indice d'un bloc basique d'une liste de blocs. */
+size_t g_block_list_get_index(const GBlockList *, GBasicBlock *);
 
 /* Recherche un bloc basique selon une première instruction. */
 GBasicBlock *g_block_list_find_by_starting_instr(const GBlockList *, GArchInstruction *);
diff --git a/src/analysis/disass/dragon.c b/src/analysis/disass/dragon.c
index 98b1cd6..24c24dc 100644
--- a/src/analysis/disass/dragon.c
+++ b/src/analysis/disass/dragon.c
@@ -770,7 +770,7 @@ GBlockList *translate_dragon_knight(const dragon_knight *knight)
 
         get_dragon_node_bounding_instructions(node, &first, &last);
 
-        block = g_basic_block_new(first, last);
+        block = g_basic_block_new(first, last, node->bits);
 
         g_block_list_add_block(result, block, i);