Defined the first steps towards new graph renderings.

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

4 files changed, 159 insertions, 18 deletions

diff --git a/src/analysis/blocks/flow.c b/src/analysis/blocks/flow.c
index 0b68a14..799931d 100644
--- a/src/analysis/blocks/flow.c
+++ b/src/analysis/blocks/flow.c
@@ -25,6 +25,7 @@
 
 
 #include <malloc.h>
+#include <sys/param.h>
 
 
 #include "../block-int.h"
@@ -36,6 +37,9 @@ struct _GFlowBlock
 {
     GInstrBlock parent;                     /* A laisser en premier        */
 
+    unsigned int rank;                      /* Rang dans l'exécution       */
+    unsigned int next_rank;                 /* Rang suivant de l'exécution */
+
     GArchInstruction *instrs;               /* Liste complète d'instruct°  */
     GArchInstruction *first;                /* Première instruction        */
     GArchInstruction *last;                 /* Dernière instruction        */
@@ -140,6 +144,8 @@ static void g_flow_block_init(GFlowBlock *block)
     parent->list_leafs = (list_leafs_blocks_fc)g_flow_block_list_leafs_blocks;
     //parent->list_regs = (list_regs_accesses_fc)g_flow_block_list_regs_accesses;
 
+    g_flow_block_set_rank(block, 0);
+
     block->regs = g_raccess_list_new();
     block->awaited = g_raccess_list_new();
 
@@ -209,22 +215,8 @@ GInstrBlock *g_flow_block_new(GArchInstruction *instrs, GArchInstruction *first,
 {
     GFlowBlock *result;                     /* Structure à retourner       */
 
-    //vmpa_t addr;                            /* Adresse de la destination   */
-
-
     result = g_object_new(G_TYPE_FLOW_BLOCK, NULL);
 
-
-    /*
-    g_arch_instruction_get_location(first, NULL, NULL, &addr);
-    printf(" ! new block @ 0x%llx - ", addr);
-
-    g_arch_instruction_get_location(last, NULL, NULL, &addr);
-    printf("0x%llx\n", addr);
-    */
-
-
-
     result->instrs = instrs;
     result->first = first;
     result->last = last;
@@ -242,6 +234,85 @@ GInstrBlock *g_flow_block_new(GArchInstruction *instrs, GArchInstruction *first,
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : block = bloc d'instruction à consulter.                      *
+*                                                                             *
+*  Description : Fournit le rang du bloc dans le flot d'exécution.            *
+*                                                                             *
+*  Retour      : Indice supérieur ou égal à zéro.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+unsigned int g_flow_block_get_rank(const GFlowBlock *block)
+{
+    return block->rank;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instruction à consulter.                      *
+*                rank  = Indice supérieur à zéro à prendre en compte.         *
+*                                                                             *
+*  Description : Définit le rang du bloc dans le flot d'exécution.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_flow_block_set_rank(GFlowBlock *block, unsigned int rank)
+{
+    block->rank = MAX(block->rank, rank);
+    g_flow_block_set_next_rank(block, block->rank + 1);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instruction à consulter.                      *
+*                                                                             *
+*  Description : Fournit le rang minimal du bloc suivant pour l'exécution.    *
+*                                                                             *
+*  Retour      : Indice supérieur à zéro.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+unsigned int g_flow_block_get_next_rank(const GFlowBlock *block)
+{
+    return block->next_rank;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instruction à consulter.                      *
+*                rank  = Indice supérieur à zéro à prendre en compte.         *
+*                                                                             *
+*  Description : Définit le rang minimal du bloc suivant pour l'exécution.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_flow_block_set_next_rank(GFlowBlock *block, unsigned int rank)
+{
+    block->next_rank = MAX(block->next_rank, rank);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : block = bloc de départ des recherches.                       *
 *                addr  = ensemble de blocs à parcourir.                       *
 *                final = indique si la cible ou le conteneur est renvoyée.    *
@@ -508,6 +579,61 @@ void g_flow_block_get_boundary_addresses(const GFlowBlock *block, vmpa_t *start,
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : block  = bloc d'instructions démarrant la visite.            *
+*                list   = ensemble des blocs basiques à parcourir.            *
+*                target = bloc de fin de parcours.                            *
+*                                                                             *
+*  Description : Détermine si un bloc peut conduire à un autre.               *
+*                                                                             *
+*  Retour      : true si un lien existe entre les deux blocs fournis.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_flow_block_is_looping_to(GFlowBlock *block, const GInstrBlock *list, GFlowBlock *target)
+{
+    bool result;                            /* Bilan à retourner           */
+    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          */
+    vmpa_t addr;                            /* Adresse de la destination   */
+    GInstrBlock *next;                      /* Bloc suivant à visiter      */
+
+    result = (block == target);
+
+    dcount = g_arch_instruction_get_destinations(block->last, &dests, &types, NULL);
+
+    for (i = 0; i < dcount && !result; i++)
+        switch (types[i])
+        {
+            case ILT_EXEC_FLOW:
+            case ILT_JUMP:
+            case ILT_CASE_JUMP:
+            case ILT_JUMP_IF_TRUE:
+            case ILT_JUMP_IF_FALSE:
+                g_arch_instruction_get_location(dests[i], NULL, NULL, &addr);
+                next = g_instr_block_find_by_addr(list, addr, true);
+                result = g_flow_block_is_looping_to(G_FLOW_BLOCK(next), list, target);
+                break;
+
+            case ILT_LOOP:
+                g_arch_instruction_get_location(dests[i], NULL, NULL, &addr);
+                next = g_instr_block_find_by_addr(list, addr, true);
+                result = (G_FLOW_BLOCK(next) == target);
+            default:
+                break;
+
+        }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : block    = bloc d'instructions démarrant la visite.          *
 *                list     = ensemble des blocs basiques à parcourir.          *
 *                mask     = points de passage à marquer.                      *
diff --git a/src/analysis/blocks/flow.h b/src/analysis/blocks/flow.h
index a01ef64..ab8fada 100644
--- a/src/analysis/blocks/flow.h
+++ b/src/analysis/blocks/flow.h
@@ -70,6 +70,18 @@ GType g_flow_block_get_type(void);
 /* Crée un bloc d'exécution d'instructions. */
 GInstrBlock *g_flow_block_new(GArchInstruction *, GArchInstruction *, GArchInstruction *);
 
+/* Fournit le rang du bloc dans le flot d'exécution. */
+unsigned int g_flow_block_get_rank(const GFlowBlock *);
+
+/* Définit le rang du bloc dans le flot d'exécution. */
+void g_flow_block_set_rank(GFlowBlock *, unsigned int);
+
+/* Fournit le rang minimal du bloc suivant pour l'exécution. */
+unsigned int g_flow_block_get_next_rank(const GFlowBlock *);
+
+/* Définit le rang minimal du bloc suivant pour l'exécution. */
+void g_flow_block_set_next_rank(GFlowBlock *, unsigned int);
+
 /* Fournit la liste d'appartenance des instructions du bloc. */
 GArchInstruction *g_flow_block_get_all_instructions_list(const GFlowBlock *);
 
@@ -79,6 +91,9 @@ void g_flow_block_get_boundary(const GFlowBlock *, GArchInstruction **, GArchIns
 /* Fournit les adresses limites d'un bloc d'exécution. */
 void g_flow_block_get_boundary_addresses(const GFlowBlock *, vmpa_t *, vmpa_t *);
 
+/* Détermine si un bloc peut conduire à un autre. */
+bool g_flow_block_is_looping_to(GFlowBlock *, const GInstrBlock *, GFlowBlock *);
+
 /* Suit le flot d'excution bloc par bloc. */
 bool g_flow_block_follow(GFlowBlock *, const GInstrBlock *, BlockFollowPosition, flow_block_follow_cb, void *);
 
diff --git a/src/analysis/blocks/virtual.c b/src/analysis/blocks/virtual.c
index 0cc6a0d..7f238d4 100644
--- a/src/analysis/blocks/virtual.c
+++ b/src/analysis/blocks/virtual.c
@@ -388,7 +388,7 @@ void g_virtual_block_add_child(GVirtualBlock *block, GInstrBlock *child)
 *                                                                             *
 ******************************************************************************/
 
-size_t g_virtual_block_count_children(GVirtualBlock *block)
+size_t g_virtual_block_count_children(const GVirtualBlock *block)
 {
     return block->children_count;
 
@@ -408,7 +408,7 @@ size_t g_virtual_block_count_children(GVirtualBlock *block)
 *                                                                             *
 ******************************************************************************/
 
-GInstrBlock *g_virtual_block_get_child(GVirtualBlock *block, size_t index)
+GInstrBlock *g_virtual_block_get_child(const GVirtualBlock *block, size_t index)
 {
     if (index >= block->children_count)
         return NULL;
diff --git a/src/analysis/blocks/virtual.h b/src/analysis/blocks/virtual.h
index b254a27..1e4b51d 100644
--- a/src/analysis/blocks/virtual.h
+++ b/src/analysis/blocks/virtual.h
@@ -59,10 +59,10 @@ GInstrBlock *g_virtual_block_new(void);
 void g_virtual_block_add_child(GVirtualBlock *, GInstrBlock *);
 
 /* Compte le nombre de blocs contenus dans le groupe courant. */
-size_t g_virtual_block_count_children(GVirtualBlock *);
+size_t g_virtual_block_count_children(const GVirtualBlock *);
 
 /* Renvoie un des blocs contenus dans le groupe courant. */
-GInstrBlock *g_virtual_block_get_child(GVirtualBlock *, size_t);
+GInstrBlock *g_virtual_block_get_child(const GVirtualBlock *, size_t);