Restored some parts of the decompilation process using the new basic blocks.

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

11 files changed, 500 insertions, 9 deletions

diff --git a/src/analysis/block-int.h b/src/analysis/block-int.h
index ba84fcb..355c1ee 100644
--- a/src/analysis/block-int.h
+++ b/src/analysis/block-int.h
@@ -29,6 +29,9 @@
 
 
 
+/* Recherche le bloc contenant une adresse donnée. */
+typedef GInstrBlock * (* find_by_addr_fc) (const GInstrBlock *, vmpa_t);
+
 /* Parcours tous les blocs d'instructions dans un ordre donné. */
 typedef bool (* visit_all_blocks_fc) (GInstrBlock *, instr_block_visitor_cb, void *);
 
@@ -45,6 +48,7 @@ struct _GInstrBlock
 {
     GObject parent;                         /* A laisser en premier        */
 
+    find_by_addr_fc find_by_addr;           /* Recherche par adresse       */
     visit_all_blocks_fc visit_blocks;       /* Visite des différents blocs */
     list_all_blocks_fc list_blocks;         /* Liste de tous les blocs     */
     list_regs_accesses_fc list_regs;        /* Liste des accès registres   */
diff --git a/src/analysis/block.c b/src/analysis/block.c
index 3b3eaf3..62b56ab 100644
--- a/src/analysis/block.c
+++ b/src/analysis/block.c
@@ -157,6 +157,26 @@ static void g_instr_block_finalize(GInstrBlock *block)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : block = bloc de départ des recherches.                       *
+*                addr  = ensemble de blocs à parcourir.                       *
+*                                                                             *
+*  Description : Recherche le bloc contenant une adresse donnée.              *
+*                                                                             *
+*  Retour      : bloc basique trouvé ou NULL en cas d'échec.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GInstrBlock *g_instr_block_find_by_addr(const GInstrBlock *block, vmpa_t addr)
+{
+    return block->find_by_addr(block, addr);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : block    = bloc d'instructions démarrant la visite.          *
 *                callback = ensemble de blocs à parcourir.                    *
 *                data     = donnée utilisateur à associer au parcours.        *
diff --git a/src/analysis/block.h b/src/analysis/block.h
index a85e4aa..1574dc1 100644
--- a/src/analysis/block.h
+++ b/src/analysis/block.h
@@ -95,6 +95,9 @@ typedef bool (* instr_block_visitor_cb) (GInstrBlock *, BlockVisitOrder, void *)
 /* Indique le type défini pour un bloc d'instructions. */
 GType g_instr_block_get_type(void);
 
+/* Recherche le bloc contenant une adresse donnée. */
+GInstrBlock *g_instr_block_find_by_addr(const GInstrBlock *, vmpa_t);
+
 /* Parcours tous les blocs d'instructions dans un ordre donné. */
 bool g_instr_block_visit(GInstrBlock *, instr_block_visitor_cb, void *);
 
diff --git a/src/analysis/blocks/flow.c b/src/analysis/blocks/flow.c
index 85d98ee..6fb5849 100644
--- a/src/analysis/blocks/flow.c
+++ b/src/analysis/blocks/flow.c
@@ -65,6 +65,9 @@ static void g_flow_block_dispose(GFlowBlock *);
 /* Procède à la libération totale de la mémoire. */
 static void g_flow_block_finalize(GFlowBlock *);
 
+/* Recherche le bloc contenant une adresse donnée. */
+static GInstrBlock *g_flow_block_find_by_addr(const GFlowBlock *, vmpa_t);
+
 /* Parcours le bloc d'instructions dans un ordre donné. */
 static bool g_flow_block_visit(GFlowBlock *, instr_block_visitor_cb, void *);
 
@@ -128,6 +131,7 @@ static void g_flow_block_init(GFlowBlock *block)
 
     parent = G_INSTR_BLOCK(block);
 
+    parent->find_by_addr = (find_by_addr_fc)g_flow_block_find_by_addr;
     parent->visit_blocks = (visit_all_blocks_fc)g_flow_block_visit;
     parent->list_blocks = (list_all_blocks_fc)g_flow_block_list_all_blocks;
     parent->list_regs = (list_regs_accesses_fc)g_flow_block_list_regs_accesses;
@@ -236,6 +240,38 @@ GInstrBlock *g_flow_block_new(GArchInstruction *instrs, GArchInstruction *first,
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : block = bloc de départ des recherches.                       *
+*                addr  = ensemble de blocs à parcourir.                       *
+*                                                                             *
+*  Description : Recherche le bloc contenant une adresse donnée.              *
+*                                                                             *
+*  Retour      : bloc basique trouvé ou NULL en cas d'échec.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GInstrBlock *g_flow_block_find_by_addr(const GFlowBlock *block, vmpa_t addr)
+{
+    GInstrBlock *result;                    /* Resultat à retourner        */
+    vmpa_t start;                           /* Adresse de début du bloc    */
+    vmpa_t end;                             /* Adresse de fin du bloc      */
+
+    g_flow_block_get_boundary_addresses(block, &start, &end);
+
+    if (start <= addr && addr <= end)
+        result = G_INSTR_BLOCK(block);
+
+    else
+        result = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : block    = bloc d'instructions concerné par la visite.       *
 *                callback = ensemble de blocs à parcourir.                    *
 *                data     = donnée utilisateur à associer au parcours.        *
@@ -419,6 +455,25 @@ static const reg_access *g_flow_block_list_regs_accesses(const GFlowBlock *block
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : block = bloc d'instructions à consulter.                     *
+*                                                                             *
+*  Description : Fournit la liste d'appartenance des instructions du bloc.    *
+*                                                                             *
+*  Retour      : Liste de l'ensemble des instructions.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *g_flow_block_get_all_instructions_list(const GFlowBlock *block)
+{
+    return block->instrs;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instructions à consulter.                     *
 *                first = instruction de départ du bloc. [OUT]                 *
 *                last  = dernière instruction du bloc. [OUT]                  *
 *                                                                             *
@@ -432,8 +487,11 @@ static const reg_access *g_flow_block_list_regs_accesses(const GFlowBlock *block
 
 void g_flow_block_get_boundary(const GFlowBlock *block, GArchInstruction **first, GArchInstruction **last)
 {
-    *first = block->first;
-    *last = block->last;
+    if (first != NULL)
+        *first = block->first;
+
+    if (last != NULL)
+        *last = block->last;
 
 }
 
diff --git a/src/analysis/blocks/flow.h b/src/analysis/blocks/flow.h
index 8bd7257..28fb5a9 100644
--- a/src/analysis/blocks/flow.h
+++ b/src/analysis/blocks/flow.h
@@ -55,6 +55,9 @@ GType g_flow_block_get_type(void);
 /* Crée un bloc d'exécution d'instructions. */
 GInstrBlock *g_flow_block_new(GArchInstruction *, GArchInstruction *, GArchInstruction *);
 
+/* Fournit la liste d'appartenance des instructions du bloc. */
+GArchInstruction *g_flow_block_get_all_instructions_list(const GFlowBlock *);
+
 /* Fournit les instructions limites d'un bloc d'exécution. */
 void g_flow_block_get_boundary(const GFlowBlock *, GArchInstruction **, GArchInstruction **);
 
diff --git a/src/analysis/blocks/virtual.c b/src/analysis/blocks/virtual.c
index 90bccca..71a6d06 100644
--- a/src/analysis/blocks/virtual.c
+++ b/src/analysis/blocks/virtual.c
@@ -69,6 +69,9 @@ static void g_virtual_block_dispose(GVirtualBlock *);
 /* Procède à la libération totale de la mémoire. */
 static void g_virtual_block_finalize(GVirtualBlock *);
 
+/* Recherche le bloc contenant une adresse donnée. */
+static GInstrBlock *g_virtual_block_find_by_addr(const GVirtualBlock *, vmpa_t);
+
 /* Parcours le bloc d'instructions dans un ordre donné. */
 static bool g_virtual_block_visit(GVirtualBlock *, instr_block_visitor_cb, void *);
 
@@ -126,6 +129,7 @@ static void g_virtual_block_init(GVirtualBlock *block)
 
     parent = G_INSTR_BLOCK(block);
 
+    parent->find_by_addr = (find_by_addr_fc)g_virtual_block_find_by_addr;
     parent->visit_blocks = (visit_all_blocks_fc)g_virtual_block_visit;
     parent->list_blocks = (list_all_blocks_fc)g_virtual_block_list_all_blocks;
     parent->list_regs = (list_regs_accesses_fc)g_virtual_block_list_regs_accesses;
@@ -207,6 +211,34 @@ GInstrBlock *g_virtual_block_new(void)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : block = bloc de départ des recherches.                       *
+*                addr  = ensemble de blocs à parcourir.                       *
+*                                                                             *
+*  Description : Recherche le bloc contenant une adresse donnée.              *
+*                                                                             *
+*  Retour      : bloc basique trouvé ou NULL en cas d'échec.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GInstrBlock *g_virtual_block_find_by_addr(const GVirtualBlock *block, vmpa_t addr)
+{
+    GInstrBlock *result;                    /* Resultat à retourner        */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = NULL;
+
+    for (i = 0; i < block->children_count && result == NULL; i++)
+        result = g_instr_block_find_by_addr(block->children[i], addr);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : block    = bloc d'instructions concerné par la visite.       *
 *                callback = ensemble de blocs à parcourir.                    *
 *                data     = donnée utilisateur à associer au parcours.        *
@@ -324,3 +356,27 @@ size_t g_virtual_block_count_children(GVirtualBlock *block)
     return block->children_count;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = bloc d'instructions à consulter.                     *
+*                index = indice du sous-bloc recherché.                       *
+*                                                                             *
+*  Description : Renvoie un des blocs contenus dans le groupe courant.        *
+*                                                                             *
+*  Retour      : Un des blocs du groupe.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GInstrBlock *g_virtual_block_get_child(GVirtualBlock *block, size_t index)
+{
+    if (index >= block->children_count)
+        return NULL;
+
+    else
+        return block->children[index];
+
+}
diff --git a/src/analysis/blocks/virtual.h b/src/analysis/blocks/virtual.h
index 5e8ddcd..b254a27 100644
--- a/src/analysis/blocks/virtual.h
+++ b/src/analysis/blocks/virtual.h
@@ -61,6 +61,9 @@ void g_virtual_block_add_child(GVirtualBlock *, GInstrBlock *);
 /* Compte le nombre de blocs contenus dans le groupe courant. */
 size_t g_virtual_block_count_children(GVirtualBlock *);
 
+/* Renvoie un des blocs contenus dans le groupe courant. */
+GInstrBlock *g_virtual_block_get_child(GVirtualBlock *, size_t);
+
 
 
 #endif  /* _ANALYSIS_BLOCKS_VIRTUAL_H */
diff --git a/src/analysis/decomp/decompiler.c b/src/analysis/decomp/decompiler.c
index c824697..47c379d 100644
--- a/src/analysis/decomp/decompiler.c
+++ b/src/analysis/decomp/decompiler.c
@@ -167,11 +167,16 @@ static void prepare_all_routines_for_decomp(const GLoadedBinary *binary, const c
         max = g_binary_routine_get_address(routines[i])
             + g_binary_routine_get_size(routines[i]);
 
-        //printf("##### DECOMPILE '%s' #####\n", g_binary_routine_to_string(routines[i]));
+        printf("##### DECOMPILE '%s' #####\n", g_binary_routine_to_string(routines[i]));
 
+
+        dinstrs = decompiled_routine_instructions(routines[i], format, proc);
+
+        /*
         dinstrs = build_decompiled_block(instrs,
                                          g_binary_routine_get_address(routines[i]),
                                          max, VMPA_MAX, context);
+        */
 
         //instr = g_binary_format_decompile_routine(G_BIN_FORMAT(format), routines[i], context);
 
@@ -216,8 +221,6 @@ GCodeBuffer *decompile_all_from_file(const GLoadedBinary *binary, const char *fi
 
     build_decomp_prologue(result, filename);
 
-
-    /*
     prepare_all_routines_for_decomp(binary, filename);
 
 
@@ -225,7 +228,7 @@ GCodeBuffer *decompile_all_from_file(const GLoadedBinary *binary, const char *fi
 
     format = g_loaded_binary_get_format(binary);
     g_binary_format_decompile(G_BIN_FORMAT(format), result, filename);
-    */
+
 
     return result;
 
diff --git a/src/analysis/decomp/il.c b/src/analysis/decomp/il.c
index 693b8cb..c2bc0be 100644
--- a/src/analysis/decomp/il.c
+++ b/src/analysis/decomp/il.c
@@ -24,6 +24,330 @@
 #include "il.h"
 
 
+#include "../blocks/flow.h"
+#include "../blocks/virtual.h"
+#include "../../decomp/expr/block.h"
+#include "../../decomp/instr/ite.h"
+
+
+
+/* --------------------- GESTION DES CONTEXTES DE DECOMPILATION --------------------- */
+
+
+
+
+
+
+
+/* -------------------------- ENCADREMENT DES INSTRUCTIONS -------------------------- */
+
+
+/* Retrouve et rassemble les instructions décompilées. */
+static GDecInstruction *merge_decompiled_instructions(GDecInstruction *, GDecInstruction *);
+
+/* Procède à la décompilation d'un bloc déterminé. */
+static GDecInstruction *decompiled_instructions_block(GFlowBlock *, GVirtualBlock *, GDecContext *);
+
+/* Procède à la décompilation d'un ensemble de blocs déterminé. */
+static GDecInstruction *decompiled_instructions_blocks(GVirtualBlock *, GDecContext *);
+
+/* Procède à la décompilation d'un bloc basique quelconque. */
+static GDecInstruction *decompiled_basic_block(GInstrBlock *, GDecContext *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       GESTION DES CONTEXTES DE DECOMPILATION                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+
+
+
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            ENCADREMENT DES INSTRUCTIONS                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : group = groupe d'instructions à compléter ou constituer.     *
+*                list  = liste d'instructions à intégrer.                     *
+*                                                                             *
+*  Description : Retrouve et rassemble les instructions décompilées.          *
+*                                                                             *
+*  Retour      : Groupe fourni ou nouveau groupe créé pour l'occasion.        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GDecInstruction *merge_decompiled_instructions(GDecInstruction *group, GDecInstruction *list)
+{
+    GExprBlock *block;                      /* Autre vision du groupe      */
+    GDecInstruction *iter;                  /* Boucle de parcours          */
+
+    if (group == NULL) block = NULL;
+    else block = G_EXPR_BLOCK(group);
+
+    for (iter = list;
+         iter != NULL;
+         iter = g_dec_instruction_get_next_iter(list, iter))
+    {
+        if (block == NULL)
+            block = G_EXPR_BLOCK(g_expr_block_new(iter));
+        else
+            g_expr_block_add_item(block, iter);
+
+    }
+
+    return G_DEC_INSTRUCTION(block);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block  = ensemble des instructions d'assemblage à traiter.   *
+*                parent = groupe de blocs d'appartenance.                     *
+*                ctx    = contexte de soutien à associer à l'opération.       *
+*                                                                             *
+*  Description : Procède à la décompilation d'un bloc déterminé.              *
+*                                                                             *
+*  Retour      : Instructions créées et enregistrées, ou NULL si erreur.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GDecInstruction *decompiled_instructions_block(GFlowBlock *block, GVirtualBlock *parent, GDecContext *ctx)
+{
+    GDecInstruction *res;
+
+    GArchInstruction *instrs;               /* Liste d'instructions natives*/
+    GArchInstruction *first;                /* Première instruction du lot */
+    GArchInstruction *last;                 /* Dernière instruction du lot */
+    vmpa_t max;                             /* Adresse de fin du bloc      */
+    GArchInstruction *iter;                 /* Boucle de parcours          */
+    GDecInstruction *decomp;                /* Dernier résultat de décomp. */
+    GDecInstruction *true_dinstr;           /* Décompilation 'cond vraie'  */
+    GDecInstruction *false_dinstr;          /* Décompilation 'cond fausse' */
+    GArchInstruction *next;                 /* Instruction de branchement  */
+    vmpa_t next_addr;                       /* Adresse de cette instruct°  */
+    GInstrBlock *next_block;                /* Bloc basique correspondant  */
+
+    instrs = g_flow_block_get_all_instructions_list(block);
+    g_flow_block_get_boundary(block, &first, &last);
+
+    g_flow_block_get_boundary_addresses(block, NULL, &max);
+    max++;
+
+    /* Décompilation du corps du bloc */
+
+    for (iter = first;
+         iter != NULL;
+         iter = g_arch_instruction_get_next_iter(instrs, iter, max))
+    {
+        decomp = g_arch_instruction_decompile(iter, ctx);
+    }
+
+    /* Post-traitement selon les types de lien */
+
+
+    res = g_dec_context_get_decomp_instrs(ctx);
+
+
+    /* if ... then ... else ... */
+    if (G_IS_ITE_INSTRUCTION(decomp))
+    {
+        next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_TRUE);
+
+        printf("@ 0x%08llx : true : %p\n", max, next);
+
+        true_dinstr = NULL;
+
+        if (next != NULL)
+        {
+            g_arch_instruction_get_location(next, NULL, NULL, &next_addr);
+            next_block = g_instr_block_find_by_addr(G_INSTR_BLOCK(parent), next_addr);
+
+            if (next_block != NULL)
+            {
+                next_block = g_instr_block_find_by_addr(next_block, next_addr);
+                true_dinstr = decompiled_basic_block(next_block, ctx);
+            }
+
+        }
+
+        next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_FALSE);
+
+        printf("@ 0x%08llx : false : %p\n", max, next);
+
+        false_dinstr = NULL;
+
+        if (next != NULL)
+        {
+            g_arch_instruction_get_location(next, NULL, NULL, &next_addr);
+            next_block = g_instr_block_find_by_addr(G_INSTR_BLOCK(parent), next_addr);
+
+            if (next_block != NULL)
+            {
+                next_block = g_instr_block_find_by_addr(next_block, next_addr);
+                false_dinstr = decompiled_basic_block(next_block, ctx);
+            }
+
+        }
+
+        printf(" -> ite : %p + %p\n", true_dinstr, false_dinstr);
+
+        printf(" -> ite : %s + %s\n",
+               g_type_name(G_TYPE_FROM_INSTANCE(true_dinstr)),
+               g_type_name(G_TYPE_FROM_INSTANCE(false_dinstr)));
+
+
+        g_ite_instruction_set_branches(G_ITE_INSTRUCTION(decomp), true_dinstr, false_dinstr);
+
+    }
+
+    /* Renvoi des instructions mises en place */
+
+    return res;
+
+    //return g_dec_context_get_decomp_instrs(ctx);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = ensemble des instructions d'assemblage à traiter.    *
+*                ctx   = contexte de soutien à associer à l'opération.        *
+*                                                                             *
+*  Description : Procède à la décompilation d'un ensemble de blocs déterminé. *
+*                                                                             *
+*  Retour      : Instructions créées et enregistrées, ou NULL si erreur.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GDecInstruction *decompiled_instructions_blocks(GVirtualBlock *block, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instructions à renvoyer     */
+    size_t count;                           /* Nombre de sous-blocs        */
+    size_t i;                               /* Boucle de parcours          */
+    GInstrBlock *sub_block;                 /* Sous-bloc à traiter         */
+    GDecInstruction *dinstrs;               /* Instructions décompilées    */
+
+    result = NULL;
+
+    count = g_virtual_block_count_children(block);
+
+    for (i = 0; i < count; i++)
+    {
+        sub_block = g_virtual_block_get_child(block, i);
+
+        /**
+         * Les groupes de blocs sont forcément rattachés à une instruction,
+         * donc ils sont décompilés depuis ces instructions, pas ici.
+         */
+        if (!G_IS_FLOW_BLOCK(sub_block)) continue;
+
+        /* FIXME */
+        g_dec_context_set_decomp_instrs(ctx, NULL);
+
+        dinstrs = decompiled_instructions_block(G_FLOW_BLOCK(sub_block), block, ctx);
+        result = merge_decompiled_instructions(result, dinstrs);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : block = ensemble des instructions d'assemblage à traiter.    *
+*                ctx   = contexte de soutien à associer à l'opération.        *
+*                                                                             *
+*  Description : Procède à la décompilation d'un bloc basique quelconque.     *
+*                                                                             *
+*  Retour      : Instructions créées et enregistrées, ou NULL si erreur.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GDecInstruction *decompiled_basic_block(GInstrBlock *block, GDecContext *ctx)
+{
+    GDecInstruction *result;                /* Instructions à retourner    */
+
+    /* FIXME */
+    g_dec_context_set_decomp_instrs(ctx, NULL);
+
+    if (G_IS_VIRTUAL_BLOCK(block))
+        result = decompiled_instructions_blocks(G_VIRTUAL_BLOCK(block), ctx);
+
+    else
+    {
+        result = decompiled_instructions_block(G_FLOW_BLOCK(block), NULL, ctx);
+
+        if (!G_IS_EXPR_BLOCK(result))
+            result = merge_decompiled_instructions(NULL, result);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : routine = routine dont le corps est à traiter.               *
+*                format  = format du binaire contenant les instructions.      *
+*                proc    = architecture du code machine.                      *
+*                                                                             *
+*  Description : Procède à la décompilation d'une routinée déterminée.        *
+*                                                                             *
+*  Retour      : Instructions créées ou NULL si erreur.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDecInstruction *decompiled_routine_instructions(GBinRoutine *routine, GExeFormat *format, GArchProcessor *proc)
+{
+    GDecInstruction *result;                /* Instructions à retourner    */
+    GDecContext *context;                   /* Contexte pour la décompil.  */
+    GInstrBlock *blocks;                    /* Blocs basiques de routine   */
+
+    context = g_arch_processor_get_decomp_context(proc);
+
+    g_object_set_data(G_OBJECT(context), "format", format);
+    g_object_set_data(G_OBJECT(context), "routine", routine);
+
+    blocks = g_binary_routine_get_basic_blocks(routine);
+
+    result = decompiled_basic_block(blocks, context);
+
+    g_object_unref(context);
+
+    return result;
+
+}
+
+
+
+
+
+#if 0
+
+
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
@@ -380,3 +704,5 @@ GDecInstruction *build_decompiled_block(GArchInstruction *instrs, vmpa_t start,
     return result;
 
 }
+
+#endif
diff --git a/src/analysis/decomp/il.h b/src/analysis/decomp/il.h
index 4f38b4f..670505c 100644
--- a/src/analysis/decomp/il.h
+++ b/src/analysis/decomp/il.h
@@ -25,6 +25,18 @@
 #define _ANALYSIS_DECOMP_IL_H
 
 
+#include "../routine.h"
+#include "../../arch/processor.h"
+
+
+
+/* Procède à la décompilation d'une routinée déterminée. */
+GDecInstruction *decompiled_routine_instructions(GBinRoutine *, GExeFormat *, GArchProcessor *);
+
+
+
+
+#if 0
 #include "../../arch/instruction.h"
 #include "../../decomp/instruction.h"
 
@@ -32,7 +44,7 @@
 
 /* Procède à la décompilation basique d'un bloc déterminé. */
 GDecInstruction *build_decompiled_block(GArchInstruction *, vmpa_t, vmpa_t, vmpa_t, GDecContext *);
-
+#endif
 
 
 #endif  /* _ANALYSIS_DECOMP_IL_H */
diff --git a/src/analysis/variable.c b/src/analysis/variable.c
index 6a7c145..edc176a 100644
--- a/src/analysis/variable.c
+++ b/src/analysis/variable.c
@@ -253,11 +253,14 @@ char *g_binary_variable_to_string(const GBinVariable *var, bool simple)
 {
     char *result;                           /* Valeur à retourner          */
 
-    result = _g_data_type_to_string(var->type, simple);
+    /* FIXME : décompilation sans type ! */
+    //result = _g_data_type_to_string(var->type, simple);
+
+    result = strdup("");
 
     if (var->name != NULL)
     {
-        if (!g_data_type_is_pointer(var->type, true))
+        if (!g_data_type_is_pointer(var->type, true) /* FIXME */ && strlen(result) > 0 /* FIXME */)
             result = stradd(result, " ");
 
         result = stradd(result, var->name);