Handled all routines disassembling processing in one place.

1 files changed, 268 insertions, 1274 deletions

diff --git a/src/analysis/disass/macro.c b/src/analysis/disass/macro.c
index acb210a..d9d20ee 100644
--- a/src/analysis/disass/macro.c
+++ b/src/analysis/disass/macro.c
@@ -25,8 +25,6 @@
 
 
 #include <assert.h>
-#include <malloc.h>
-#include <stdlib.h>
 
 
 #include "../blocks/flow.h"
@@ -34,115 +32,6 @@
 
 
 
-/* ------------------------ COUVERTURE D'UNE ZONE A DECOUPER ------------------------ */
-
-
-/* Bornes d'une zone à couvrir */
-typedef struct _code_coverage
-{
-    bool initial;                           /* Couverture racine ?         */
-
-    mrange_t range;                         /* Couverture totale           */
-
-    vmpa2t start;                           /* Position butoir de début    */
-
-    vmpa2t *ends;                           /* Positions butoir de fin     */
-    size_t ends_count;                      /* Quantité de fins possibles  */
-
-    unsigned long *processed;               /* Octets traités dans la zone */
-    size_t allocated;                       /* Taille de la cartographie   */
-
-} code_coverage;
-
-
-/* Met en place les délimitations d'une zone de code. */
-static code_coverage *create_code_coverage(const mrange_t *);
-
-/* Crée une copie d'une couverture de zone de code. */
-static code_coverage *dup_code_coverage(const code_coverage *, const vmpa2t *);
-
-/* Détruit des délimitations d'une zone de code. */
-static void delete_code_coverage(code_coverage *);
-
-/* Précise la position de départ courante pour une analyse. */
-static const vmpa2t *get_code_coverage_start_addr(const code_coverage *);
-
-/* Indique si une adresse est hors zone ou non. */
-static bool code_coverage_stop_here(const code_coverage *coverage, const vmpa2t *);
-
-/* Ajoute une adresse butoir pour la zone à couvrir. */
-static bool add_ending_address_code_coverage(code_coverage *, const vmpa2t *);
-
-/* Indique si une zone donnée n'a jamais été traitée ou non. */
-static bool is_range_processed_in_coverage(const code_coverage *, const mrange_t *);
-
-/* Marque une série d'octets comme ayant été traités. */
-static void mark_range_as_processed_in_coverage(code_coverage *, const GArchInstruction *);
-
-
-
-/* ------------------------- SUIVI DES FLOTS D'INSTRUCTIONS ------------------------- */
-
-
-/* Indications sur une branche */
-typedef struct _branch_info
-{
-    vmpa2t *hops;                           /* Jalons de la branche        */
-    size_t count;                           /* Quantité de ces jalons      */
-
-    vmpa2t entry;                           /* Valeur du jalon d'entrée    */
-
-} branch_info;
-
-
-/* Initialise le suivi d'une branche de flot d'exécution. */
-static void init_branch_info(branch_info *);
-
-/* Acte la fin d'un suivi d'une branche de flot d'exécution. */
-static void clean_branch_info(branch_info *);
-
-/* Indique si une adresse est retenue comme point de passage. */
-static bool is_addr_in_branch(const branch_info *, const vmpa2t *);
-
-/* Ajoute un nouveau jalon dans l'exécution d'une branche. */
-static bool add_hop_into_branch(branch_info *, const vmpa2t *);
-
-/* Retourne le premier point d'exécution d'une branche donnée. */
-static const vmpa2t *get_entry_to_branch(const branch_info *);
-
-/* Identifie les différents points de passage d'une branche. */
-static void find_next_hops(GArchProcessor *, const vmpa2t *, const code_coverage *, branch_info *);
-
-/* Retrouve le point de ralliement entre deux branches. */
-static bool compute_first_common_addr(const branch_info *, const branch_info *, vmpa2t *);
-
-
-/* Groupement de branches et d'indications */
-typedef struct _branch_group
-{
-    branch_info *branches;                  /* Liste des branches          */
-    size_t count;                           /* Taille de cette liste       */
-
-} branch_group;
-
-
-/* Initialise le suivi d'un ensemble de branches. */
-static void init_branch_group(branch_group *);
-
-/* Acte la fin d'un suivi d'un ensemble de branches. */
-static void clean_branch_group(branch_group *);
-
-/* Ajoute une branche à un ensemble de branches en place. */
-static branch_info *extend_branch_group(branch_group *);
-
-/* Retrouve le point de ralliement entre un groupe de branches. */
-static bool compute_first_common_addr_in_group(const branch_group *, vmpa2t *);
-
-
-
-/* --------------------------- DECOUPAGE EN BLOCS DE CODE --------------------------- */
-
-
 /**
  * Procédure d'ajout de blocs : pour le premier, on conserve le bloc en mémoire
  * et on attend. Si rien ne suit, il constitura l'unique retour. Sinon, on
@@ -169,389 +58,64 @@ static bool compute_first_common_addr_in_group(const branch_group *, vmpa2t *);
     while (0)
 
 
-/* Procède à la création d'un bloc d'instructions simple. */
-static GInstrBlock *build_instruction_block_simple(GArchProcessor *, code_coverage *, GArchInstruction **, GArchInstruction *);
-
-/* Procède à la définition d'un bloc d'instructions selectif. */
-static GInstrBlock *build_instruction_blocks_case(GArchProcessor *, code_coverage *, const branch_group *, vmpa2t *);
-
-/* Procède à la définition d'un bloc d'instruction if/then/else. */
-static GInstrBlock *build_instruction_blocks_ite(GArchProcessor *, code_coverage *, const branch_info *, const branch_info *, vmpa2t *);
-
-/* Procède à la définition d'un bloc d'instructions d'exception. */
-static void add_instruction_blocks_except(GInstrBlock **, GInstrBlock **, GArchProcessor *, code_coverage *, const branch_group *, const branch_info *);
+/* Détermine la couverture d'un ensemble de chemins. */
+static bitfield_t *compute_other_paths_mask(const dragon_knight *, GArchInstruction **, InstructionLinkType *, size_t, size_t);
 
 /* Procède à la définition de bloc regroupant des instructions. */
