Defined the first steps for a new disassembling approach.

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

15 files changed, 490 insertions, 102 deletions

diff --git a/src/arch/arm/v456/instruction.c b/src/arch/arm/v456/instruction.c
index 3ba3c54..b5df0f8 100644
--- a/src/arch/arm/v456/instruction.c
+++ b/src/arch/arm/v456/instruction.c
@@ -180,7 +180,7 @@ static void g_armv456_instruction_init(GArmV456Instruction *instr)
 
     parent = G_ARCH_INSTRUCTION(instr);
 
-    parent->get_text = (get_instruction_text_fc)g_armv456_get_instruction_text;
+    //parent->get_text = (get_instruction_text_fc)g_armv456_get_instruction_text;
 
     /*
     parent->get_rw_regs = (get_instruction_rw_regs_fc)g_armv456_instruction_get_rw_registers;
diff --git a/src/arch/artificial.c b/src/arch/artificial.c
index 6fbd6d9..4131e5f 100644
--- a/src/arch/artificial.c
+++ b/src/arch/artificial.c
@@ -57,8 +57,14 @@ static void g_db_instruction_class_init(GDbInstructionClass *);
 /* Initialise une instance d'opérande d'architecture. */
 static void g_db_instruction_init(GDbInstruction *);
 
-/* Traduit une instruction en version humainement lisible. */
-static const char *g_db_instruction_get_text(const GDbInstruction *, const GExeFormat *, AsmSyntax);
+/* Supprime toutes les références externes. */
+static void g_db_instruction_dispose(GDbInstruction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_db_instruction_finalize(GDbInstruction *);
+
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *g_db_instruction_get_keyword(const GDbInstruction *, AsmSyntax);
 
 /* Informe sur une éventuelle référence à une autre instruction. */
 static InstructionLinkType g_db_instruction_get_link(const GDbInstruction *, vmpa_t *);
@@ -91,6 +97,17 @@ G_DEFINE_TYPE(GDbInstruction, g_db_instruction, G_TYPE_ARCH_INSTRUCTION);
 
 static void g_db_instruction_class_init(GDbInstructionClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_db_instruction_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_db_instruction_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->get_key = (get_instruction_keyword_fc)g_db_instruction_get_keyword;
 
 }
 
@@ -113,7 +130,6 @@ static void g_db_instruction_init(GDbInstruction *instr)
 
     parent = G_ARCH_INSTRUCTION(instr);
 
-    parent->get_text = (get_instruction_text_fc)g_db_instruction_get_text;
     parent->get_link = (get_instruction_link_fc)g_db_instruction_get_link;
     parent->is_return = (is_instruction_return_fc)g_db_instruction_is_return;
 
@@ -122,6 +138,44 @@ static void g_db_instruction_init(GDbInstruction *instr)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_db_instruction_dispose(GDbInstruction *instr)
+{
+    G_OBJECT_CLASS(g_db_instruction_parent_class)->dispose(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_db_instruction_finalize(GDbInstruction *instr)
+{
+    G_OBJECT_CLASS(g_db_instruction_parent_class)->finalize(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : data = flux de données à analyser.                           *
 *                pos  = position courante dans ce flux. [OUT]                 *
 *                end  = limite des données à analyser.                        *
@@ -136,16 +190,26 @@ static void g_db_instruction_init(GDbInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos, off_t end, vmpa_t addr, const GArchProcessor *proc)
+GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, vmpa2t *address, off_t end, const GArchProcessor *proc)
 {
     GArchInstruction *result;               /* Instruction à retourner     */
+    off_t pos;
+    off_t old;
     GArchOperand *operand;                  /* Octet non décodé à afficher */
 
     result = g_object_new(G_TYPE_DB_INSTRUCTION, NULL);
 
+    pos = get_phy_addr(address);
+    old = pos;
+
     operand = g_imm_operand_new_from_data(g_arch_processor_get_instruction_size(proc),
-                                          data, pos, end,
+                                          data, &pos, end,
                                           g_arch_processor_get_endianness(proc));
+
+    address->physical += (pos - old);
+
+    /* FIXME : essayer une taille plus petite en cas d'échec (on peut être en bout de binaire) */
+
     if (operand == NULL) goto gdinfd_error;
 
     g_imm_operand_pad(G_IMM_OPERAND(operand), true);
@@ -169,15 +233,15 @@ GArchInstruction *g_db_instruction_new_from_data(const bin_t *data, off_t *pos,
 *                format = format du binaire manipulé.                         *
 *                syntax = type de représentation demandée.                    *
 *                                                                             *
-*  Description : Traduit une instruction en version humainement lisible.      *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
-*  Retour      : Chaîne de caractères à libérer de la mémoire.                *
+*  Retour      : Mot clef de bas niveau.                                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static const char *g_db_instruction_get_text(const GDbInstruction *instr, const GExeFormat *format, AsmSyntax syntax)
+static const char *g_db_instruction_get_keyword(const GDbInstruction *instr, AsmSyntax syntax)
 {
     return "db";
 
diff --git a/src/arch/artificial.h b/src/arch/artificial.h
index b341644..65eb4fe 100644
--- a/src/arch/artificial.h
+++ b/src/arch/artificial.h
@@ -30,6 +30,7 @@
 
 #include "archbase.h"
 #include "processor.h"
+#include "vmpa.h"
 
 
 
@@ -53,7 +54,7 @@ typedef struct _GDbInstructionClass GDbInstructionClass;
 GType g_db_instruction_get_type(void);
 
 /* Crée une instruction de type 'db' à partir de données. */
-GArchInstruction *g_db_instruction_new_from_data(const bin_t *, off_t *, off_t, vmpa_t, const GArchProcessor *);
+GArchInstruction *g_db_instruction_new_from_data(const bin_t *, vmpa2t *, off_t, const GArchProcessor *);
 
 #ifdef DEBUG
 
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index 83e0e6c..c0c6675 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -39,6 +39,12 @@ static void g_dalvik_instruction_class_init(GDalvikInstructionClass *);
 /* Initialise une instance d'opérande d'architecture Dalvik. */
 static void g_dalvik_instruction_init(GDalvikInstruction *);
 
+/* Supprime toutes les références externes. */
+static void g_dalvik_instruction_dispose(GDalvikInstruction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dalvik_instruction_finalize(GDalvikInstruction *);
+
 /* Liste les registres lus et écrits par l'instruction. */
 static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *, GArchRegister ***, size_t *, GArchRegister ***, size_t *);
 
@@ -321,8 +327,8 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
 };
 
 
-/* Traduit une instruction en version humainement lisible. */
-static const char *dalvik_get_instruction_text(const GDalvikInstruction *, const GExeFormat *, AsmSyntax);
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *dalvik_get_instruction_keyword(const GDalvikInstruction *, AsmSyntax);
 
 /* Informe sur une éventuelle référence à une autre instruction. */
 static InstructionLinkType dalvik_get_instruction_link(const GDalvikInstruction *, vmpa_t *);
@@ -354,6 +360,17 @@ G_DEFINE_TYPE(GDalvikInstruction, g_dalvik_instruction, G_TYPE_ARCH_INSTRUCTION)
 
 static void g_dalvik_instruction_class_init(GDalvikInstructionClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_instruction_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_dalvik_instruction_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->get_key = (get_instruction_keyword_fc)dalvik_get_instruction_keyword;
 
 }
 
@@ -377,7 +394,6 @@ static void g_dalvik_instruction_init(GDalvikInstruction *instr)
     parent = G_ARCH_INSTRUCTION(instr);
 
     parent->get_rw_regs = (get_instruction_rw_regs_fc)g_dalvik_instruction_get_rw_registers;
-    parent->get_text = (get_instruction_text_fc)dalvik_get_instruction_text;
     parent->get_link = (get_instruction_link_fc)dalvik_get_instruction_link;
     parent->is_return = (is_instruction_return_fc)dalvik_instruction_is_return;
     parent->decomp = (decomp_instr_fc)dalvik_instruction_decompile;
@@ -387,6 +403,44 @@ static void g_dalvik_instruction_init(GDalvikInstruction *instr)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_instruction_dispose(GDalvikInstruction *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_instruction_parent_class)->dispose(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_instruction_finalize(GDalvikInstruction *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_instruction_parent_class)->finalize(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : type = type d'instruction à représenter.                     *
 *                                                                             *
 *  Description : Crée une instruction pour l'architecture Dalvik.             *
@@ -517,18 +571,17 @@ DalvikOpcodes dalvik_guess_next_instruction(const bin_t *data, off_t pos, off_t
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : instr  = instruction à traiter.                              *
-*                format = format du binaire manipulé.                         *
 *                syntax = type de représentation demandée.                    *
 *                                                                             *
-*  Description : Traduit une instruction en version humainement lisible.      *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
-*  Retour      : Chaîne de caractères à libérer de la mémoire.                *
+*  Retour      : Mot clef de bas niveau.                                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static const char *dalvik_get_instruction_text(const GDalvikInstruction *instr, const GExeFormat *format, AsmSyntax syntax)
+static const char *dalvik_get_instruction_keyword(const GDalvikInstruction *instr, AsmSyntax syntax)
 {
     return _instructions[instr->type].keyword;
 
diff --git a/src/arch/dalvik/pseudo/fill.c b/src/arch/dalvik/pseudo/fill.c
index 702f4b9..acb8551 100644
--- a/src/arch/dalvik/pseudo/fill.c
+++ b/src/arch/dalvik/pseudo/fill.c
@@ -56,6 +56,12 @@ static void g_dalvik_fill_instr_class_init(GDalvikFillInstrClass *);
 /* Initialise une instance d'opérande d'architecture. */
 static void g_dalvik_fill_instr_init(GDalvikFillInstr *);
 
+/* Supprime toutes les références externes. */
+static void g_dalvik_fill_instr_dispose(GDalvikFillInstr *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dalvik_fill_instr_finalize(GDalvikFillInstr *);
+
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 static void g_dalvik_fill_instr_print(const GDalvikFillInstr *, GCodeBuffer *, MemoryDataSize, const bin_t *, AsmSyntax);
 
@@ -79,6 +85,17 @@ G_DEFINE_TYPE(GDalvikFillInstr, g_dalvik_fill_instr, G_TYPE_DALVIK_INSTRUCTION);
 
 static void g_dalvik_fill_instr_class_init(GDalvikFillInstrClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_fill_instr_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_dalvik_fill_instr_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->print = (print_instruction_fc)g_dalvik_fill_instr_print;
 
 }
 
@@ -97,11 +114,44 @@ static void g_dalvik_fill_instr_class_init(GDalvikFillInstrClass *klass)
 
 static void g_dalvik_fill_instr_init(GDalvikFillInstr *instr)
 {
-    GArchInstruction *parent;               /* Instance parente            */
 
-    parent = G_ARCH_INSTRUCTION(instr);
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    parent->print = (print_instruction_fc)g_dalvik_fill_instr_print;
+static void g_dalvik_fill_instr_dispose(GDalvikFillInstr *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_fill_instr_parent_class)->dispose(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_fill_instr_finalize(GDalvikFillInstr *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_fill_instr_parent_class)->finalize(G_OBJECT(instr));
 
 }
 
@@ -179,13 +229,20 @@ static void g_dalvik_fill_instr_print(const GDalvikFillInstr *instr, GCodeBuffer
 
     base = G_ARCH_INSTRUCTION(instr);
 
+    line = NULL;
+
+
+#if 0
+
     line = g_code_buffer_append_new_line(buffer, base->address);
 
     /* Adresse virtuelle ou physique */
 
     len = vmpa_to_string(base->address, msize, address);
 
-    g_buffer_line_insert_text(line, BLC_ADDRESS, address, len, RTT_RAW);
+    g_buffer_line_insert_text(line, BLC_PHYSICAL, address, len, RTT_RAW);
+
+    /* TODO ... */
 
     /* Code brut */
 
@@ -204,6 +261,8 @@ static void g_dalvik_fill_instr_print(const GDalvikFillInstr *instr, GCodeBuffer
 
     free(bin_code);
 
+#endif
+
     /* Instruction proprement dite */
 
     key = "<fill-array>";
diff --git a/src/arch/dalvik/pseudo/switch.c b/src/arch/dalvik/pseudo/switch.c
index c97c82b..169c5bf 100644
--- a/src/arch/dalvik/pseudo/switch.c
+++ b/src/arch/dalvik/pseudo/switch.c
@@ -55,6 +55,12 @@ static void g_dalvik_switch_instr_class_init(GDalvikSwitchInstrClass *);
 /* Initialise une instance d'opérande d'architecture. */
 static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *);
 
+/* Supprime toutes les références externes. */
+static void g_dalvik_switch_instr_dispose(GDalvikSwitchInstr *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_dalvik_switch_instr_finalize(GDalvikSwitchInstr *);
+
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 static void g_dalvik_switch_instr_print(const GDalvikSwitchInstr *, GCodeBuffer *, MemoryDataSize, const bin_t *, AsmSyntax);
 
@@ -78,6 +84,17 @@ G_DEFINE_TYPE(GDalvikSwitchInstr, g_dalvik_switch_instr, G_TYPE_DALVIK_INSTRUCTI
 
 static void g_dalvik_switch_instr_class_init(GDalvikSwitchInstrClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_switch_instr_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_dalvik_switch_instr_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->print = (print_instruction_fc)g_dalvik_switch_instr_print;
 
 }
 
@@ -96,11 +113,44 @@ static void g_dalvik_switch_instr_class_init(GDalvikSwitchInstrClass *klass)
 
 static void g_dalvik_switch_instr_init(GDalvikSwitchInstr *instr)
 {
-    GArchInstruction *parent;               /* Instance parente            */
 
-    parent = G_ARCH_INSTRUCTION(instr);
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_switch_instr_dispose(GDalvikSwitchInstr *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_switch_instr_parent_class)->dispose(G_OBJECT(instr));
+
+}
 
-    parent->print = (print_instruction_fc)g_dalvik_switch_instr_print;
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_dalvik_switch_instr_finalize(GDalvikSwitchInstr *instr)
+{
+    G_OBJECT_CLASS(g_dalvik_switch_instr_parent_class)->finalize(G_OBJECT(instr));
 
 }
 
@@ -182,13 +232,19 @@ static void g_dalvik_switch_instr_print(const GDalvikSwitchInstr *instr, GCodeBu
 
     base = G_ARCH_INSTRUCTION(instr);
 
+    line = NULL;
+
+
+#if 0
     line = g_code_buffer_append_new_line(buffer, base->address);
 
     /* Adresse virtuelle ou physique */
 
     len = vmpa_to_string(base->address, msize, address);
 
-    g_buffer_line_insert_text(line, BLC_ADDRESS, address, len, RTT_RAW);
+    g_buffer_line_insert_text(line, BLC_PHYSICAL, address, len, RTT_RAW);
+
+    /* TODO ... */
 
     /* Code brut */
 
@@ -207,6 +263,8 @@ static void g_dalvik_switch_instr_print(const GDalvikSwitchInstr *instr, GCodeBu
 
     free(bin_code);
 
+#endif
+
     /* Instruction proprement dite */
 
     key = "<fill-array>";
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index 98f1eea..076eec2 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -39,7 +39,7 @@ typedef void (* get_instruction_rw_regs_fc) (const GArchInstruction *, GArchRegi
 typedef void (* print_instruction_fc) (const GArchInstruction *, GCodeBuffer *, MemoryDataSize, const bin_t *, AsmSyntax);
 
 /* Traduit une instruction en version humainement lisible. */
-typedef const char * (* get_instruction_text_fc) (const GArchInstruction *, const GExeFormat *, AsmSyntax);
+typedef const char * (* get_instruction_keyword_fc) (const GArchInstruction *, AsmSyntax);
 
 /* Informe sur une éventuelle référence à une autre instruction. */
 typedef InstructionLinkType (* get_instruction_link_fc) (const GArchInstruction *, vmpa_t *);
@@ -55,6 +55,7 @@ struct _GArchInstruction
 
     DL_LIST_ITEM(flow);                     /* Maillon de liste chaînée    */
 
+    vmpa2t address2;                         /* Position associée           */
     off_t offset;                           /* Position physique de départ */
     off_t length;                           /* Taille de l'instruction     */
 
@@ -72,8 +73,8 @@ struct _GArchInstruction
     size_t to_count;                        /* Nombre de ces destinations  */
 
     get_instruction_rw_regs_fc get_rw_regs; /* Liste des registres liés    */
-    print_instruction_fc print;             /* Imprime l'ensemble          */
-    get_instruction_text_fc get_text;       /* Texte humain équivalent     */
+    //print_instruction_fc print;             /* Imprime l'ensemble          */
+    //get_instruction_keyword_fc get_key;     /* Texte humain équivalent     */
     get_instruction_link_fc get_link;       /* Référence à une instruction */
     is_instruction_return_fc is_return;     /* Retour de fonction ou pas ? */
     decomp_instr_fc decomp;                 /* Procédure de décompilation  */
@@ -86,6 +87,9 @@ struct _GArchInstructionClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    print_instruction_fc print;             /* Imprime l'ensemble          */
+    get_instruction_keyword_fc get_key;     /* Texte humain équivalent     */
+
 };
 
 
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index 72911bf..3a62a90 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -39,6 +39,12 @@ static void g_arch_instruction_class_init(GArchInstructionClass *);
 /* Initialise une instance d'opérande d'architecture. */
 static void g_arch_instruction_init(GArchInstruction *);
 
+/* Supprime toutes les références externes. */
+static void g_arch_instruction_dispose(GArchInstruction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_arch_instruction_finalize(GArchInstruction *);
+
 
 
 /* --------------------- CONVERSIONS DU FORMAT DES INSTRUCTIONS --------------------- */
@@ -67,6 +73,17 @@ G_DEFINE_TYPE(GArchInstruction, g_arch_instruction, G_TYPE_OBJECT);
 
 static void g_arch_instruction_class_init(GArchInstructionClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_arch_instruction_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_arch_instruction_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->print = (print_instruction_fc)_g_arch_instruction_print;
 
 }
 
@@ -92,10 +109,47 @@ static void g_arch_instruction_init(GArchInstruction *instr)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arch_instruction_dispose(GArchInstruction *instr)
+{
+    G_OBJECT_CLASS(g_arch_instruction_parent_class)->dispose(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arch_instruction_finalize(GArchInstruction *instr)
+{
+    G_OBJECT_CLASS(g_arch_instruction_parent_class)->finalize(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : instr   = instruction quelconque à modifier.                 *
-*                offset  = position physique dans le code binaire.            *
+*                address = adresse virtuelle et/ou position physique.         *
 *                length  = taille de l'instruction.                           *
-*                address = adresse virtuelle ou position physique.            *
 *                                                                             *
 *  Description : Définit la localisation d'une instruction.                   *
 *                                                                             *
@@ -105,12 +159,15 @@ static void g_arch_instruction_init(GArchInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-void g_arch_instruction_set_location(GArchInstruction *instr, off_t offset, off_t length, vmpa_t address)
+void g_arch_instruction_set_location(GArchInstruction *instr, const vmpa2t *address, off_t length)
 {
-    instr->offset = offset;
-    instr->length = length;
+    copy_vmpa(&instr->address2, address);
+
+    /* FIXME */
+    instr->offset = get_phy_addr(address);
+    instr->address = get_virt_addr(address);
 
-    instr->address = address;
+    instr->length = length;
 
 }
 
@@ -578,6 +635,7 @@ size_t g_arch_instruction_compute_group_index(GArchInstruction **iter, GArchInst
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : instr  = instruction d'assemblage à consulter.               *
+*                syntax = type de représentation demandée.                    *
 *                                                                             *
 *  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
@@ -587,9 +645,9 @@ size_t g_arch_instruction_compute_group_index(GArchInstruction **iter, GArchInst
 *                                                                             *
 ******************************************************************************/
 
-const char *g_arch_instruction_get_keyword(const GArchInstruction *instr)
+const char *g_arch_instruction_get_keyword(const GArchInstruction *instr, AsmSyntax syntax)
 {
-    return instr->get_text(instr, NULL/* FIXME */, 0/* FIXME */);
+    G_ARCH_INSTRUCTION_GET_CLASS(instr)->get_key(instr, syntax);
 
 }
 
@@ -611,42 +669,17 @@ const char *g_arch_instruction_get_keyword(const GArchInstruction *instr)
 static void _g_arch_instruction_print(const GArchInstruction *instr, GCodeBuffer *buffer, MemoryDataSize msize, const bin_t *content, AsmSyntax syntax)
 {
     GBufferLine *line;                      /* Ligne de destination        */
-    char address[VMPA_MAX_SIZE];            /* Adresse au format texte     */
-    size_t len;                             /* Taille de l'élément inséré  */
-    char *bin_code;                         /* Tampon du code binaire      */
-    off_t i;                                /* Boucle de parcours #1       */
     const char *key;                        /* Mot clef principal          */
     size_t klen;                            /* Taille de ce mot clef       */
-    size_t j;                               /* Boucle de parcours #2       */
-
-    line = g_code_buffer_append_new_line(buffer, instr->address);
-
-    /* Adresse virtuelle ou physique */
-
-    len = vmpa_to_string(instr->address, msize, address);
-
-    g_buffer_line_insert_text(line, BLC_ADDRESS, address, len, RTT_RAW);
-
-    /* Code brut */
-
-    bin_code = (char *)calloc(instr->length * 3, sizeof(char));
-
-    for (i = 0; i < instr->length; i++)
-    {
-        if ((i + 1) < instr->length)
-            snprintf(&bin_code[i * (2 + 1)], 4, "%02hhx ", content[instr->offset + i]);
-        else
-            snprintf(&bin_code[i * (2 + 1)], 3, "%02hhx", content[instr->offset + i]);
-    }
+    size_t i;                               /* Boucle de parcours          */
 
-    g_buffer_line_insert_text(line, BLC_BINARY,
-                              bin_code, instr->length * 3 - 1, RTT_RAW_CODE);
+    line = g_code_buffer_append_new_line(buffer, &instr->address2);
 
-    free(bin_code);
+    g_buffer_line_fill_for_instr(line, msize/* TODO ! */, msize, content, instr->length, true);
 
     /* Instruction proprement dite */
 
-    key = instr->get_text(instr, NULL/* FIXME */, 0/* FIXME */);
+    key = g_arch_instruction_get_keyword(instr, syntax);
     klen = strlen(key);
 
     g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, key, klen, RTT_INSTRUCTION);
@@ -655,12 +688,12 @@ static void _g_arch_instruction_print(const GArchInstruction *instr, GCodeBuffer
     {
         g_arch_operand_print(instr->operands[0], line, syntax);
 
-        for (j = 1; j < instr->operands_count; j++)
+        for (i = 1; i < instr->operands_count; i++)
         {
             g_buffer_line_insert_text(line, BLC_ASSEMBLY, ",", 1, RTT_PUNCT);
             g_buffer_line_insert_text(line, BLC_ASSEMBLY, " ", 1, RTT_RAW);
 
-            g_arch_operand_print(instr->operands[j], line, syntax);
+            g_arch_operand_print(instr->operands[i], line, syntax);
 
         }
 
@@ -685,11 +718,7 @@ static void _g_arch_instruction_print(const GArchInstruction *instr, GCodeBuffer
 
 void g_arch_instruction_print(const GArchInstruction *instr, GCodeBuffer *buffer, MemoryDataSize msize, const bin_t *content, AsmSyntax syntax)
 {
-    if (instr->print != NULL)
-        instr->print(instr, buffer, msize, content, syntax);
-
-    else
-        _g_arch_instruction_print(instr, buffer, msize, content, syntax);
+    G_ARCH_INSTRUCTION_GET_CLASS(instr)->print(instr, buffer, msize, content, syntax);
 
 }
 
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index 06a29bf..a059161 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -30,6 +30,7 @@
 
 #include "immediate.h"
 #include "register.h"
+#include "vmpa.h"
 #include "../analysis/type.h"
 #include "../decomp/context.h"
 #include "../decomp/instruction.h"
@@ -37,10 +38,12 @@
 
 
 
-#define G_TYPE_ARCH_INSTRUCTION                 g_arch_instruction_get_type()
-#define G_ARCH_INSTRUCTION(obj)                 (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arch_instruction_get_type(), GArchInstruction))
-#define G_IS_ARCH_INSTRUCTION(obj)              (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arch_instruction_get_type()))
-#define G_ARCH_INSTRUCTION_GET_IFACE(inst)      (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_arch_instruction_get_type(), GArchInstructionIface))
+#define G_TYPE_ARCH_INSTRUCTION               g_arch_instruction_get_type()
+#define G_ARCH_INSTRUCTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arch_instruction_get_type(), GArchInstruction))
+#define G_IS_ARCH_INSTRUCTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arch_instruction_get_type()))
+#define G_ARCH_INSTRUCTION_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARCH_INSTRUCTION, GArchInstructionClass))
+#define G_IS_ARCH_INSTRUCTION_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARCH_INSTRUCTION))
+#define G_ARCH_INSTRUCTION_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARCH_INSTRUCTION, GArchInstructionClass))
 
 
 /* Définition générique d'une instruction d'architecture (instance) */
@@ -54,7 +57,7 @@ typedef struct _GArchInstructionClass GArchInstructionClass;
 GType g_arch_instruction_get_type(void);
 
 /* Définit la localisation d'une instruction. */
-void g_arch_instruction_set_location(GArchInstruction *, off_t, off_t, vmpa_t);
+void g_arch_instruction_set_location(GArchInstruction *, const vmpa2t *, off_t);
 
 /* Fournit la localisation d'une instruction. */
 void g_arch_instruction_get_location(const GArchInstruction *, off_t *, off_t *, vmpa_t *);
@@ -139,7 +142,7 @@ size_t g_arch_instruction_compute_group_index(GArchInstruction **, GArchInstruct
 
 
 /* Fournit le nom humain de l'instruction manipulée. */
-const char *g_arch_instruction_get_keyword(const GArchInstruction *);
+const char *g_arch_instruction_get_keyword(const GArchInstruction *, AsmSyntax);
 
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 void g_arch_instruction_print(const GArchInstruction *, GCodeBuffer *, MemoryDataSize, const bin_t *, AsmSyntax);
diff --git a/src/arch/jvm/instruction.c b/src/arch/jvm/instruction.c
index bfb6fc1..c2daaf5 100644
--- a/src/arch/jvm/instruction.c
+++ b/src/arch/jvm/instruction.c
@@ -199,7 +199,7 @@ static void g_jvm_instruction_init(GJvmInstruction *instr)
 
     parent = G_ARCH_INSTRUCTION(instr);
 
-    parent->get_text = (get_instruction_text_fc)jvm_get_instruction_text;
+    //parent->get_text = (get_instruction_text_fc)jvm_get_instruction_text;
 
 }
 
diff --git a/src/arch/mips/instruction.c b/src/arch/mips/instruction.c
index b3ef65d..93c32e7 100644
--- a/src/arch/mips/instruction.c
+++ b/src/arch/mips/instruction.c
@@ -177,7 +177,7 @@ static void g_mips_instruction_init(GMipsInstruction *instr)
 
     parent = G_ARCH_INSTRUCTION(instr);
 
-    parent->get_text = (get_instruction_text_fc)mips_get_instruction_text;
+    //parent->get_text = (get_instruction_text_fc)mips_get_instruction_text;
 
 }
 
diff --git a/src/arch/processor.c b/src/arch/processor.c
index 8ca58a7..48d0924 100644
--- a/src/arch/processor.c
+++ b/src/arch/processor.c
@@ -259,7 +259,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
         skipped = (result == SKIPPED_INSTR);
 
         *pos = old_pos;
-        result = g_db_instruction_new_from_data(data, pos, end, addr, proc);
+        result = NULL;// changed !!! g_db_instruction_new_from_data(data, pos, end, addr, proc);
 
 #ifdef DEBUG /* FIXME */
         if (skipped)
@@ -267,7 +267,7 @@ GArchInstruction *g_arch_processor_decode_instruction(const GArchProcessor *proc
 #endif
     }
 
-    g_arch_instruction_set_location(result, old_pos, *pos - old_pos, addr);
+    //g_arch_instruction_set_location(result, old_pos, *pos - old_pos, addr);
 
     return result;
 
diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index c6972af..4ee0b99 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -26,6 +26,7 @@
 
 #include <inttypes.h>
 #include <malloc.h>
+#include <string.h>
 
 
 #include "../common/io.h"
@@ -35,6 +36,76 @@
 
 
 
+
+#if 0
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : src = définition à copier.                                   *
+*                                                                             *
+*  Description : Crée la copie d'un adressage mémoire en local.               *
+*                                                                             *
+*  Retour      : Adressage alloué sur la pile.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+inline vmpa2t *local_dup_vmpa(const vmpa2t *src)
+{
+    vmpa2t *result;                         /* Adressage à retourner       */
+
+    result = alloca(sizeof(vmpa2t));
+
+    copy_vmpa(result, src);
+
+    return result;
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = structure de destination pour la copie.               *
+*                src  = structure de source pour la copie.                    *
+*                                                                             *
+*  Description : Copie la définition d'un adressage dans un autre.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void copy_vmpa(vmpa2t *dest, const vmpa2t *src)
+{
+    dest->physical = src->physical;
+    dest->virtual= src->virtual;
+
+    dest->last_phys_size = src->last_phys_size;
+    dest->last_virt_size = src->last_virt_size;
+
+    strncpy(dest->phys_cache, src->phys_cache, VMPA_MAX_SIZE);
+    dest->phys_cache[VMPA_MAX_SIZE - 1] = '\0';
+
+    strncpy(dest->virt_cache, src->virt_cache, VMPA_MAX_SIZE);
+    dest->virt_cache[VMPA_MAX_SIZE - 1] = '\0';
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : phy  = position dans la mémoire physique.                    *
@@ -164,6 +235,7 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
 *                                                                             *
 *  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
 *                msize  = taille de cette adresse, réelle ou désirée.         *
+*                length = transmission de la taille du résultat ou NULL. [OUT]*
 *                                                                             *
 *  Description : Transforme une adresse physique en chaîne de caractères.     *
 *                                                                             *
@@ -173,39 +245,45 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
 *                                                                             *
 ******************************************************************************/
 
-const char *vmpa2_phy_to_string(vmpa2t *addr, MemoryDataSize msize)
+const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
 {
-    if (addr->phy_cache[0] == '\0' || addr->last_phy_size != msize)
+    size_t ret;                             /* Retour de l'impression      */
+
+    if (addr->phys_cache[0] == '\0' || addr->last_phys_size != msize)
     {
         switch (msize)
         {
             case MDS_8_BITS:
-                snprintf(addr->phy_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
+                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
                 break;
 
             case MDS_16_BITS:
-                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
+                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
                 break;
 
             case MDS_32_BITS:
-                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
+                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
                 break;
 
             case MDS_64_BITS:
-                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
+                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
                 break;
 
             default:
-                snprintf(addr->phy_cache, VMPA_MAX_SIZE, "???");
+                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "???");
                 break;
 
         }
 
-        addr->last_phy_size = msize;
+        addr->last_phys_size = msize;
+        addr->last_phys_len = ret;
 
     }
 
-    return addr->phy_cache;
+    if (length != NULL)
+        *length = addr->last_phys_size;
+
+    return addr->phys_cache;
 
 }
 
@@ -214,6 +292,7 @@ const char *vmpa2_phy_to_string(vmpa2t *addr, MemoryDataSize msize)
 *                                                                             *
 *  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
 *                msize  = taille de cette adresse, réelle ou désirée.         *
+*                length = transmission de la taille du résultat ou NULL. [OUT]*
 *                                                                             *
 *  Description : Transforme une adresse virtuelle en chaîne de caractères.    *
 *                                                                             *
@@ -223,38 +302,44 @@ const char *vmpa2_phy_to_string(vmpa2t *addr, MemoryDataSize msize)
 *                                                                             *
 ******************************************************************************/
 
-const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize)
+const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
 {
+    size_t ret;                             /* Retour de l'impression      */
+
     if (addr->virt_cache[0] == '\0' || addr->last_virt_size != msize)
     {
         switch (msize)
         {
             case MDS_8_BITS:
-                snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
+                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
                 break;
 
             case MDS_16_BITS:
-                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
+                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
                 break;
 
             case MDS_32_BITS:
-                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
+                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
                 break;
 
             case MDS_64_BITS:
-                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
+                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
                 break;
 
             default:
-                snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
+                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
                 break;
 
         }
 
         addr->last_virt_size = msize;
+        addr->last_virt_len = ret;
 
     }
 
+    if (length != NULL)
+        *length = addr->last_virt_size;
+
     return addr->virt_cache;
 
 }
diff --git a/src/arch/vmpa.h b/src/arch/vmpa.h
index 5df9b8a..461780c 100644
--- a/src/arch/vmpa.h
+++ b/src/arch/vmpa.h
@@ -25,6 +25,7 @@
 #define _ARCH_VMPA_H
 
 
+#include <alloca.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -50,9 +51,11 @@ struct _vmpa2_t
     off_t physical;                         /* Position physique           */
     uint64_t virtual;                       /* Adresse virtuelle           */
 
-    MemoryDataSize last_phy_size;           /* Dernière taille demandée #1 */
+    MemoryDataSize last_phys_size;          /* Dernière taille demandée #1 */
     MemoryDataSize last_virt_size;          /* Dernière taille demandée #2 */
-    char phy_cache[VMPA_MAX_SIZE];          /* Impression physique cachée  */
+    size_t last_phys_len;                   /* Dernière taille fournie #1  */
+    size_t last_virt_len;                   /* Dernière taille fournie #2  */
+    char phys_cache[VMPA_MAX_SIZE];         /* Impression physique cachée  */
     char virt_cache[VMPA_MAX_SIZE];         /* Impression virtuelle cachée */
 
 };
@@ -66,6 +69,30 @@ typedef struct _vmpa2_t vmpa2_t;
 typedef struct _vmpa2_t vmpa2t;
 
 
+
+
+/* Crée la copie d'un adressage mémoire en local. */
+//inline vmpa2t *local_dup_vmpa(const vmpa2t *) __attribute__((always_inline));
+
+
+
+#define local_dup_vmpa(src) \
+    ({                      \
+        vmpa2t *__result;           \
+        __result = alloca(sizeof(vmpa2t));        \
+        copy_vmpa(__result, src);               \
+        __result;                           \
+    })
+
+
+
+/* Copie la définition d'un adressage dans un autre. */
+void copy_vmpa(vmpa2t *, const vmpa2t *);
+
+
+
+
+
 /* Initialise une localisation dans l'espace mémoire/physique. */
 void init_vmpa(vmpa2t *, off_t, uint64_t);
 
@@ -81,6 +108,11 @@ vmpa2t *make_vmpa(off_t, uint64_t);
 
 
 
+#define get_phy_addr(a) a->physical
+#define get_virt_addr(a) a->virtual
+
+
+
 
 /* Lit la définition d'une adresse depuis un flux réseau. */
 bool recv_vmpa(vmpa2t *, int, int);
@@ -89,10 +121,10 @@ bool recv_vmpa(vmpa2t *, int, int);
 bool send_vmpa(const vmpa2t *, int, int);
 
 /* Transforme une adresse physique en chaîne de caractères. */
-const char *vmpa2_phy_to_string(vmpa2t *, MemoryDataSize);
+const char *vmpa2_phys_to_string(vmpa2t *, MemoryDataSize, size_t *);
 
 /* Transforme une adresse virtuelle en chaîne de caractères. */
-const char *vmpa2_virt_to_string(vmpa2t *, MemoryDataSize);
+const char *vmpa2_virt_to_string(vmpa2t *, MemoryDataSize, size_t *);
 
 
 
diff --git a/src/arch/x86/instruction.c b/src/arch/x86/instruction.c
index 789aab2..0450d96 100644
--- a/src/arch/x86/instruction.c
+++ b/src/arch/x86/instruction.c
@@ -494,7 +494,7 @@ static void g_x86_instruction_init(GX86Instruction *instr)
 
     parent = G_ARCH_INSTRUCTION(instr);
 
-    parent->get_text = (get_instruction_text_fc)x86_get_instruction_text;
+    //parent->get_text = (get_instruction_text_fc)x86_get_instruction_text;
     parent->get_link = (get_instruction_link_fc)x86_get_instruction_link;
     parent->is_return = (is_instruction_return_fc)x86_instruction_is_return;