Defined a new kind of code blocks.

8 files changed, 175 insertions, 722 deletions

diff --git a/src/analysis/disass/block.c b/src/analysis/disass/block.c
index 2d01d5d..5c97358 100644
--- a/src/analysis/disass/block.c
+++ b/src/analysis/disass/block.c
@@ -27,6 +27,10 @@
 #include <assert.h>
 
 
+#include "../block-int.h"
+#include "../../glibext/gbinarycursor.h"
+
+
 
 /* ------------------------ MISE EN PLACE DES BLOCS BASIQUES ------------------------ */
 
@@ -34,21 +38,19 @@
 /* Description d'un bloc basique d'instructions (instance) */
 struct _GBasicBlock
 {
-    GObject parent;                         /* A laisser en premier        */
+    GCodeBlock parent;                      /* A laisser en premier        */
+
+    GLoadedBinary *binary;                  /* Binaire chargé et associé   */
 
     GArchInstruction *first;                /* Première instruction        */
     GArchInstruction *last;                 /* Dernière instruction        */
 
-    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) */
 struct _GBasicBlockClass
 {
-    GObjectClass parent;                    /* A laisser en premier        */
+    GCodeBlockClass parent;                 /* A laisser en premier        */
 
 };
 
@@ -65,40 +67,14 @@ static void g_basic_block_dispose(GBasicBlock *);
 /* Procède à la libération totale de la mémoire. */
 static void g_basic_block_finalize(GBasicBlock *);
 
+/* Détermine si un bloc de code débute à une adresse donnée. */
+static bool g_basic_block_is_starting_with(const GBasicBlock *, const vmpa2t *);
 
+/* Etablit les liens entre un bloc de code et ses voisins. */
+static void g_basic_block_resolve_links(GBasicBlock *, const GBlockList *);
 
-/* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
-
-
-/* Description d'une liste de blocs basiques (instance) */
-struct _GBlockList
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    GBasicBlock **blocks;                   /* Blocs basiques rassemblés   */
-    size_t count;                           /* Quantité de ces blocs       */
-
-};
-
-/* Description d'une liste de blocs basiques (classe) */
-struct _GBlockListClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe des listes de blocs basiques. */
-static void g_block_list_class_init(GBlockListClass *);
-
-/* Initialise une liste de blocs basiques. */
-static void g_block_list_init(GBlockList *);
-
-/* Supprime toutes les références externes. */
-static void g_block_list_dispose(GBlockList *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_block_list_finalize(GBlockList *);
+/* Fournit la représentation graphique d'un bloc de code. */
+static GBufferView *g_basic_block_build_view(const GBasicBlock *, segcnt_list *);
 
 
 
@@ -108,7 +84,7 @@ static void g_block_list_finalize(GBlockList *);
 
 
 /* Indique le type défini pour un bloc d'instructions basique. */
-G_DEFINE_TYPE(GBasicBlock, g_basic_block, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GBasicBlock, g_basic_block, G_TYPE_CODE_BLOCK);
 
 
 /******************************************************************************
@@ -126,12 +102,19 @@ G_DEFINE_TYPE(GBasicBlock, g_basic_block, G_TYPE_OBJECT);
 static void g_basic_block_class_init(GBasicBlockClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
+    GCodeBlockClass *block;                 /* Version parente de la classe*/
 
     object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_basic_block_dispose;
     object->finalize = (GObjectFinalizeFunc)g_basic_block_finalize;
 
+    block = G_CODE_BLOCK_CLASS(class);
+
+    block->is_starting = (block_is_starting_fc)g_basic_block_is_starting_with;
+    block->link = (block_resolve_links_fc)g_basic_block_resolve_links;
+    block->build = (block_build_view_fc)g_basic_block_build_view;
+
 }
 
 
@@ -149,7 +132,6 @@ static void g_basic_block_class_init(GBasicBlockClass *class)
 
 static void g_basic_block_init(GBasicBlock *block)
 {
-    block->rank = -1;
 
 }
 
@@ -168,8 +150,10 @@ static void g_basic_block_init(GBasicBlock *block)
 
 static void g_basic_block_dispose(GBasicBlock *block)
 {
-    g_object_ref(G_OBJECT(block->first));
-    g_object_ref(G_OBJECT(block->last));
+    g_object_unref(G_OBJECT(block->binary));
+
+    g_object_unref(G_OBJECT(block->first));
+    g_object_unref(G_OBJECT(block->last));
 
     G_OBJECT_CLASS(g_basic_block_parent_class)->dispose(G_OBJECT(block));
 
@@ -190,8 +174,6 @@ 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));
 
 }
@@ -199,9 +181,10 @@ 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.                             *
+*  Paramètres  : binary = binaire chargé contenant les instructions.          *
+*                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.             *
 *                                                                             *
@@ -211,57 +194,37 @@ static void g_basic_block_finalize(GBasicBlock *block)
 *                                                                             *
 ******************************************************************************/
 