-static GInstrBlock *build_instruction_blocks(GArchProcessor *, code_coverage *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          COUVERTURE D'UNE ZONE A DECOUPER                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : range = définition de la zone à couvrir.                     *
-*                                                                             *
-*  Description : Met en place les délimitations d'une zone de code.           *
-*                                                                             *
-*  Retour      : Couverture d'une zone de code.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static code_coverage *create_code_coverage(const mrange_t *range)
-{
-    code_coverage *result;                  /* Couverture à retourner      */
-    phys_t length;                          /* Taille de la zone couverte  */
-    size_t requested;                       /* Nombre de mots à allouer    */
+static GInstrBlock *build_instruction_blocks(GArchProcessor *, const dragon_knight *, dragon_node *, const bitfield_t *, bitfield_t *, size_t *);
 
-    result = (code_coverage *)calloc(1, sizeof(code_coverage));
-
-    result->initial = true;
-
-    copy_mrange(&result->range, range);
-
-    copy_vmpa(&result->start, get_mrange_addr(range));
-
-    result->ends = (vmpa2t *)calloc(1, sizeof(vmpa2t));
-    result->ends_count = 1;
-
-    compute_mrange_end_addr(range, &result->ends[0]);
-
-    length = get_mrange_length(range);
-
-    requested = length / sizeof(unsigned long);
-    if (length % sizeof(unsigned long) != 0) requested++;
-
-    result->processed = (unsigned long *)calloc(requested, sizeof(unsigned long));
-    result->allocated = requested;
-
-    return result;
-
-}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : src = informations de couverture à consulter.                *
-*                new = nouvelle position de début, plus profonde.             *
+*  Paramètres  : knight  = représentation de la complexité du code.           *
+*                dests   = instructions pointées à consulter.                 *
+*                types   = types associés aux destinations.                   *
+*                dcount  = nombre de destinations.                            *
+*                current = indice de la destionation courante.                *
 *                                                                             *
-*  Description : Crée une copie d'une couverture de zone de code.             *
+*  Description : Détermine la couverture d'un ensemble de chemins.            *
 *                                                                             *
-*  Retour      : Couverture d'une zone de code copiée.                        *
+*  Retour      : Champ de bits mis en place.                                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static code_coverage *dup_code_coverage(const code_coverage *src, const vmpa2t *new)
+static bitfield_t *compute_other_paths_mask(const dragon_knight *knight, GArchInstruction **dests, InstructionLinkType *types, size_t dcount, size_t current)
 {
-    code_coverage *result;                  /* Couverture à retourner      */
+    bitfield_t *result;                     /* Couverture à retourner      */
+    size_t length;                          /* Taille du champ de bits     */
+    InstructionLinkType target;             /* Type de noeud à cibler      */
     size_t i;                               /* Boucle de parcours          */
+    dragon_node *node;                      /* Noeud à considérer          */
 
-    result = (code_coverage *)calloc(1, sizeof(code_coverage));
-
-    result->initial = false;
-
-    copy_mrange(&result->range, &src->range);
-
-    copy_vmpa(&result->start, new);
-
-    result->ends = (vmpa2t *)calloc(src->ends_count, sizeof(vmpa2t));
-    result->ends_count = src->ends_count;
-
-    for (i = 0; i < result->ends_count; i++)
-        copy_vmpa(&result->ends[i], &src->ends[i]);
-
-    /**
-     * Les blocs produits par le découpage sont à accès global, et ne sont donc pas
-     * la propriété d'une branche particulière.
-     * Il ne faut donc pas créer deux blocs identiques à partir de deux chemins
-     * différents ; aussi on partage la couverture de code plutôt que la copier.
-     * Et, par ailleurs, c'est plus simple & efficace.
-     */
-
-    result->processed = src->processed;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = structure à libérer de la mémoire.                *
-*                                                                             *
-*  Description : Détruit des délimitations d'une zone de code.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void delete_code_coverage(code_coverage *coverage)
-{
-    free(coverage->ends);
-
-    if (coverage->initial)
-        free(coverage->processed);
-
-    free(coverage);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = informations de couverture à consulter.           *
-*                                                                             *
-*  Description : Précise la position de départ courante pour une analyse.     *
-*                                                                             *
-*  Retour      : Position de départ pour une analyse d'une portion de zone.   *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static const vmpa2t *get_code_coverage_start_addr(const code_coverage *coverage)
-{
-    return &coverage->start;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = informations de couverture à consulter.           *
-*                addr     = localisation à tester.                            *
-*                                                                             *
-*  Description : Indique si une adresse est hors zone ou non.                 *
-*                                                                             *
-*  Retour      : true si l'adresse ne doit pas être couverte, false sinon.    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool code_coverage_stop_here(const code_coverage *coverage, const vmpa2t *addr)
-{
-    void *ptr;                              /* Résultat des recherches     */
-
-    if (!mrange_contains_addr(&coverage->range, addr))
-        return true;
-
-    ptr = bsearch(addr, coverage->ends, coverage->ends_count,
-                  sizeof(vmpa2t), (__compar_fn_t)cmp_vmpa);
-
-    return (ptr != NULL);
-
-}
+    get_dragon_knight_content(knight, NULL, &length);
 
+    result = create_bit_field(length, false);
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = informations de couverture à compléter.           *
-*                addr     = localisation à ajouter.                           *
-*                                                                             *
-*  Description : Ajoute une adresse butoir pour la zone à couvrir.            *
-*                                                                             *
-*  Retour      : true si une insertion a été effectuée, false sinon.          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+    target = types[current];
 
-static bool add_ending_address_code_coverage(code_coverage *coverage, const vmpa2t *addr)
-{
-    bool result;                            /* Bilan à retourner           */
+    if (target == ILT_JUMP_IF_TRUE)
+        target = ILT_JUMP_IF_FALSE;
+    else if (target == ILT_JUMP_IF_FALSE)
+        target = ILT_JUMP_IF_TRUE;
 
-    result = !code_coverage_stop_here(coverage, addr);
+    assert(target == ILT_CASE_JUMP || target == ILT_JUMP_IF_TRUE || target == ILT_JUMP_IF_FALSE);
 
-    if (result)
+    for (i = 0; i < dcount; i++)
     {
-        coverage->ends = (vmpa2t *)realloc(coverage->ends, ++coverage->ends_count * sizeof(vmpa2t));
-
-        copy_vmpa(&coverage->ends[coverage->ends_count - 1], addr);
-
-        qsort(coverage->ends, coverage->ends_count, sizeof(vmpa2t), (__compar_fn_t)cmp_vmpa);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = informations de couverture à consulter.           *
-*                range    = zone à interroger.                                *
-*                                                                             *
-*  Description : Indique si une zone donnée n'a jamais été traitée ou non.    *
-*                                                                             *
-*  Retour      : true si l'aire visée est vierge, false sinon.                *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool is_range_processed_in_coverage(const code_coverage *coverage, const mrange_t *range)
-{
-    bool result;                            /* Bilan à renvoyer            */
-    phys_t diff;                            /* Décalage à appliquer        */
-    size_t index;                           /* Cellule de tableau visée    */
-    unsigned int remaining;                 /* Nombre de bits restants     */
-
-    diff = compute_vmpa_diff(get_mrange_addr(&coverage->range), get_mrange_addr(range));
-    assert(diff < get_mrange_length(&coverage->range));
-
-    index = diff / (sizeof(unsigned long) * 8);
-    remaining = diff % (sizeof(unsigned long) * 8);
-
-    result = ((coverage->processed[index] & (1ul << remaining)) != 0);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : coverage = informations de couverture à consulter.           *
-*                instr    = instruction couvrant la zone à interroger.        *
-*                                                                             *
-*  Description : Marque une série d'octets comme ayant été traités.           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void mark_range_as_processed_in_coverage(code_coverage *coverage, const GArchInstruction *instr)
-{
-    const mrange_t *range;                  /* Emplacement d'instruction   */
-    phys_t diff;                            /* Décalage à appliquer        */
-    size_t index;                           /* Cellule de tableau visée    */
-    unsigned int remaining;                 /* Nombre de bits restants     */
-
-    range = g_arch_instruction_get_range(instr);
-
-    diff = compute_vmpa_diff(get_mrange_addr(&coverage->range), get_mrange_addr(range));
-    assert(diff < get_mrange_length(&coverage->range));
-
-    index = diff / (sizeof(unsigned long) * 8);
-    remaining = diff % (sizeof(unsigned long) * 8);
-
-    coverage->processed[index] |= (1ul << remaining);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           SUIVI DES FLOTS D'INSTRUCTIONS                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : info = informations à initialiser.                           *
-*                                                                             *
-*  Description : Initialise le suivi d'une branche de flot d'exécution.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void init_branch_info(branch_info *info)
-{
-    memset(info, 0, sizeof(branch_info));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : info = informations à nettoyer.                              *
-*                                                                             *
-*  Description : Acte la fin d'un suivi d'une branche de flot d'exécution.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void clean_branch_info(branch_info *info)
-{
-    if (info->hops != NULL)
-        free(info->hops);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : info = informations à consulter.                             *
-*                addr = position à rechercher.                                *
-*                                                                             *
-*  Description : Indique si une adresse est retenue comme point de passage.   *
-*                                                                             *
-*  Retour      : true si le jalon est déjà dans la liste, false sinon.        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool is_addr_in_branch(const branch_info *info, const vmpa2t *addr)
-{
-    void *ptr;                              /* Résultat des recherches     */
-
-    ptr = bsearch(addr, info->hops, info->count,
-                  sizeof(vmpa2t), (__compar_fn_t)cmp_vmpa);
-
-    return (ptr != NULL);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : info = informations de flot à compléter.                     *
-*                addr = localisation à ajouter.                               *
-*                                                                             *
-*  Description : Ajoute un nouveau jalon dans l'exécution d'une branche.      *
-*                                                                             *
-*  Retour      : true si une insertion a été effectuée, false sinon.          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool add_hop_into_branch(branch_info *info, const vmpa2t *addr)
-{
-    bool result;                            /* Bilan à retourner           */
-
-    result = !is_addr_in_branch(info, addr);
-
-    if (result)
-    {
-        if (info->count == 0)
-            copy_vmpa(&info->entry, addr);
+        if (i == current)
+            continue;
 
-        info->hops = (vmpa2t *)realloc(info->hops, ++info->count * sizeof(vmpa2t));
+        if (types[i] == target)
+        {
+            node = find_knight_node_for_instruction(knight, false, dests[i]);
+            if (node == NULL) continue;
 
-        copy_vmpa(&info->hops[info->count - 1], addr);
+            or_bit_field(result, get_paths_bits(node));
 
-        qsort(info->hops, info->count, sizeof(vmpa2t), (__compar_fn_t)cmp_vmpa);
+        }
 
     }
 
@@ -562,983 +126,413 @@ static bool add_hop_into_branch(branch_info *info, const vmpa2t *addr)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : info = informations de flot à consulter.                     *
-*                                                                             *
-*  Description : Retourne le premier point d'exécution d'une branche donnée.  *
-*                                                                             *
-*  Retour      : Point de départ d'une branche.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static const vmpa2t *get_entry_to_branch(const branch_info *info)
-{
-    return &info->entry;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : proc     = ensemble des instructions d'assemblage.           *
-*                start    = position du début de bloc.                        *
-*                coverage = liste des adresses de fin butoir.                 *
-*                count    = nombre de sauts détectés. [OUT]                   *
+*                coverage = délimitations de la zone à couvrir.               *
 *                                                                             *
-*  Description : Identifie les différents points de passage d'une branche.    *
+*  Description : Procède à la définition de bloc regroupant des instructions. *
 *                                                                             *
-*  Retour      : Jalons dans le flot d'exécution.                             *
+*  Retour      : Bloc créé et enregistré, ou NULL si erreur.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void find_next_hops(GArchProcessor *proc, const vmpa2t *start, const code_coverage *coverage, branch_info *info)
+static GInstrBlock *build_instruction_blocks(GArchProcessor *proc, const dragon_knight *knight, dragon_node *node, const bitfield_t *stop, bitfield_t *converted, size_t *next)
 {
-    GArchInstruction *iter;                 /* Boucle de parcours #1       */
-    const mrange_t *range;                  /* Emplacement d'instruction   */
+    GInstrBlock *result;                    /* Regroupement à retourner    */
+    GInstrBlock *result_cached;             /* Temporisation pour unicité  */
+    size_t id;                              /* Indice du bit associé       */
+    GArchInstruction *first;                /* Première instruction de bloc*/
+    GArchInstruction *last;                 /* Dernière instruction de bloc*/
+    GInstrBlock *block;                     /* Nouveau bloc mis en place   */
+    bitfield_t *local_stop;                 /* Arrêts pour les sous-blocs  */
+    bitfield_t *others;                     /* Couvertures des autres      */
     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 #2       */
-    size_t not_handled;                     /* Nombre d'éléments écartés   */
+    size_t i;                               /* Boucle de parcours          */
+    dragon_node *target;                    /* Noeud suivant à traiter     */
+    GInstrBlock *group;                     /* Regroupement à retourner    */
+    GInstrBlock *group_cached ;             /* Temporisation pour unicité  */
 
-    printf(" ---- FN [ %p ] ---------------------------\n", info);
+    result = NULL;
+    result_cached = NULL;
 
 
-    printf("CONTAINS ? %d\n", mrange_contains_addr(&coverage->range, start));
 
-    /* Si la position est déjà présente, on évite de boucler... */
-    if (!add_hop_into_branch(info, start))
-    {
-        printf("  ++ !add 0x%08x\n", (unsigned int)start->virtual);
-        return;
-    }
-    else
-        printf("  ++ add 0x%08x\n", (unsigned int)start->virtual);
 
-    /* On suit le flot jusqu'à la prochaine bifurcation */
-    for (iter = g_arch_processor_find_instr_by_address(proc, start);
-         iter != NULL;
-         iter = g_arch_processor_get_next_instr(proc, iter))
+    while (1)
     {
-        range = g_arch_instruction_get_range(iter);
+        id = get_dragon_knight_node_index(knight, node);
 
-
-        if (code_coverage_stop_here(coverage, get_mrange_addr(range)))
-            printf("  ++ stop here 0x%08x\n", (unsigned int)range->addr.virtual);
-
-        if (code_coverage_stop_here(coverage, get_mrange_addr(range)))
-            break;
+        /**
+         * Si on traite une des branches Vrai/Faux et que cette branche est vide,
+         * on doit s'arrêter.
+         */
 
 
-        if (g_arch_instruction_has_sources(iter))
-            add_hop_into_branch(info, get_mrange_addr(range));
+        //printf("=== [%d] PROCESSING NODE %u (0x%x) in 0x%08x\n", fff, id, 1 << id, gfw(stop));
 
 
+        if (test_in_bit_field(stop, id, 1))
+        {
+            //printf(" -- STOP\n");
+            *next = id;
+            break;
+        }
 
-        if (g_arch_instruction_get_flags(iter) & AIF_RETURN_POINT)
-            printf("  ++ return 0x%08x\n", (unsigned int)range->addr.virtual);
+        /**
+         * Si le bloc a déjà été converti, on arrête la conversion pour la branche courante.
+         *
+         * Cela peut correspondre à la situation suivante quand on revient sur le bloc
+         * inférieur droit :
+         *
+         *      ======
+         *       /  \
+         *     ===  |
+         *     / \  |
+         *     |  `.|
+         *     |   ||
+         *    ===  ===
+         */
 
-        if (g_arch_instruction_get_flags(iter) & AIF_RETURN_POINT)
+        if (test_in_bit_field(converted, id, 1))
         {
-            iter = NULL;
+            //printf(" HALT\n");
+
+            *next = 0;
             break;
         }
 
+        /* Constitution et ajout d'un bloc */
+
+        get_dragon_node_bounding_instructions(node, &first, &last);
+
         /*
-        if (!g_arch_instruction_has_destinations(iter))
-            printf("  ++ no dest 0x%08x\n", (unsigned int)range->addr.virtual);
+        printf("  -- [%d] process block %u  @  0x%08x <-> 0x%08x\n",
+               fff, (unsigned int)id,
+               (unsigned int)first->range.addr.virtual,
+               (unsigned int)last->range.addr.virtual);
         */
 
-        if (!g_arch_instruction_has_destinations(iter))
-            continue;
+        block = g_flow_block_new(proc, first, last);
 
+        DELAYED_BLOCK_ADDING(result, result_cached, block);
 
-        printf("  ++ dcount 0x%08x\n", (unsigned int)range->addr.virtual);
+        set_in_bit_field(converted, id, 1);
 
-        dcount = g_arch_instruction_get_destinations(iter, &dests, &types, NULL);
+        /* Détermination du prochain arrêt */
 
-        not_handled = 0;
+        local_stop = create_bit_field_from(stop, true);
 
-        for (i = 0; i < dcount; i++)
-        {
-            range = g_arch_instruction_get_range(dests[i]);
+        others = NULL;
 
+        dcount = g_arch_instruction_get_destinations(last, &dests, &types, NULL);
+
+        for (i = 0; i < dcount && others == NULL; 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:
-                    find_next_hops(proc, get_mrange_addr(range), coverage, info);
                     break;
 
                 case ILT_LOOP:
-                    add_hop_into_branch(info, get_mrange_addr(range));
                     break;
 
-                default:
-                    not_handled++;
-                    break;
-
-            }
-
-        }
-
-        if (not_handled < dcount)
-            break;
+                case ILT_CASE_JUMP:
+                case ILT_JUMP_IF_TRUE:
+                case ILT_JUMP_IF_FALSE:
 
-    }
+                    target = find_knight_node_for_instruction(knight, false, dests[i]);
+                    if (target == NULL) break;
 
-    /* Si on termine... */
-    if (iter != NULL) add_hop_into_branch(info, get_mrange_addr(range));
+                    id = get_dragon_knight_node_index(knight, target);
 
-    printf(" ------- [ %p ] ---\n", info);
+                    others = compute_other_paths_mask(knight, dests, types, dcount, i);
 
-}
+                    /**
+                     * Si une patte est contenue dans une autre, on place la branche
+                     * incluse comme borne de fin.
+                     */
+                    if (test_in_bit_field(others, id, 1))
+                    {
+                        reset_all_in_bit_field(others);
+                        set_in_bit_field(others, id, 1);
+                    }
 
+                    /**
+                     * Sinon la borne de fin est la sortie commune.
+                     */
+                    else
+                    {
+                        delete_bit_field(others);
+                        others = NULL;
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : a = premier ensemble de jalons à parcourir.                  *
-*                b = second ensemble de jalons à parcourir.                   *
-*                c = éventuelle adresse commune à deux branches.              *
-*                                                                             *
-*  Description : Retrouve le point de ralliement entre deux branches.         *
-*                                                                             *
-*  Retour      : true si une position commune a pu être trouvée, false sinon. *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+                        and_bit_field(local_stop, get_paths_bits(target));
 
-static bool compute_first_common_addr(const branch_info *a, const branch_info *b, vmpa2t *c)
-{
-    bool result;                            /* Bilan à retourner           */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = false;
+                    }
 
+                    break;
 
-    printf("....................\n");
+                case ILT_CATCH_EXCEPTION:
+                    break;
 
-    printf(" A :: ");
-    for (i = 0; i < a->count; i++)
-        printf("0x%08x ", a->hops[i].virtual);
-    printf("\n");
+                default:
+                    //assert(false);
+                    break;
 
-    printf(" B :: ");
-    for (i = 0; i < b->count; i++)
-        printf("0x%08x ", b->hops[i].virtual);
-    printf("\n");
+            }
 
 
-    for (i = 0; i < a->count && !result; i++)
-        if (is_addr_in_branch(b, &a->hops[i]))
+        if (others != NULL)
         {
-            result = true;
-            copy_vmpa(c, &a->hops[i]);
+            //printf(" HO \n");
+            delete_bit_field(local_stop);
+            local_stop = others;
         }
 
-    if (result)
-        printf(" N :: 0x%08x\n", (unsigned int)c->virtual);
-    else
-        printf(" N :: ----\n");
-
-    printf("....................\n");
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group = informations à initialiser.                          *
-*                                                                             *
-*  Description : Initialise le suivi d'un ensemble de branches.               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void init_branch_group(branch_group *group)
-{
-    memset(group, 0, sizeof(branch_group));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group = informations à nettoyer.                             *
-*                                                                             *
-*  Description : Acte la fin d'un suivi d'un ensemble de branches.            *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void clean_branch_group(branch_group *group)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < group->count; i++)
-        clean_branch_info(&group->branches[i]);
-
-    if (group->branches != NULL)
-        free(group->branches);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group = liste d'ensembles de jalons à agrandir.              *
-*                                                                             *
-*  Description : Ajoute une branche à un ensemble de branches en place.       *
-*                                                                             *
-*  Retour      : Nouvel élément rajouté et initialisé.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static branch_info *extend_branch_group(branch_group *group)
-{
-    branch_info *result;                    /* Nouveauté à retourner       */
 
-    group->branches = (branch_info *)realloc(group->branches,
-                                             ++group->count * sizeof(branch_info));
 
-    result = &group->branches[group->count];
+        //printf("  -- [%d] common :: 0x%08x\n", fff, gfw(local_stop));
 
-    init_branch_info(result);
 
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group  = liste d'ensembles de jalons à parcourir.            *
-*                common = éventuelle adresse commune à branches.              *
-*                                                                             *
-*  Description : Retrouve le point de ralliement entre un groupe de branches. *
-*                                                                             *
-*  Retour      : true si une position commune a pu être trouvée, false sinon. *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+        //or_bit_field(local_stop, stop);
 
-static bool compute_first_common_addr_in_group(const branch_group *group, vmpa2t *common)
-{
-    vmpa_t result;                          /* Adresse trouvée à retourner */
-    branch_info *list;                      /* Raccourci de confort        */
-    size_t i;                               /* Boucle de parcours #1       */
-    bool keep;                              /* Candidate à garder ?        */
-    size_t j;                               /* Boucle de parcours #2       */
 
-    result = false;
+        //printf("  -- [%d] common :: 0x%08x\n", fff, gfw(local_stop));
 
-    list = group->branches;
 
-    for (i = 0; i < list[0].count && !result; i++)
-    {
-        keep = true;
+        /* Récupération des sous-blocs */
 
-        for (j = 1; j < group->count && keep; j++)
-            keep = is_addr_in_branch(&list[j], &list[0].hops[i]);
+        *next = 0;
 
-        if (keep)
-            copy_vmpa(common, &list[0].hops[i]);
+        group = NULL;
+        group_cached = NULL;
 
-    }
+        for (i = 0; i < dcount; i++)
+            switch (types[i])
+            {
+                case ILT_EXEC_FLOW:
+                case ILT_JUMP:
 
-    return result;
+                    /* Il ne peut y en avoir qu'un ! */
+                    assert(*next == 0);
 
-}
+                    target = find_knight_node_for_instruction(knight, false, dests[i]);
+                    if (target == NULL) break;
 
+                    *next = get_dragon_knight_node_index(knight, target);
+                    break;
 
+                case ILT_LOOP:
+                    break;
 
-/* ---------------------------------------------------------------------------------- */
-/*                             DECOUPAGE EN BLOCS DE CODE                             */
-/* ---------------------------------------------------------------------------------- */
+                case ILT_CASE_JUMP:
+                case ILT_JUMP_IF_TRUE:
+                case ILT_JUMP_IF_FALSE:
 
+                    target = find_knight_node_for_instruction(knight, false, dests[i]);
+                    if (target == NULL) break;
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : proc     = ensemble des instructions d'assemblage.           *
-*                coverage = délimitations de la zone à couvrir.               *
-*                first    = première instruction d'un bloc préliminaire.      *
-*                cur      = instruction courante dans le traitement.          *
-*                                                                             *
-*  Description : Procède à la création d'un bloc d'instructions simple.       *
-*                                                                             *
-*  Retour      : Bloc créé ou NULL.                                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#include "../../arch/instruction-int.h"
-static GInstrBlock *build_instruction_block_simple(GArchProcessor *proc, code_coverage *coverage, GArchInstruction **first, GArchInstruction *cur)
-{
-    GInstrBlock *result;                    /* Regroupement à retourner    */
- 
-    if (*first != NULL)
-    {
-        result = g_flow_block_new(proc, *first, cur);
+                    /*
+                    printf(" -- call %d -> %zu -> %zu\n",
+                           fff,
+                           get_dragon_knight_node_index(knight, node),
+                           get_dragon_knight_node_index(knight, target));
+                    */
 
-        mark_range_as_processed_in_coverage(coverage, *first);
+                    block = build_instruction_blocks(proc, knight, target, local_stop, converted, &id);
 
-        *first = NULL;
+                    //printf(" -> next id = %zu\n", id);
 
-    }
-    else result = NULL;
 
-    return result;
 
-}
+                    /* Le premier passage crée la référence */
+                    if (*next == 0)
+                        *next = id;
 
+                    /**
+                     * Une patte, première ou nom, peut se terminer alors que
+                     * ses voisines continuent.
+                     *
+                     * Il y a donc plusieurs valeurs pour l'indice suivant :
+                     * un nul et un strictement positif.
+                     *
+                     * Le cas typique est le suivant :
+                     *
+                     *    ======
+                     *     /  \
+                     *     |  |
+                     *    ret |
+                     *        |
+                     *       ===
+                     */
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : proc     = ensemble des instructions d'assemblage.           *
-*                coverage = délimitations de la zone à couvrir.               *
-*                cases    = branches conditionnelles des situations.          *
-*                next     = localisation de l'instruction de reprise.         *
-*                                                                             *
-*  Description : Procède à la définition d'un bloc d'instructions selectif.   *
-*                                                                             *
-*  Retour      : Bloc créé et enregistré, ou NULL si erreur.                  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+                    else if (id > 0)
+                    {
+                        //printf(" NEXT :: %u vs %u\n", *next, id);
+                        assert(*next == id);
+                    }
 
-static GInstrBlock *build_instruction_blocks_case(GArchProcessor *proc, code_coverage *coverage, const branch_group *cases, vmpa2t *next)
-{
-    GInstrBlock *result;                    /* Regroupement à retourner    */
-    bool has_common;                        /* Fin commune ?               */
-    size_t i;                               /* Boucle de parcours #1       */
-    code_coverage *sub_coverage;            /* Couverture pour les suivants*/
-    size_t j;                               /* Boucle de parcours #2       */
-    GInstrBlock *block;                     /* Nouveau bloc mis en place   */
+                    if (block != NULL)
+                        DELAYED_BLOCK_ADDING(group, group_cached, block);
 
-    has_common = compute_first_common_addr_in_group(cases, next);
-    if (!has_common) return NULL;
+                    break;
 
-    result = g_virtual_block_new();
+                case ILT_CATCH_EXCEPTION:
+                    break;
 
-    for (i = 0; i < cases->count; i++)
-    {
-        sub_coverage = dup_code_coverage(coverage, get_entry_to_branch(&cases->branches[i]));
+                default:
+                    //assert(false);
+                    break;
 
-        add_ending_address_code_coverage(sub_coverage, next);
+            }
 
-        for (j = 0; j < cases->count; j++)
-            add_ending_address_code_coverage(sub_coverage, get_entry_to_branch(&cases->branches[j]));
+        if (/*group != NULL || */group_cached != NULL)
+            DELAYED_BLOCK_ADDING(result, result_cached, group != NULL ? group : group_cached);
 
-        block = build_instruction_blocks(proc, sub_coverage);
+        delete_bit_field(local_stop);
 
-        if (block != NULL)
-            g_virtual_block_add_child(G_VIRTUAL_BLOCK(result), block);
+        /* On passe au noeud suivant */
 
-        delete_code_coverage(sub_coverage);
+        if (*next == 0)
+            break;
 
-    }
+        node = get_dragon_knight_node(knight, *next);
 
-    if (g_virtual_block_count_children(G_VIRTUAL_BLOCK(result)) == 0)
-    {
-        g_object_unref(G_OBJECT(result));
-        result = NULL;
     }
 
-    return result;
+    return (result != NULL ? result : result_cached);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : proc         = ensemble des instructions d'assemblage.       *
-*                coverage     = délimitations de la zone à couvrir.           *
-*                true_branch  = branche conditionnelle correspondant à true.  *
-*                false_branch = branche conditionnelle correspondant à false. *
-*                next         = localisation de l'instruction de reprise.     *
+*  Paramètres  : routine = routine en code exécutable à traiter.              *
+*                knight  = rassemblement des complexités de code.             *
 *                                                                             *
-*  Description : Procède à la définition d'un bloc d'instruction if/then/else.*
+*  Description : Procède à la définition de blocs regroupant des instructions.*
 *                                                                             *
-*  Retour      : Bloc créé et enregistré, ou NULL si erreur.                  *
+*  Retour      : Blocs créés et enregistrés, ou NULL si erreur.               *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GInstrBlock *build_instruction_blocks_ite(GArchProcessor *proc, code_coverage *coverage, const branch_info *true_branch, const branch_info *false_branch, vmpa2t *next)
+void group_routine_instructions(GBinRoutine *routine, const dragon_knight *knight)
 {
-    GInstrBlock *result;                    /* Regroupement à retourner    */
-    bool has_common;                        /* Fin commune ?               */
-    GInstrBlock *block;                     /* Nouveau bloc mis en place   */
-
-    has_common = compute_first_common_addr(true_branch, false_branch, next);
-
-
-    if (!has_common)
-    {
-        code_coverage *_sub_coverage;        /* Couverture pour les suivants*/
-
-
-        result = g_virtual_block_new();
-
-
-        /* Branche 'true' */
-
-        _sub_coverage = dup_code_coverage(coverage, get_entry_to_branch(true_branch));
-
-        block = build_instruction_blocks(proc, _sub_coverage);
-
-        delete_code_coverage(_sub_coverage);
-
-        printf("===> !TRUE_BRANCH = %p\n", block);
-
-        if (block != NULL)
-            g_virtual_block_add_child(G_VIRTUAL_BLOCK(result), block);
 
-        /* Branche 'false' */
 
-        _sub_coverage = dup_code_coverage(coverage, get_entry_to_branch(false_branch));
-
-        block = build_instruction_blocks(proc, _sub_coverage);
-
-        delete_code_coverage(_sub_coverage);
+    dragon_node *nodes;                     /* Liste des noeuds détectés   */
+    size_t count;                           /* Taille de cette liste       */
+    dragon_node *node;                      /* Noeud à traiter             */
+    bitfield_t *stop;                       /* Bloc d'arrêt de l'analyse   */
+    bitfield_t *converted;                  /* Cartographie des traitements*/
+    GInstrBlock *blocks;                    /* Blocs basiques construits   */
 
-        printf("===> !FALSE_BRANCH = %p\n", block);
 
-        if (block != NULL)
-            g_virtual_block_add_child(G_VIRTUAL_BLOCK(result), block);
 
-        /* Conclusion */
 
-        if (g_virtual_block_count_children(G_VIRTUAL_BLOCK(result)) == 0)
-        {
-            g_object_unref(G_OBJECT(result));
-            result = NULL;
-        }
 
-        return result;
+    get_dragon_knight_content(knight, &nodes, &count);
 
+    compute_all_paths(nodes, count);
 
 
 
-    }
 
-    assert(has_common);
+#if 0
+    size_t k;
 
-    if (!has_common) printf("   === nothing in common\n");
-    if (!has_common) return NULL;
-
-    result = g_virtual_block_new();
-
-    /**
-     * Encapsulation des branches conditionnelles.
-     */
-
-    GInstrBlock *build_instr_block_bi(GArchProcessor *proc, const code_coverage *coverage, const branch_info *br0, const branch_info *br1, const vmpa2t *next)
+    for (k = 0; k < count; k++)
     {
-        GInstrBlock *result;                /* Bloc construit à renvoyer   */
-        code_coverage *sub_coverage;        /* Couverture pour les suivants*/
-
-        result = NULL;
-
-        if (br0->count > 0)
-        {
-            sub_coverage = dup_code_coverage(coverage, get_entry_to_branch(br0));
-
-            add_ending_address_code_coverage(sub_coverage, next);
+        GArchInstruction *first;
+        GArchInstruction *last;
+        const bitfield_t *paths;
 
-            if (br1->count > 0)
-                add_ending_address_code_coverage(sub_coverage, get_entry_to_branch(br1));
+        node = get_dragon_node(nodes, k);
 
-            result = build_instruction_blocks(proc, sub_coverage);
+        paths = get_paths_bits(node);
 
-            delete_code_coverage(sub_coverage);
+        get_dragon_node_bounding_instructions(node, &first, &last);
 
-        }
 
-        return result;
+        printf("#[ node %zu ]#  @ 0x%08x / 0x%08x  -  mask = 0x%08lx\n", k,
+               (unsigned int)g_arch_instruction_get_range(first)->addr.virtual,
+               (unsigned int)g_arch_instruction_get_range(last)->addr.virtual,
+               gfw(paths));
 
     }
+#endif
 
-    /* Branche 'true' */
-
-    block = build_instr_block_bi(proc, coverage, true_branch, false_branch, next);
-
-    printf("===> TRUE_BRANCH = %p\n", block);
-
-    if (block != NULL)
-        g_virtual_block_add_child(G_VIRTUAL_BLOCK(result), block);
 
-    /* Branche 'false' */
 
-    block = build_instr_block_bi(proc, coverage, false_branch, true_branch, next);
 
-    printf("===> FALSE_BRANCH = %p\n", block);
+    node = get_dragon_node(nodes, 0);
 
-    if (block != NULL)
-        g_virtual_block_add_child(G_VIRTUAL_BLOCK(result), block);
+    stop = create_bit_field(count, false);
+    converted = create_bit_field(count, false);
 
-    /* Conclusion */
-
-    if (g_virtual_block_count_children(G_VIRTUAL_BLOCK(result)) == 0)
-    {
-        g_object_unref(G_OBJECT(result));
-        result = NULL;
-    }
-
-    return result;
+    blocks = build_instruction_blocks(NULL, knight, node, stop, converted, (size_t []) { 0 });
 
-}
+    delete_bit_field(stop);
 
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : result      = liste générale résultante du découpage. [OUT]  *
-*                cached      = emplacement pour le cache des résultats. [OUT] *
-*                proc        = ensemble des instructions d'assemblage.        *
-*                coverage    = délimitations de la zone à couvrir.            *
-*                exceptions  = branche conditionnelle correspondant à true.   *
-*                main_branch = branche principale avec son flot d'exécution.  *
-*                                                                             *
-*  Description : Procède à la définition d'un bloc d'instructions d'exception.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
 
-static void add_instruction_blocks_except(GInstrBlock **result, GInstrBlock **cached, GArchProcessor *proc, code_coverage *coverage, const branch_group *exceptions, const branch_info *main_branch)
-{
-    size_t i;                               /* Boucle de parcours          */
-    vmpa2t stop_addr;                       /* Adresse de fin de bloc      */
-    bool has_stop;                          /* Fin commune ?               */
-    code_coverage *sub_coverage;            /* Couverture pour les suivants*/
-    GInstrBlock *block;                     /* Nouveau bloc mis en place   */
 
-    for (i = 0; i < exceptions->count; i++)
+#if 0
+    bool visit_block(GInstrBlock *blk, BlockVisitOrder order, int *indent)
     {
-        has_stop = compute_first_common_addr(main_branch, &exceptions->branches[i], &stop_addr);
-        if (!has_stop) continue;
-
-        sub_coverage = dup_code_coverage(coverage, get_entry_to_branch(&exceptions->branches[i]));
-        add_ending_address_code_coverage(sub_coverage, &stop_addr);
-
-        block = build_instruction_blocks(proc, sub_coverage);
+        int i;
 
-        if (block != NULL)
-            DELAYED_BLOCK_ADDING(*result, *cached, block);
-
-        delete_code_coverage(sub_coverage);
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : proc     = ensemble des instructions d'assemblage.           *
-*                coverage = délimitations de la zone à couvrir.               *
-*                                                                             *
-*  Description : Procède à la définition de bloc regroupant des instructions. *
-*                                                                             *
-*  Retour      : Bloc créé et enregistré, ou NULL si erreur.                  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#include "../../arch/instruction-int.h"
-static GInstrBlock *build_instruction_blocks(GArchProcessor *proc, code_coverage *coverage)
-{
-    GInstrBlock *result;                    /* Regroupement à retourner    */
-    GInstrBlock *result_cached;             /* Temporisation pour unicité  */
-    branch_info main_branch;                /* Flot d'exécution complet    */
-    GArchInstruction *first;                /* Première instruction        */
-    GArchInstruction *last;                 /* Dernière instruction        */
-    GArchInstruction *iter;                 /* Boucle de parcours          */
-    const mrange_t *range;                  /* Emplacement d'instruction   */
-    const vmpa2t *addr;                     /* Adresse de la destination   */
-    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 #1       */
-    GInstrBlock *block;                     /* Nouveau bloc mis en place   */
-    GInstrBlock *group;                     /* Regroupement de blocs       */
-    size_t not_handled;                     /* Quantité de liens non gérés */
-    vmpa2t next_addr;                       /* Prochaine instruction visée */
-    branch_group  cases_branches;           /* Branches d'un aiguillage    */
-    branch_info true_branch;                /* Branche 'condition vraie'   */
-    branch_info false_branch;               /* Branche 'condition fausse'  */
-    branch_group excep_branches;            /* Branches d'exceptions       */
-    branch_info *branch;                    /* Branche à suivre            */
-
-    result = NULL;
-    result_cached = NULL;
-
-    first = NULL;
-    last = NULL;
-
-    init_branch_info(&main_branch);
-    find_next_hops(proc, get_code_coverage_start_addr(coverage), coverage, &main_branch);
-
-
-    printf("//////////////////////////\n");
-    printf("/// Cutting for 0x%08x -> %p\n",
-           get_code_coverage_start_addr(coverage)->virtual,
-           g_arch_processor_find_instr_by_address(proc, get_code_coverage_start_addr(coverage)));
-    printf("//////////////////////////\n");
-
-
-    for (iter = g_arch_processor_find_instr_by_address(proc, get_code_coverage_start_addr(coverage));
-         iter != NULL;
-         )
-    {
-        range = g_arch_instruction_get_range(iter);
-        addr = get_mrange_addr(range);
-
-        if (code_coverage_stop_here(coverage, addr)) break;
-
-        /* On s'arrête si l'instruction est déjà décompilée */
-        if (is_range_processed_in_coverage(coverage, range)) break;
-
-        if (first == NULL)
-            first = iter;
-
-        last = iter;
-
-        /**
-         * On s'arrête également en fin de procédure.
-         * L'expérience montre qu'il peut y avoir plusieurs fins dans une routine,
-         * et donc des fins en milieu de couverture de cette même routine.
-         */
-        if (g_arch_instruction_get_flags(iter) & AIF_RETURN_POINT) break;
-
-        /* On n'approfondit que les chemins qui se séparent */
-        if (!g_arch_instruction_has_destinations(iter))
+        switch (order)
         {
-            iter = g_arch_processor_get_next_instr(proc, iter);
-            continue;
-        }
-
-        /* Adaptations en fonction du type de bifurcation */
+        case BVO_IN:
+        case BVO_PENDING:
 
-        dcount = g_arch_instruction_get_destinations(iter, &dests, &types, NULL);
+            for (i = 0; i < *indent; i++)
+                printf("   ");
 
-        not_handled = 0;
-        init_vmpa(&next_addr, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL);
+            printf("%p '%s'", blk, G_OBJECT_TYPE_NAME(blk));
 
-        init_branch_group(&cases_branches);
-        init_branch_info(&true_branch);
-        init_branch_info(&false_branch);
-        init_branch_group(&excep_branches);
-
-        for (i = 0; i < dcount; i++)
-        {
-            branch = NULL;
-
-            switch (types[i])
+            if (G_IS_FLOW_BLOCK(blk))
             {
-                case ILT_EXEC_FLOW:
-                case ILT_JUMP:
-
-
-                    //break;
-                {
-                    GArchInstruction *_saved0;
-
-                    _saved0 = first;
-
-                    block = build_instruction_block_simple(proc, coverage, &first, iter);
-                    printf(" -- simple block JMP -- @ 0x%08x <-> 0x%08x\n",
-                           (unsigned int)(_saved0 ? _saved0->range.addr.virtual : ~0),
-                           (unsigned int)iter->range.addr.virtual);
-                    fflush(NULL);
-                }
-                    DELAYED_BLOCK_ADDING(result, result_cached, block);
-
-                    /**
-                     * La prochaine adresse d'analyse est celle visée par l'instruction !
-                     * Pour les sauts naturels, ça ne change rien ; ce n'est pas le cas
-                     * pour les sauts explicites.
-                     */
-                    range = g_arch_instruction_get_range(dests[i]);
-                    copy_vmpa(&next_addr, get_mrange_addr(range));
-
-                    first = NULL;
-
-                    break;
-
-                case ILT_LOOP:
-                    /**
-                     * Lorsque l'on désassemble un flot d'instructions et que l'on rencontre
-                     * une amorce de boucle, il y a deux cas de figure :
-                     *
-                     *    - soit il s'agit d'un ancien JUMP, et la reprise du désassemblage
-                     *      se fera à partir de l'adresse ciblée.
-                     *
-                     *    - soit il s'agit d'un branchement conditionnel dont une des branches
-                     *      conduit à un rebouclage. Le désassemblage s'arrête alors pour la
-                     *      partie en boucle car il n'y a plus d'adresse commune pour la suite.
-                     *
-                     * Il reste donc à forcer une coupure dans le cas suivant :
-                     *
-                     *       ...
-                     *       jmp xxxx
-                     *    loc:
-                     *       ...
-                     *
-                     * Il suffit de ne pas initialiser 'next_addr' et de laisser la main à d'éventuelles
-                     * autres destinations voisines.
-                     */
-                     break;
-
-                case ILT_CASE_JUMP:
-                    branch = extend_branch_group(&cases_branches);
-                    break;
-
-                case ILT_JUMP_IF_TRUE:
-                    printf("FIND TRUE BRANCH @ 0x%08x\n", (unsigned int)iter->range.addr.virtual);
-                    branch = &true_branch;
-                    break;
-
-                case ILT_JUMP_IF_FALSE:
-                    printf("FIND FALSE BRANCH @ 0x%08x\n", (unsigned int)iter->range.addr.virtual);
-                    branch = &false_branch;
-                    break;
-
-                case ILT_CATCH_EXCEPTION:
-                    branch = extend_branch_group(&excep_branches);
-
-                    /**
-                     * Les deux cas sont les seuls à ne pas conduire à une définition de
-                     * next_addr, donc on les comptabilise sur un pied d'égalité !
-                     */
-                    /* break; */
+                vmpa2t start;
+                vmpa2t end;
 
-                default:
-                    not_handled++;
-                    break;
+                g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(blk), &start, &end);
 
-            }
-
-            /* Si on a une branche à compléter... */
-            if (branch != NULL)
-            {
-                range = g_arch_instruction_get_range(dests[i]);
-                addr = get_mrange_addr(range);
-
-                printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
-                printf("BUILD @ 0x%08x\n", (unsigned int)addr->virtual);
-                find_next_hops(proc, addr, coverage, branch);
-                printf("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n");
+                printf("  0x%08x -> 0x%08x",
+                       (unsigned int)start.virtual,
+                       (unsigned int)end.virtual);
 
             }
 
-        }
-
-        /* Post-traitements de ILT_CASE_JUMP */
-        if (cases_branches.count > 0)
-        {
-            block = build_instruction_block_simple(proc, coverage, &first, iter);
-            DELAYED_BLOCK_ADDING(result, result_cached, block);
+            printf("\n");
 
-            group = build_instruction_blocks_case(proc, coverage, &cases_branches, &next_addr);
-
-            if (group != NULL)
-            {
-                DELAYED_BLOCK_ADDING(result, result_cached, group);
-                g_instr_block_set_links_block(block, group);
-            }
-
-        }
-
-        /* Post-traitements de ILT_JUMP_IF_TRUE / ILT_JUMP_IF_FALSE */
-        else if (true_branch.count > 0 || false_branch.count > 0)
-        {
-            block = build_instruction_block_simple(proc, coverage, &first, iter);
-
-            GArchInstruction *_saved1;
-
-            _saved1 = first;
-
-
-
-            printf(" -- branches -- %d vs %d\n", (int)true_branch.count, (int)false_branch.count);
-
-            printf(" -- simple block ITE -- @ 0x%08x <-> 0x%08x\n",
-                   (unsigned int)(_saved1 ? _saved1->range.addr.virtual : ~0),
-                   (unsigned int)iter->range.addr.virtual);
-            fflush(NULL);
-            DELAYED_BLOCK_ADDING(result, result_cached, block);
-
-            group = build_instruction_blocks_ite(proc, coverage, &true_branch, &false_branch, &next_addr);
-
-            printf(" --> group = %p  -  next = 0x%08x\n", group, next_addr.virtual);
-
-            if (group != NULL)
-            {
-                DELAYED_BLOCK_ADDING(result, result_cached, group);
-                g_instr_block_set_links_block(block, group);
-            }
-
-        }
-
-        /* Post-traitements de ILT_CATCH_EXCEPTION */
-        if (excep_branches.count > 0)
-        {
-            block = build_instruction_block_simple(proc, coverage, &first, iter);
-            if (block != NULL) DELAYED_BLOCK_ADDING(result, result_cached, block);
+            if (order == BVO_IN) (*indent)++;
+            break;
 
-            add_instruction_blocks_except(&result, &result_cached, proc, coverage,
-                                          &excep_branches, &main_branch);
+        case BVO_OUT:
+            (*indent)--;
+            break;
 
         }
 
-        clean_branch_group(&cases_branches);
-        clean_branch_info(&true_branch);
-        clean_branch_info(&false_branch);
-        clean_branch_group(&excep_branches);
-
-        /* Détermination du prochain point de chute */
-
-        if (not_handled == dcount)
-            iter = g_arch_processor_get_next_instr(proc, iter);
-        else
-            iter = g_arch_processor_find_instr_by_address(proc, &next_addr);
-
-    }
-
-    if (first != NULL && last != NULL)
-    {
-        range = g_arch_instruction_get_range(first);
-
-        if (!is_range_processed_in_coverage(coverage, range))
-        {
-            block = build_instruction_block_simple(proc, coverage, &first, last);
-            DELAYED_BLOCK_ADDING(result, result_cached, block);
-        }
+        return true;
 
     }
 
-    clean_branch_info(&main_branch);
-
-    return (result != NULL ? result : result_cached);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : proc      = processeur rassemblant les instructions à relier.*
-*                routines  = prototypes existants à insérer.                  *
-*                count     = quantité de ces prototypes.                      *
-*                statusbar = barre de statut avec progression à mettre à jour.*
-*                id        = identifiant du message affiché à l'utilisateur.  *
-*                                                                             *
-*  Description : Regroupe les instructions par blocs.                         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void group_routines_instructions(GArchProcessor *proc, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, bstatus_id_t id)
-{
-    size_t i;                               /* Boucle de parcours          */
-    const mrange_t *range;                  /* Emplacement de routine      */
-    code_coverage *coverage;                /* Couverture de zone de code  */
-    GInstrBlock *block;                     /* Regroupement d'instructions */
-
-    for (i = 0; i < count; i++)
-    {
-        range = g_binary_routine_get_range(routines[i]);
-
-        printf("===== BLOCK(S) for 0x%08x ======\n", range->addr.virtual);
-
-        coverage = create_code_coverage(range);
-
-        block = build_instruction_blocks(proc, coverage);
-
-
-        if (block == NULL) continue;
-
-
-        g_binary_routine_set_basic_blocks(routines[i], block);
-
-
-        bool visit_block(GInstrBlock *blk, BlockVisitOrder order, int *indent)
-        {
-            int i;
-
-            switch (order)
-            {
-                case BVO_IN:
-                case BVO_PENDING:
-
-                    for (i = 0; i < *indent; i++)
-                        printf("   ");
-
-                    printf("%p '%s'", blk, G_OBJECT_TYPE_NAME(blk));
-
-                    if (G_IS_FLOW_BLOCK(blk))
-                    {
-                        vmpa2t start;
-                        vmpa2t end;
-
-                        g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(blk), &start, &end);
-
-                        printf("  0x%08x -> 0x%08x",
-                               (unsigned int)start.virtual,
-                               (unsigned int)end.virtual);
-
-                    }
-
-                    printf("\n");
-
-                    if (order == BVO_IN) (*indent)++;
-                    break;
-
-                case BVO_OUT:
-                    (*indent)--;
-                    break;
-
-            }
-
-            return true;
-
-        }
-
-        g_instr_block_visit(block, (instr_block_visitor_cb)visit_block, (int []){ 0 });
-
-        printf("\n");
+    g_instr_block_visit(blocks, (instr_block_visitor_cb)visit_block, (int []){ 0 });
 
+    printf("\n");
+#endif
 
 
-        delete_code_coverage(coverage);
+    //if (blocks != NULL)
 
-        gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count);
 
-    }
+    g_binary_routine_set_basic_blocks(routine, blocks);
 
 }