-GBasicBlock *g_basic_block_new(GArchInstruction *first, GArchInstruction *last, const bitfield_t *bits)
+GCodeBlock *g_basic_block_new(GLoadedBinary *binary, GArchInstruction *first, GArchInstruction *last, const bitfield_t *bits)
 {
-    GBasicBlock *result;                     /* Structure à retourner       */
+    GBasicBlock *result;                    /* Structure à retourner       */
+    GCodeBlock *parent;                     /* Version parente d'instance  */
 
     result = g_object_new(G_TYPE_BASIC_BLOCK, NULL);
 
+    result->binary = binary;
+    g_object_ref(G_OBJECT(binary));
+
     result->first = first;
     result->last = last;
 
-    g_object_ref(G_OBJECT(result->first));
-    g_object_ref(G_OBJECT(result->last));
+    g_object_ref(G_OBJECT(first));
+    g_object_ref(G_OBJECT(last));
 
-    result->domination = dup_bit_field(bits);
+    parent = G_CODE_BLOCK(result);
 
-    return result;
-
-}
+    parent->domination = dup_bit_field(bits);
 
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc d'instructions à consulter.                     *
-*                first = instruction de départ du bloc. [OUT]                 *
-*                last  = dernière instruction du bloc. [OUT]                  *
-*                                                                             *
-*  Description : Fournit les instructions limites d'un bloc basique.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_basic_block_get_boundary(const GBasicBlock *block, GArchInstruction **first, GArchInstruction **last)
-{
-    if (first != NULL)
-        *first = block->first;
-
-    if (last != NULL)
-        *last = block->last;
+    return parent;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : block = bloc d'instructions à consulter.                     *
-*                start = adresse de départ du bloc. [OUT]                     *
-*                end   = dernière adresse du bloc. [OUT]                      *
+*  Paramètres  : block = bloc de code à consulter.                            *
+*                addr  = localisation à comparer.                             *
 *                                                                             *
-*  Description : Fournit les adresses limites d'un bloc basique.              *
+*  Description : Détermine si un bloc de code débute à une adresse donnée.    *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -269,140 +232,26 @@ void g_basic_block_get_boundary(const GBasicBlock *block, GArchInstruction **fir
 *                                                                             *
 ******************************************************************************/
 
-void g_basic_block_get_boundary_addresses(const GBasicBlock *block, vmpa2t *start, vmpa2t *end)
+static bool g_basic_block_is_starting_with(const GBasicBlock *block, const vmpa2t *addr)
 {
+    bool result;                            /* Bilan à retourner           */
     const mrange_t *range;                  /* Couverture d'instruction    */
 
-    if (start != NULL)
-    {
-        range = g_arch_instruction_get_range(block->first);
-        copy_vmpa(start, get_mrange_addr(range));
-    }
+    range = g_arch_instruction_get_range(block->first);
 
-    if (end != NULL)
-    {
-        range = g_arch_instruction_get_range(block->last);
-        copy_vmpa(end, get_mrange_addr(range));
-    }
+    result = (cmp_vmpa(addr, get_mrange_addr(range)) == 0);
 
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc d'instructions à consulter.                     *
-*                                                                             *
-*  Description : Fournit le rang du bloc basique dans le flot d'exécution.    *
-*                                                                             *
-*  Retour      : Indice supérieur ou égal à zéro.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-unsigned int g_basic_block_get_rank(const GBasicBlock *block)
-{
-    return block->rank;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc d'instructions à consulter.                     *
-*                rank  = Indice supérieur à zéro à prendre en compte.         *
-*                                                                             *
-*  Description : Définit le rang du bloc basique dans le flot d'exécution.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_basic_block_set_rank(GBasicBlock *block, unsigned int rank)
-{
-    block->rank = rank;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  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                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour une liste de blocs basiques. */
-G_DEFINE_TYPE(GBlockList, g_block_list, G_TYPE_OBJECT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des listes de blocs basiques.           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_block_list_class_init(GBlockListClass *class)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(class);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_block_list_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_block_list_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = instance à initialiser.                              *
-*                                                                             *
-*  Description : Initialise une liste de blocs basiques.                      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_block_list_init(GBlockList *list)
-{
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : block = instance d'objet GLib à traiter.                     *
+*  Paramètres  : block = bloc de code à mettre à jour.                        *
+*                list  = ensemble des blocs de code à disposition.            *
 *                                                                             *
-*  Description : Supprime toutes les références externes.                     *
+*  Description : Etablit les liens entre un bloc de code et ses voisins.      *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -410,150 +259,87 @@ static void g_block_list_init(GBlockList *list)
 *                                                                             *
 ******************************************************************************/
 
-static void g_block_list_dispose(GBlockList *list)
+static void g_basic_block_resolve_links(GBasicBlock *block, const GBlockList *list)
 {
+    size_t dcount;                          /* Nombre de liens de dest.    */
     size_t i;                               /* Boucle de parcours          */
+    const instr_link_t *dest;               /* Instr. visée par une autre  */
+    const mrange_t *range;                  /* Couverture d'instruction    */
+    GCodeBlock *target;                     /* Bloc ciblé par un lien      */
 
-    for (i = 0; i < list->count; i++)
-        if (list->blocks[i] != NULL)
-            g_object_unref(G_OBJECT(list->blocks[i]));
-
-    G_OBJECT_CLASS(g_block_list_parent_class)->dispose(G_OBJECT(list));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = instance d'objet GLib à traiter.                     *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_block_list_finalize(GBlockList *list)
-{
-    G_OBJECT_CLASS(g_block_list_parent_class)->finalize(G_OBJECT(list));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : count = quantité finale de blocs présentie.                  *
-*                                                                             *
-*  Description : Crée une liste de blocs basiques.                            *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBlockList *g_block_list_new(size_t count)
-{
-    GBlockList *result;                     /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_BASIC_BLOCK, NULL);
-
-    result->blocks = (GBasicBlock **)calloc(count, sizeof(GBasicBlock *));
-
-    result->count = count;
-
-    return result;
-
-}
+    g_arch_instruction_lock_dest(block->last);
+    dcount = g_arch_instruction_count_destinations(block->last);
 
+    for (i = 0; i < dcount; i++)
+    {
+        dest = g_arch_instruction_get_destination(block->last, i);
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : list = liste de blocs basiques à consulter.                  *
-*                                                                             *
-*  Description : Compte le nombre de blocs basiques représentés.              *
-*                                                                             *
-*  Retour      : Quantité de blocs basiques rassemblés.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+        range = g_arch_instruction_get_range(dest->linked);
 
-size_t g_block_list_count_blocks(const GBlockList *list)
-{
-    return list->count;
+        target = g_block_list_find_by_starting_instr(list, get_mrange_addr(range));
 
-}
+        /**
+         * Les sauts ne se font pas toujours à l'intérieur d'une même fonction.
+         * Par exemple sous ARM :
+         *
+         *    00008358 <call_gmon_start>:
+         *        ....
+         *        8362:       f7ff bfcf       b.w     8304 <_init+0x38>
+         *        ....
+         *
+         */
 
+        if (target != NULL)
+        {
+            g_code_block_link_with(G_CODE_BLOCK(block), target, dest->type);
+            g_object_unref(G_OBJECT(target));
+        }
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : list  = liste de blocs basiques à compléter.                 *
-*                block = bloc d'instructions basique à intégrer.              *
-*                index = indice de la position d'insertion du bloc.           *
-*                                                                             *
-*  Description : Ajoute un bloc basique à une liste définie.                  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+        unref_instr_link(dest);
 
-void g_block_list_add_block(GBlockList *list, GBasicBlock *block, size_t index)
-{
-    assert(index < list->count);
-    assert(list->blocks[index] == NULL);
+    }
 
-    list->blocks[index] = block;
+    g_arch_instruction_unlock_dest(block->last);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : list  = liste de blocs basiques à consulter.                 *
-*                index = indice de la position du bloc recherché.             *
+*  Paramètres  : block       = bloc de code à manipuler.                      *
+*                highlighted = gestionnaire de surbrillance pour segments.    *
 *                                                                             *
-*  Description : Fournit un bloc basique à d'une liste définie.               *
+*  Description : Fournit la représentation graphique d'un bloc de code.       *
 *                                                                             *
-*  Retour      : Bloc d'instructions basique trouvé.                          *
+*  Retour      : Vue d'un cache de lignes.                                    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GBasicBlock *g_block_list_get_block(const GBlockList *list, size_t index)
+static GBufferView *g_basic_block_build_view(const GBasicBlock *block, segcnt_list *highlighted)
 {
-    assert(index < list->count);
+    GBufferView *result;                    /* Instance à retourner        */
+    const mrange_t *first_range;            /* Couverture d'instruction #1 */
+    const mrange_t *last_range;             /* Couverture d'instruction #2 */
+    GLineCursor *start;                     /* Départ de zone couverture   */
+    GLineCursor *end;                       /* Fin de zone couverture      */
+    GBufferCache *cache;                    /* Tampon brut à découper      */
 
-    return list->blocks[index];
+    first_range = g_arch_instruction_get_range(block->first);
+    last_range = g_arch_instruction_get_range(block->last);
 
-}
+    start = g_binary_cursor_new();
+    g_binary_cursor_update(G_BINARY_CURSOR(start), get_mrange_addr(first_range));
 
+    end = g_binary_cursor_new();
+    g_binary_cursor_update(G_BINARY_CURSOR(end), get_mrange_addr(last_range));
 
-/******************************************************************************
-*                                                                             *
-*  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   : -                                                            *
-*                                                                             *
-******************************************************************************/
+    cache = g_loaded_binary_get_disassembled_cache(block->binary);
 
-size_t g_block_list_get_index(const GBlockList *list, GBasicBlock *block)
-{
-    size_t result;                          /* Indice trouvé à retourner   */
+    result = g_buffer_view_new(cache, highlighted);
 
-    for (result = 0; result < list->count; result++)
-        if (list->blocks[result] == block)
-            break;
+    g_buffer_view_restrict(result, start, end);
 
     return result;
 
@@ -562,37 +348,30 @@ size_t g_block_list_get_index(const GBlockList *list, GBasicBlock *block)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : list  = liste de blocs basiques à consulter.                 *
-*                instr = instruction de début de bloc recherchée.             *
+*  Paramètres  : block = bloc d'instructions à consulter.                     *
+*                first = instruction de départ du bloc. [OUT]                 *
+*                last  = dernière instruction du bloc. [OUT]                  *
 *                                                                             *
-*  Description : Recherche un bloc basique selon une première instruction.    *
+*  Description : Fournit les instructions limites d'un bloc basique.          *
 *                                                                             *
-*  Retour      : Bloc basique trouvé ou NULL si aucun.                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GBasicBlock *g_block_list_find_by_starting_instr(const GBlockList *list, GArchInstruction *instr)
+void g_basic_block_get_boundary(const GBasicBlock *block, GArchInstruction **first, GArchInstruction **last)
 {
-    GBasicBlock *result;                    /* Trouvaille à retourner      */
-    size_t i;                               /* Boucle de parcours          */
-    GBasicBlock *block;                     /* Bloc basique analysé        */
-    GArchInstruction *first;                /* Première instruction du bloc*/
-
-    result = NULL;
-
-    for (i = 0; i < list->count && result == NULL; i++)
+    if (first != NULL)
     {
-        block = list->blocks[i];
-
-        g_basic_block_get_boundary(block, &first, NULL);
-
-        if (instr == first)
-            result = block;
-
+        *first = block->first;
+        g_object_ref(G_OBJECT(*first));
     }
 
-    return result;
+    if (last != NULL)
+    {
+        *last = block->last;
+        g_object_ref(G_OBJECT(*last));
+    }
 
 }
diff --git a/src/analysis/disass/block.h b/src/analysis/disass/block.h
index 68cade7..eab0b27 100644
--- a/src/analysis/disass/block.h
+++ b/src/analysis/disass/block.h
@@ -28,6 +28,8 @@
 #include <glib-object.h>
 
 
+#include "../binary.h"
+#include "../block.h"
 #include "../../arch/instruction.h"
 #include "../../common/bits.h"
 
@@ -55,64 +57,11 @@ 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 *, const bitfield_t *);
+GCodeBlock *g_basic_block_new(GLoadedBinary *, GArchInstruction *, GArchInstruction *, const bitfield_t *);
 
 /* Fournit les instructions limites d'un bloc basique. */
 void g_basic_block_get_boundary(const GBasicBlock *, GArchInstruction **, GArchInstruction **);
 
-/* Fournit les adresses limites d'un bloc basique. */
-void g_basic_block_get_boundary_addresses(const GBasicBlock *, vmpa2t *, vmpa2t *);
-
-/* Fournit le rang du bloc basique dans le flot d'exécution. */
-unsigned int g_basic_block_get_rank(const GBasicBlock *);
-
-/* Définit le rang du bloc basique dans le flot d'exécution. */
-void g_basic_block_set_rank(GBasicBlock *, unsigned int);
-
-/* Indique la liste des blocs de code dominés. */
-const bitfield_t *g_basic_block_get_domination(const GBasicBlock *);
-
-
-
-/* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
-
-
-#define G_TYPE_BLOCK_LIST               g_block_list_get_type()
-#define G_BLOCK_LIST(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_block_list_get_type(), GBlockList))
-#define G_IS_BLOCK_LIST(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_block_list_get_type()))
-#define G_BLOCK_LIST_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BLOCK_LIST, GBlockListClass))
-#define G_IS_BLOCK_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BLOCK_LIST))
-#define G_BLOCK_LIST_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BLOCK_LIST, GBlockListClass))
-
-
-/* Description d'une liste de blocs basiques (instance) */
-typedef struct _GBlockList GBlockList;
-
-/* Description d'une liste de blocs basiques (classe) */
-typedef struct _GBlockListClass GBlockListClass;
-
-
-/* Indique le type défini pour une liste de blocs basiques. */
-GType g_block_list_get_type(void);
-
-/* Crée une liste de blocs basiques. */
-GBlockList *g_block_list_new(size_t);
-
-/* Compte le nombre de blocs basiques représentés. */
-size_t g_block_list_count_blocks(const GBlockList *);
-
-/* Ajoute un bloc basique à une liste définie. */
-void g_block_list_add_block(GBlockList *, GBasicBlock *, size_t);
-
-/* Fournit un bloc basique à d'une liste définie. */
-GBasicBlock *g_block_list_get_block(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 *);
-
 
 
 #endif  /* _ANALYSIS_DISASS_BLOCK_H */
diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c
index 6e71ed6..f229af3 100644
--- a/src/analysis/disass/disassembler.c
+++ b/src/analysis/disass/disassembler.c
@@ -52,7 +52,7 @@
 static void process_all_instructions(wgroup_id_t, GtkStatusStack *, const char *, ins_fallback_cb, GArchProcessor *, GProcContext *, GExeFormat *);
 
 /* Opère sur toutes les routines. */
-static void process_all_routines(wgroup_id_t, GtkStatusStack *, const char *, rtn_fallback_cb, GArchProcessor *, GBinFormat *);
+static void process_all_routines(GLoadedBinary *, wgroup_id_t, GtkStatusStack *, const char *, rtn_fallback_cb);
 
 /* Réalise un désassemblage effectif. */
 static void compute_disassembly(GLoadedBinary *, GProcContext *, wgroup_id_t, GtkStatusStack *);
@@ -127,12 +127,11 @@ static void process_all_instructions(wgroup_id_t gid, GtkStatusStack *status, co
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : gid      = groupe de travail impliqué.                       *
+*  Paramètres  : binary   = binaire chargé comprenant les routines à traiter. *
+*                gid      = groupe de travail impliqué.                       *
                  status   = barre de statut à tenir informée.                 *
 *                msg      = message à faire paraître pour la patience.        *
 *                fallback = routine de traitements particuliers.              *
-*                proc     = ensemble d'instructions désassemblées.            *
-*                format   = accès aux données du binaire d'origine.           *
 *                                                                             *
 *  Description : Opère sur toutes les routines.                               *
 *                                                                             *
@@ -142,8 +141,9 @@ static void process_all_instructions(wgroup_id_t gid, GtkStatusStack *status, co
 *                                                                             *
 ******************************************************************************/
 
-static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const char *msg, rtn_fallback_cb fallback, GArchProcessor *proc, GBinFormat *format)
+static void process_all_routines(GLoadedBinary *binary, wgroup_id_t gid, GtkStatusStack *status, const char *msg, rtn_fallback_cb fallback)
 {
+    GBinFormat *format;                     /* Format associé au binaire   */
     GBinPortion *portions;                  /* Couche première de portions */
     size_t sym_count;                       /* Nombre de ces symboles      */
     guint runs_count;                       /* Qté d'exécutions parallèles */
@@ -155,6 +155,8 @@ static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const
     size_t end;                             /* Fin d'un bloc de traitement */
     GRoutinesStudy *study;                  /* Tâche d'étude à programmer  */
 
+    format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
+
     portions = g_exe_format_get_portions(G_EXE_FORMAT(format));
 
     g_binary_format_lock_symbols_rd(format);
@@ -178,8 +180,7 @@ static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const
         else
             end = begin + run_size;
 
-        study = g_routines_study_new(proc, format, portions,
-                                     begin, end, id, fallback);
+        study = g_routines_study_new(binary, portions, begin, end, id, fallback);
 
         g_work_queue_schedule_work(queue, G_DELAYED_WORK(study), gid);
 
@@ -193,6 +194,8 @@ static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const
 
     g_object_unref(G_OBJECT(portions));
 
+    g_object_unref(G_OBJECT(format));
+
 }
 
 
@@ -293,9 +296,9 @@ static void compute_disassembly(GLoadedBinary *binary, GProcContext *context, wg
      * Quatrième étape : établissement des couvertures de routines restantes.
      */
 
-    process_all_routines(gid, status,
+    process_all_routines(binary, gid, status,
                          _("Finding remaining limits..."),
-                         g_routines_study_compute_limits, proc, G_BIN_FORMAT(format));
+                         g_routines_study_compute_limits);
 
     process_disassembly_event(PGA_DISASSEMBLY_LIMITED, binary, status, context);
 
@@ -317,9 +320,9 @@ static void compute_disassembly(GLoadedBinary *binary, GProcContext *context, wg
      * Sixième étape : regroupement en blocs basiques.
      */
 
-    process_all_routines(gid, status,
+    process_all_routines(binary, gid, status,
                          _("Control-flow analysis for routines..."),
-                         g_routines_study_handle_blocks, proc, G_BIN_FORMAT(format));
+                         g_routines_study_handle_blocks);
 
     process_disassembly_event(PGA_DISASSEMBLY_GROUPED, binary, status, context);
 
diff --git a/src/analysis/disass/dragon.c b/src/analysis/disass/dragon.c
index 04f5190..ad20b24 100644
--- a/src/analysis/disass/dragon.c
+++ b/src/analysis/disass/dragon.c
@@ -28,6 +28,9 @@
 #include <malloc.h>
 
 
+#include "block.h"
+
+
 
 /* ---------------------------- ENCAPSULATION DES NOEUDS ---------------------------- */
 
@@ -801,6 +804,7 @@ dragon_node *find_knight_node_for_instruction(const dragon_knight *knight, bool
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : knight = rassemblement des complexités de code.              *
+*                binary = binaire contenant l'ensemble des instructions.      *
 *                                                                             *
 *  Description : Traduit une complexité de noeuds en liste de blocs basiques. *
 *                                                                             *
@@ -810,7 +814,7 @@ dragon_node *find_knight_node_for_instruction(const dragon_knight *knight, bool
 *                                                                             *
 ******************************************************************************/
 
-GBlockList *translate_dragon_knight(const dragon_knight *knight)
+GBlockList *translate_dragon_knight(const dragon_knight *knight, GLoadedBinary *binary)
 {
     GBlockList *result;                     /* Liste à retourner           */
     dragon_node *nodes;                     /* Liste des noeuds détectés   */
@@ -819,7 +823,7 @@ GBlockList *translate_dragon_knight(const dragon_knight *knight)
     dragon_node *node;                      /* Noeud à traiter             */
     GArchInstruction *first;                /* Première instruction        */
     GArchInstruction *last;                 /* Dernière instruction        */
-    GBasicBlock *block;                     /* Nouveau bloc basique        */
+    GCodeBlock *block;                      /* Nouveau bloc basique        */
 
     get_dragon_knight_content(knight, &nodes, &count);
 
@@ -831,7 +835,7 @@ GBlockList *translate_dragon_knight(const dragon_knight *knight)
 
         get_dragon_node_bounding_instructions(node, &first, &last);
 
-        block = g_basic_block_new(first, last, node->bits);
+        block = g_basic_block_new(binary, first, last, node->bits);
 
         g_block_list_add_block(result, block, i);
 
diff --git a/src/analysis/disass/dragon.h b/src/analysis/disass/dragon.h
index dfef39f..584f43a 100644
--- a/src/analysis/disass/dragon.h
+++ b/src/analysis/disass/dragon.h
@@ -25,7 +25,8 @@
 #define _ANALYSIS_DISASS_DRAGON_H
 
 
-#include "block.h"
+#include "../binary.h"
+#include "../block.h"
 #include "../../arch/processor.h"
 #include "../../common/bits.h"
 
@@ -90,7 +91,7 @@ size_t get_dragon_knight_node_index(const dragon_knight *, dragon_node *);
 dragon_node *find_knight_node_for_instruction(const dragon_knight *, bool, const GArchInstruction *);
 
 /* Traduit une complexité de noeuds en liste de blocs basiques. */
-GBlockList *translate_dragon_knight(const dragon_knight *);
+GBlockList *translate_dragon_knight(const dragon_knight *, GLoadedBinary *);
 
 
 
diff --git a/src/analysis/disass/rank.c b/src/analysis/disass/rank.c
index 6e737a5..b4a8f92 100644
--- a/src/analysis/disass/rank.c
+++ b/src/analysis/disass/rank.c
@@ -24,270 +24,12 @@
 #include "rank.h"
 
 
-
-
-#if 0
-
-#include <assert.h>
-#include <sys/param.h>
-
-
-#include "../blocks/flow.h"
-#include "../blocks/virtual.h"
-
-
-
-/* Classe le contenu d'un bloc d'instructions exécutées. */
-static bool rank_flow_block(GFlowBlock *, BlockVisitOrder, const GInstrBlock *);
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc d'instructions concerné par la visite.          *
-*                order = indication quant au sens de visite.                  *
-*                list  = ensemble des blocs basiques à parcourir.             *
-*                                                                             *
-*  Description : Classe le contenu d'un bloc d'instructions exécutées.        *
-*                                                                             *
-*  Retour      : true pour continuer la visite.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool rank_flow_block(GFlowBlock *block, BlockVisitOrder order, const GInstrBlock *list)
-{
-    unsigned int next;                      /* Rang suivant obtenu         */
-    GInstrBlock *links;                     /* Blocs liés au bloc courant  */
-    GArchInstruction *last;                 /* Dernière instruction du bloc*/
-    size_t dcount;                          /* Nombre de liens de dest.    */
-    size_t i;                               /* Boucle de parcours          */
-    const instr_link_t *dest;               /* Instr. visée par une autre  */
-    const mrange_t *range;                  /* Emplacement d'une cible     */
-    GFlowBlock *target;                     /* Bloc ciblé par un lien      */
-    unsigned int rank;                      /* Rang à constituer           */
-
-    /* Si le bloc visité n'est pas basique... */
-    if (order != BVO_PENDING) return true;
-
-    next = g_flow_block_get_rank(block) + 1;
-
-    links = g_instr_block_get_links_block(G_INSTR_BLOCK(block));
-
-    g_flow_block_get_boundary(block, NULL, &last);
-
-    g_arch_instruction_lock_dest(last);
-    dcount = g_arch_instruction_count_destinations(last);
-
-    for (i = 0; i < dcount; i++)
-    {
-        dest = g_arch_instruction_get_destination(last, i);
-
-        range = g_arch_instruction_get_range(dest->linked);
-
-        switch (dest->type)
-        {
-            case ILT_EXEC_FLOW:
-            case ILT_CATCH_EXCEPTION:
-                target = G_FLOW_BLOCK(g_instr_block_find_by_addr(list, get_mrange_addr(range), true));
-                //assert(target != NULL);
-                break;
-
-            case ILT_JUMP:
-                target = G_FLOW_BLOCK(g_instr_block_find_by_addr(list, get_mrange_addr(range), true));
-
-                /**
-                 * Les sauts ne se font pas toujours à l'intérieur d'une même fonction.
-                 * Par exemple sous ARM :
-                 *
-                 *    00008358 <call_gmon_start>:
-                 *        ....
-                 *        8362:       f7ff bfcf       b.w     8304 <_init+0x38>
-                 *        ....
-                 *
-                 */
-                /* assert(target != NULL);*/
-
-                break;
-
-            case ILT_CASE_JUMP:
-                target = G_FLOW_BLOCK(g_instr_block_find_by_addr(links, get_mrange_addr(range), true));
-                //assert(target != NULL);
-                break;
-
-            case ILT_JUMP_IF_TRUE:
-            case ILT_JUMP_IF_FALSE:
-
-                /**
-                 * Même dans les branches if/then/else, il n'y a pas forcément de groupe de blocs
-                 * associé. C'est par exemple le cas dans des constructions telles que celle de
-                 * la fonction __libc_csu_init() :
-                 *
-                 *    if (...)
-                 *       do
-                 *       {
-                 *          ...
-                 *       }
-                 *       while (...)
-                 *
-                 *    ...
-                 *
-                 * Le code final est étiquetté comme étant le 'else' de la première condition,
-                 * donc au niveau de la condition de bouclage, il appartient déjà à un autre
-                 * et n'est donc pas réattribué une seconde fois.
-                 *
-                 */
-
-                if (links != NULL)
-                    target = G_FLOW_BLOCK(g_instr_block_find_by_addr(links, get_mrange_addr(range), true));
-                else
-                    target = NULL;
-
-                /**
-                 * Le bloc visé ne se trouve pas toujours dans les blocs attachés :
-                 *
-                 * { bloc IF }
-                 *    { bloc THEN }
-                 * { block NEXT }
-                 *
-                 * Le bloc NEXT est ici à rechercher dans la liste globale.
-                 */
-
-                if (target == NULL)
-                    target = G_FLOW_BLOCK(g_instr_block_find_by_addr(list, get_mrange_addr(range), true));
-
-                //assert(target != NULL);
-
-                break;
-
-            default:
-                target = NULL;
-                break;
-
-        }
-
-        unref_instr_link(dest);
-
-        if (target != NULL)
-        {
-            rank = MAX(next, g_flow_block_get_rank(target));
-
-            g_flow_block_set_rank(target, rank);
-
-        }
-
-    }
-
-    g_arch_instruction_unlock_dest(last);
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : routine = routine regroupant les blocs à traiter.            *
-*                                                                             *
-*  Description : Classe les blocs des routines.                               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void rank_routine_blocks(GBinRoutine *routine)
-{
-    GInstrBlock *main_block;                /* Ensemble des blocs d'instr. */
-
-    main_block = g_binary_routine_get_basic_blocks(routine);
-
-
-    if (main_block == NULL) return;
-
-
-    g_instr_block_visit(main_block, (instr_block_visitor_cb)rank_flow_block, main_block);
-
-
-#if 0
-
-    printf("===== BLOCK(S) xXXx ======\n");
-
-
-        bool visit_ranked_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 (rank = %u)",
-                               (unsigned int)start.virtual,
-                               (unsigned int)end.virtual,
-                               g_flow_block_get_rank(G_FLOW_BLOCK(blk)));
-
-                    }
-
-                    printf("\n");
-
-                    if (order == BVO_IN) (*indent)++;
-                    break;
-
-                case BVO_OUT:
-                    (*indent)--;
-                    break;
-
-            }
-
-            return true;
-
-        }
-
-        g_instr_block_visit(main_block, (instr_block_visitor_cb)visit_ranked_block, (int []){ 0 });
-
-        printf("\n");
-
-
-#endif
-
-
-
-
-}
-
-
-
-#endif
-
-
-
-
-
-
-
 #include <assert.h>
 
 
 
 /* Classe les blocs basiques d'une routine. */
-void rank_routine_block(const GBlockList *, GBasicBlock *);
-
+void rank_routine_block(const GBlockList *, GCodeBlock *);
 
 
 
@@ -304,27 +46,23 @@ void rank_routine_block(const GBlockList *, GBasicBlock *);
 *                                                                             *
 ******************************************************************************/
 
-void rank_routine_block(const GBlockList *list, GBasicBlock *block)
+void rank_routine_block(const GBlockList *list, GCodeBlock *block)
 {
-    unsigned int next;                      /* Rang suivant obtenu         */
-    GArchInstruction *last;                 /* Dernière instruction du bloc*/
+    size_t next;                            /* Rang suivant obtenu         */
     size_t dcount;                          /* Nombre de liens de dest.    */
     size_t i;                               /* Boucle de parcours          */
-    const instr_link_t *dest;               /* Instr. visée par une autre  */
+    const block_link_t *dest;               /* Instr. visée par une autre  */
     InstructionLinkType type;               /* Raccourci pour confort      */
-    GBasicBlock *target;                    /* Bloc ciblé par un lien      */
     unsigned int rank;                      /* Rang à constituer           */
 
-    next = g_basic_block_get_rank(block) + 1;
-
-    g_basic_block_get_boundary(block, NULL, &last);
+    next = g_code_block_get_rank(block) + 1;
 
-    g_arch_instruction_lock_dest(last);
-    dcount = g_arch_instruction_count_destinations(last);
+    g_code_block_lock_dest(block);
+    dcount = g_code_block_count_destinations(block);
 
     for (i = 0; i < dcount; i++)
     {
-        dest = g_arch_instruction_get_destination(last, i);
+        dest = g_code_block_get_destination(block, i);
 
         type = dest->type;
 
@@ -343,30 +81,13 @@ void rank_routine_block(const GBlockList *list, GBasicBlock *block)
             && type != ILT_JUMP_IF_FALSE)
             goto next_dest;
 
-        target = g_block_list_find_by_starting_instr(list, dest->linked);
+        rank = g_code_block_get_rank(dest->linked);
 
-        /**
-         * Les sauts ne se font pas toujours à l'intérieur d'une même fonction.
-         * Par exemple sous ARM :
-         *
-         *    00008358 <call_gmon_start>:
-         *        ....
-         *        8362:       f7ff bfcf       b.w     8304 <_init+0x38>
-         *        ....
-         *
-         */
-
-        if (target != NULL)
+        if (next > rank || rank == -1)
         {
-            rank = g_basic_block_get_rank(target);
-
-            if (next > rank || rank == -1)
-            {
-                g_basic_block_set_rank(target, next);
+            g_code_block_set_rank(dest->linked, next);
 
-                rank_routine_block(list, target);
-
-            }
+            rank_routine_block(list, dest->linked);
 
         }
 
@@ -376,7 +97,7 @@ void rank_routine_block(const GBlockList *list, GBasicBlock *block)
 
     }
 
-    g_arch_instruction_unlock_dest(last);
+    g_code_block_unlock_dest(block);
 
 }
 
@@ -396,22 +117,17 @@ void rank_routine_block(const GBlockList *list, GBasicBlock *block)
 void rank_routine_blocks(GBinRoutine *routine)
 {
     GBlockList *blocks;                     /* Ensemble des blocs d'instr. */
-    GBasicBlock *start;                     /* Bloc basique de départ      */
+    GCodeBlock *start;                      /* Bloc basique de départ      */
 
     blocks = g_binary_routine_get_basic_blocks(routine);
 
-    start = g_block_list_get_block(blocks, 0 /* FIXME */);
+    start = g_block_list_get_block(blocks, 0);
     assert(start != NULL);
 
-
-    g_basic_block_set_rank(start, 0);
-
+    g_code_block_set_rank(start, 0);
 
     rank_routine_block(blocks, start);
 
-
-
-
-
+    g_object_unref(G_OBJECT(start));
 
 }
diff --git a/src/analysis/disass/routines.c b/src/analysis/disass/routines.c
index f04611f..4e65b77 100644
--- a/src/analysis/disass/routines.c
+++ b/src/analysis/disass/routines.c
@@ -41,6 +41,8 @@ struct _GRoutinesStudy
 {
     GDelayedWork parent;                    /* A laisser en premier        */
 
+    GLoadedBinary *binary;                  /* Binaire en cours d'analyse  */
+
     GArchProcessor *proc;                   /* Processeur avec ses instr.  */
     GBinFormat *format;                     /* Format de fichier manipulé  */
     GBinPortion *portions;                  /* Couches de binaire bornées  */
@@ -155,6 +157,8 @@ static void g_routines_study_dispose(GRoutinesStudy *study)
     g_object_unref(G_OBJECT(study->format));
     g_object_unref(G_OBJECT(study->proc));
 
+    g_object_unref(G_OBJECT(study->binary));
+
     G_OBJECT_CLASS(g_routines_study_parent_class)->dispose(G_OBJECT(study));
 
 }
@@ -181,8 +185,7 @@ static void g_routines_study_finalize(GRoutinesStudy *study)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : proc     = ensemble d'instructions désassemblées.            *
-*                format   = format de fichier à manipuler.                    *
+*  Paramètres  : binary   = binaire chargé comprenant les routines à traiter. *
 *                portions = ensemble de couches binaires bornées.             *
 *                begin    = point de départ du parcours de liste.             *
 *                end      = point d'arrivée exclu du parcours.                *
@@ -197,24 +200,24 @@ static void g_routines_study_finalize(GRoutinesStudy *study)
 *                                                                             *
 ******************************************************************************/
 
-GRoutinesStudy *g_routines_study_new(GArchProcessor *proc, GBinFormat *format, GBinPortion *portions, size_t begin, size_t end, activity_id_t id, rtn_fallback_cb fallback)
+GRoutinesStudy *g_routines_study_new(GLoadedBinary *binary, GBinPortion *portions, size_t begin, size_t end, activity_id_t id, rtn_fallback_cb fallback)
 {
     GRoutinesStudy *result;                /* Tâche à retourner           */
 
     result = g_object_new(G_TYPE_ROUTINES_STUDY, NULL);
 
-    result->proc = proc;
-    g_object_ref(G_OBJECT(proc));
+    result->binary = binary;
+    g_object_ref(G_OBJECT(binary));
 
-    result->format = format;
-    g_object_ref(G_OBJECT(format));
+    result->proc = g_loaded_binary_get_processor(binary);
+    result->format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
 
     result->portions = portions;
     g_object_ref(G_OBJECT(portions));
 
-    g_binary_format_lock_symbols_rd(format);
+    g_binary_format_lock_symbols_rd(result->format);
 
-    result->count = g_binary_format_count_symbols(format);
+    result->count = g_binary_format_count_symbols(result->format);
 
     result->fallback = fallback;
     result->begin = begin;
@@ -397,7 +400,7 @@ void g_routines_study_handle_blocks(GRoutinesStudy *study, GBinRoutine *routine,
 
     detect_loops_in_code(knight);
 
-    blocks = translate_dragon_knight(knight);
+    blocks = translate_dragon_knight(knight, study->binary);
 
     g_binary_routine_set_basic_blocks(routine, blocks);
 
diff --git a/src/analysis/disass/routines.h b/src/analysis/disass/routines.h
index d6fd76b..ce44fec 100644
--- a/src/analysis/disass/routines.h
+++ b/src/analysis/disass/routines.h
@@ -25,10 +25,8 @@
 #define _ANALYSIS_DISASS_ROUTINES_H
 
 
+#include "../binary.h"
 #include "../routine.h"
-#include "../../arch/processor.h"
-#include "../../format/executable.h"
-#include "../../format/format.h"
 #include "../../gtkext/gtkstatusstack.h"
 
 
@@ -53,7 +51,7 @@ typedef void (* rtn_fallback_cb) (GRoutinesStudy *, GBinRoutine *, size_t);
 
 
 /* Crée une tâche d'étude de routines différée. */
-GRoutinesStudy *g_routines_study_new(GArchProcessor *, GBinFormat *, GBinPortion *, size_t, size_t, activity_id_t, rtn_fallback_cb);
+GRoutinesStudy *g_routines_study_new(GLoadedBinary *, GBinPortion *, size_t, size_t, activity_id_t, rtn_fallback_cb);
 
 /* Détermine si besoin est les bornes des routines. */
 void g_routines_study_compute_limits(GRoutinesStudy *, GBinRoutine *, size_t);