Reduced once again the size of the main instruction structure.

17 files changed, 248 insertions, 187 deletions

diff --git a/ChangeLog b/ChangeLog
index 49e0b88..1569aac 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,29 @@
 16-10-29  Cyrille Bagard <nocbos@gmail.com>
 
+	* src/arch/arm/instruction-int.h:
+	* src/arch/arm/instruction.c:
+	* src/arch/arm/instruction.h:
+	* src/arch/arm/v7/instruction.c:
+	* src/arch/arm/v7/instruction.h:
+	* src/arch/arm/v7/opdefs/Makefile.am:
+	* src/arch/dalvik/instruction.c:
+	Update code.
+
+	* src/arch/instruction-int.h:
+	* src/arch/instruction.c:
+	* src/arch/instruction.h:
+	Reduce once again the size of the main instruction structure.
+
+	* src/arch/raw.c:
+	* src/arch/undefined.c:
+	* tools/d2c/Makefile.am:
+	* tools/d2c/qckcall.c:
+	* tools/d2c/qckcall.h:
+	* tools/d2c/spec.c:
+	Update code.
+
+16-10-29  Cyrille Bagard <nocbos@gmail.com>
+
 	* plugins/libcsem/exit.c:
 	* plugins/pychrysa/arch/instruction.c:
 	* src/analysis/blocks/flow.c:
diff --git a/src/arch/arm/instruction-int.h b/src/arch/arm/instruction-int.h
index 0dc848d..ba93b03 100644
--- a/src/arch/arm/instruction-int.h
+++ b/src/arch/arm/instruction-int.h
@@ -36,6 +36,9 @@ struct _GArmInstruction
     GArchInstruction parent;                /* A laisser en premier        */
 
     const char *keyword;                    /* Nom clef de l'instruction   */
+    char *suffix;                           /* Complément au nom affiché   */
+    char *cached_keyword;                   /* Désignation complète        */
+
     ArmCondCode cond;                       /* Condition d'exécution       */
 
 };
diff --git a/src/arch/arm/instruction.c b/src/arch/arm/instruction.c
index 2c1f3b8..4c08c9a 100644
--- a/src/arch/arm/instruction.c
+++ b/src/arch/arm/instruction.c
@@ -24,6 +24,7 @@
 #include "instruction.h"
 
 
+#include <malloc.h>
 #include <string.h>
 
 
@@ -44,8 +45,8 @@ static void g_arm_instruction_dispose(GArmInstruction *);
 /* Procède à la libération totale de la mémoire. */
 static void g_arm_instruction_finalize(GArmInstruction *);
 
-/* Reconstruit le cache complet d'une désignation d'instruction. */
-static void g_arm_instruction_build_keyword(const GArmInstruction *, AsmSyntax);
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *g_arm_instruction_get_keyword(GArmInstruction *, AsmSyntax);
 
 
 
@@ -76,7 +77,7 @@ static void g_arm_instruction_class_init(GArmInstructionClass *klass)
     object_class->dispose = (GObjectFinalizeFunc/* ! */)g_arm_instruction_dispose;
     object_class->finalize = (GObjectFinalizeFunc)g_arm_instruction_finalize;
 
-    instr->build_key = (build_instruction_keyword_fc)g_arm_instruction_build_keyword;
+    instr->get_keyword = (get_instruction_keyword_fc)g_arm_instruction_get_keyword;
 
 }
 
@@ -133,6 +134,12 @@ static void g_arm_instruction_dispose(GArmInstruction *instr)
 
 static void g_arm_instruction_finalize(GArmInstruction *instr)
 {
+    if (instr->suffix != NULL)
+        free(instr->suffix);
+
+    if (instr->cached_keyword != NULL)
+        free(instr->cached_keyword);
+
     G_OBJECT_CLASS(g_arm_instruction_parent_class)->finalize(G_OBJECT(instr));
 
 }
@@ -140,10 +147,38 @@ static void g_arm_instruction_finalize(GArmInstruction *instr)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr  = instruction à traiter.                              *
+*  Paramètres  : instr  = instruction quelconque à modifier.                  *
+*                suffix = chaîne de caractères fournie en complément.         *
+*                                                                             *
+*  Description : Etend la désignation d'un nom d'instruction.                 *
+*                                                                             *
+*  Retour      : true.                                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_arm_instruction_extend_keyword(GArmInstruction *instr, const char *suffix)
+{
+    instr->suffix = stradd(instr->suffix, suffix);
+
+    if (instr->cached_keyword != NULL)
+    {
+        free(instr->cached_keyword);
+        instr->cached_keyword = NULL;
+    }
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr  = instruction d'assemblage à consulter.               *
 *                syntax = type de représentation demandée.                    *
 *                                                                             *
-*  Description : Reconstruit le cache complet d'une désignation d'instruction.*
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
 *  Retour      : Mot clef de bas niveau.                                      *
 *                                                                             *
@@ -151,20 +186,18 @@ static void g_arm_instruction_finalize(GArmInstruction *instr)
 *                                                                             *
 ******************************************************************************/
 
-static void g_arm_instruction_build_keyword(const GArmInstruction *instr, AsmSyntax syntax)
+static const char *g_arm_instruction_get_keyword(GArmInstruction *instr, AsmSyntax syntax)
 {
-    GArchInstruction *base;                 /* Instruction, vue générique  */
-
-    /* FIXME : tout bouger dans la base des instructions ? */
+    if (instr->cached_keyword == NULL)
+    {
+        instr->cached_keyword = strdup(instr->keyword);
 
-    base = G_ARCH_INSTRUCTION(instr);
+        if (instr->suffix != NULL)
+            instr->cached_keyword = stradd(instr->cached_keyword, instr->suffix);
 
-    base->cached_keyword = strdup(instr->keyword);
+    }
 
-    /*
-    if (base->suffix != NULL)
-        base->cached_keyword = stradd(base->cached_keyword, base->suffix);
-    */
+    return instr->cached_keyword;
 
 }
 
@@ -210,7 +243,7 @@ bool g_arm_instruction_set_cond(GArmInstruction *instr, ArmCondCode cond)
     }
 
     if (suffix != NULL)
-        result = g_arch_instruction_extend_keyword(G_ARCH_INSTRUCTION(instr), suffix);
+        result = g_arm_instruction_extend_keyword(instr, suffix);
 
     else
         result = true;
diff --git a/src/arch/arm/instruction.h b/src/arch/arm/instruction.h
index 3211766..946d272 100644
--- a/src/arch/arm/instruction.h
+++ b/src/arch/arm/instruction.h
@@ -53,6 +53,9 @@ typedef struct _GArmInstructionClass GArmInstructionClass;
 /* Indique le type défini pour une représentation d'une instruction ARM. */
 GType g_arm_instruction_get_type(void);
 
+/* Etend la désignation d'un nom d'instruction. */
+bool g_arm_instruction_extend_keyword(GArmInstruction *, const char *);
+
 /* Définit les conditions d'exécution d'une instruction ARM. */
 bool g_arm_instruction_set_cond(GArmInstruction *, ArmCondCode);
 
diff --git a/src/arch/arm/v7/instruction.c b/src/arch/arm/v7/instruction.c
index d485dbc..0fba9cb 100644
--- a/src/arch/arm/v7/instruction.c
+++ b/src/arch/arm/v7/instruction.c
@@ -24,6 +24,12 @@
 #include "instruction.h"
 
 
+#include <assert.h>
+#ifndef NDEBUG
+#   include <string.h>
+#endif
+
+
 #include "../instruction-int.h"
 
 
@@ -33,6 +39,8 @@ struct _GArmV7Instruction
 {
     GArmInstruction parent;                 /* Instance parente            */
 
+    char encoding;                          /* Encodage de l'instruction   */
+
     bool setflags;                          /* Mise à jour des drapeaux    */
 
 };
@@ -190,14 +198,22 @@ GArchInstruction *g_armv7_instruction_new(const char *keyword)
 static const char *g_armv7_instruction_get_encoding(const GArmV7Instruction *instr)
 {
     const char *result;                     /* Description à retourner     */
-    const char *raw;                        /* Description brute d'origine */
 
-    raw = G_ARCH_INSTRUCTION(instr)->encoding;
+    switch (instr->encoding)
+    {
+        case 't':
+            result = "Thumb/16";
+            break;
 
-    if (raw[0] == 'T' || raw[0] == 't')
-        result = "Thumb";
-    else
-        result = "ARM";
+        case 'T':
+            result = "Thumb/32";
+            break;
+
+        default:
+            result = "ARM";
+            break;
+
+    }
 
     return result;
 
@@ -206,6 +222,29 @@ static const char *g_armv7_instruction_get_encoding(const GArmV7Instruction *ins
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : instr    = instruction quelconque à modifier.                *
+*                encoding = encodage de l'instruction.                        *
+*                                                                             *
+*  Description : Précise l'encodage d'une instruction ARMv7 dans le détail.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_armv7_instruction_set_encoding(GArmV7Instruction *instr, const char *encoding)
+{
+    assert(strlen(encoding) == 1);
+    assert(encoding[0] == 'A' || encoding[0] == 'T' || encoding[0] == 't');
+
+    instr->encoding = encoding[0];
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : instr = instruction ARMv7 à mettre à jour.                   *
 *                set   = statut à enregistrer.                                *
 *                                                                             *
diff --git a/src/arch/arm/v7/instruction.h b/src/arch/arm/v7/instruction.h
index 291f2c9..5d79cb8 100644
--- a/src/arch/arm/v7/instruction.h
+++ b/src/arch/arm/v7/instruction.h
@@ -55,6 +55,9 @@ GType g_armv7_instruction_get_type(void);
 /* Crée une instruction pour l'architecture ARMv7. */
 GArchInstruction *g_armv7_instruction_new(const char *);
 
+/* Précise l'encodage d'une instruction ARMv7 dans le détail. */
+void g_armv7_instruction_set_encoding(GArmV7Instruction *, const char *);
+
 /* Définit si une instruction ARMv7 met à jour les drapeaux. */
 bool g_armv7_instruction_define_setflags(GArmV7Instruction *, bool);
 
diff --git a/src/arch/arm/v7/opdefs/Makefile.am b/src/arch/arm/v7/opdefs/Makefile.am
index 7844578..41785c6 100644
--- a/src/arch/arm/v7/opdefs/Makefile.am
+++ b/src/arch/arm/v7/opdefs/Makefile.am
@@ -24,7 +24,7 @@ D2C_MACROS =											\
     -M SignExtend=sign_extend_armv7_imm					\
     -M SetInsFlag=g_arch_instruction_set_flag			\
     -M StoreCondition=g_arm_instruction_set_cond		\
-	-M ExtendKeyword=g_arch_instruction_extend_keyword
+	-M ExtendKeyword=g_arm_instruction_extend_keyword
 
 D2C_OPERANDS =							\
 	-n BarrierLimitation				\
diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c
index 3735bd7..ca43dbd 100644
--- a/src/arch/dalvik/instruction.c
+++ b/src/arch/dalvik/instruction.c
@@ -332,8 +332,8 @@ static dalvik_instruction _instructions[DOP_COUNT] = {
 };
 
 
-/* Reconstruit le cache complet d'une désignation d'instruction. */
-static void dalvik_build_instruction_keyword(const GDalvikInstruction *, AsmSyntax);
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *dalvik_instruction_get_keyword(const GDalvikInstruction *, AsmSyntax);
 
 /* Décompile une instruction de la machine virtuelle Dalvik. */
 GDecInstruction *dalvik_instruction_decompile(const GDalvikInstruction *, GDecContext *);
@@ -370,7 +370,7 @@ static void g_dalvik_instruction_class_init(GDalvikInstructionClass *klass)
     instr = G_ARCH_INSTRUCTION_CLASS(klass);
 
     instr->get_encoding = (get_instruction_encoding_fc)g_dalvik_instruction_get_encoding;
-    instr->build_key = (build_instruction_keyword_fc)dalvik_build_instruction_keyword;
+    instr->get_keyword = (get_instruction_keyword_fc)dalvik_instruction_get_keyword;
 
 }
 
@@ -562,10 +562,10 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr  = instruction à traiter.                              *
+*  Paramètres  : instr  = instruction d'assemblage à consulter.               *
 *                syntax = type de représentation demandée.                    *
 *                                                                             *
-*  Description : Reconstruit le cache complet d'une désignation d'instruction.*
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
 *                                                                             *
 *  Retour      : Mot clef de bas niveau.                                      *
 *                                                                             *
@@ -573,9 +573,9 @@ static void g_dalvik_instruction_get_rw_registers(const GDalvikInstruction *inst
 *                                                                             *
 ******************************************************************************/
 
-static void dalvik_build_instruction_keyword(const GDalvikInstruction *instr, AsmSyntax syntax)
+static const char *dalvik_instruction_get_keyword(const GDalvikInstruction *instr, AsmSyntax syntax)
 {
-    G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup(instr->keyword);
+    return instr->keyword;
 
 }
 
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index 6c9da03..e4d886b 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -41,8 +41,8 @@ typedef const char * (* get_instruction_encoding_fc) (const GArchInstruction *);
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 typedef GBufferLine * (* print_instruction_fc) (const GArchInstruction *, GCodeBuffer *, MemoryDataSize, const GBinContent *, AsmSyntax);
 
-/* Reconstruit le cache complet d'une désignation d'instruction. */
-typedef void (* build_instruction_keyword_fc) (const GArchInstruction *, AsmSyntax);
+/* Fournit le nom humain de l'instruction manipulée. */
+typedef const char * (* get_instruction_keyword_fc) (GArchInstruction *, AsmSyntax );
 
 /* Informe sur une éventuelle référence à une autre instruction. */
 typedef InstructionLinkType (* get_instruction_link_fc) (const GArchInstruction *, vmpa_t *);
@@ -55,11 +55,6 @@ struct _GArchInstruction
 
     DL_LIST_ITEM(flow);                     /* Maillon de liste chaînée    */
 
-    const char *encoding;                   /* Encodage de l'instruction   */
-
-    char *suffix;                           /* Complément au nom affiché   */
-    char *cached_keyword;                   /* Désignation complète        */
-
     phys_t max_displayed_len;               /* Quantité de code affichée   */
 
     ArchInstrFlag flags;                    /* Informations complémentaires*/
@@ -94,9 +89,9 @@ struct _GArchInstructionClass
     GObjectClass parent;                    /* A laisser en premier        */
 
     get_instruction_encoding_fc get_encoding; /* Obtention de l'encodage   */
+    get_instruction_keyword_fc get_keyword; /* Texte humain équivalent     */
 
     print_instruction_fc print;             /* Imprime l'ensemble          */
-    build_instruction_keyword_fc build_key; /* Texte humain équivalent     */
 
 };
 
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index b57b49d..f77a20b 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -30,7 +30,6 @@
 
 
 #include "instruction-int.h"
-#include "../common/extstr.h"
 
 
 
@@ -176,56 +175,6 @@ const char *g_arch_instruction_get_encoding(const GArchInstruction *instr)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr    = instruction quelconque à modifier.                *
-*                encoding = encodage de l'instruction.                        *
-*                                                                             *
-*  Description : Précise l'encodage d'une instruction de façon détaillée.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_arch_instruction_set_encoding(GArchInstruction *instr, const char *encoding)
-{
-    instr->encoding = encoding;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr  = instruction quelconque à modifier.                  *
-*                suffix = chaîne de caractères fournie en complément.         *
-*                                                                             *
-*  Description : Etend la désignation d'un nom d'instruction.                 *
-*                                                                             *
-*  Retour      : true.                                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_arch_instruction_extend_keyword(GArchInstruction *instr, const char *suffix)
-{
-    instr->suffix = stradd(instr->suffix, suffix);
-
-    if (instr->cached_keyword != NULL)
-    {
-        free(instr->cached_keyword);
-        instr->cached_keyword = NULL;
-    }
-
-    /* TODO : signal ? */
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : instr = instruction quelconque à modifier.                   *
 *                flag  = drapeau d'information complémentaire à planter.      *
 *                                                                             *
@@ -900,13 +849,11 @@ size_t g_arch_instruction_compute_group_index(GArchInstruction **iter, GArchInst
 
 const char *g_arch_instruction_get_keyword(GArchInstruction *instr, AsmSyntax syntax)
 {
-    if (instr->cached_keyword == NULL)
-        G_ARCH_INSTRUCTION_GET_CLASS(instr)->build_key(instr, syntax);
+    const char *result;                     /* Désignation à retourner     */
 
-    if (instr->suffix != NULL)
-        instr->cached_keyword = stradd(instr->cached_keyword, instr->suffix);
+    result = G_ARCH_INSTRUCTION_GET_CLASS(instr)->get_keyword(instr, syntax);
 
-    return instr->cached_keyword;
+    return result;
 
 }
 
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index fed88a3..291f160 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -62,12 +62,6 @@ GType g_arch_instruction_get_type(void);
 /* Indique l'encodage d'une instruction de façon détaillée. */
 const char *g_arch_instruction_get_encoding(const GArchInstruction *);
 
-/* Précise l'encodage d'une instruction de façon détaillée. */
-void g_arch_instruction_set_encoding(GArchInstruction *, const char *);
-
-/* Etend la désignation d'un nom d'instruction. */
-bool g_arch_instruction_extend_keyword(GArchInstruction *, const char *);
-
 /* Drapeaux pour informations complémentaires */
 typedef enum _ArchInstrFlag
 {
diff --git a/src/arch/raw.c b/src/arch/raw.c
index 356f809..25e1fb5 100644
--- a/src/arch/raw.c
+++ b/src/arch/raw.c
@@ -74,12 +74,12 @@ static void g_raw_instruction_finalize(GRawInstruction *);
 /* Indique l'encodage d'une instruction de façon détaillée. */
 static const char *g_raw_instruction_get_encoding(const GRawInstruction *);
 
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *g_raw_instruction_get_keyword(const GRawInstruction *, AsmSyntax);
+
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 static GBufferLine *g_raw_instruction_print(GRawInstruction *, GCodeBuffer *, MemoryDataSize, const GBinContent *, AsmSyntax);
 
-/* Reconstruit le cache complet d'une désignation d'instruction. */
-static void g_raw_instruction_build_keyword(const GRawInstruction *, AsmSyntax);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -116,8 +116,8 @@ static void g_raw_instruction_class_init(GRawInstructionClass *klass)
     instr = G_ARCH_INSTRUCTION_CLASS(klass);
 
     instr->get_encoding = (get_instruction_encoding_fc)g_raw_instruction_get_encoding;
+    instr->get_keyword = (get_instruction_keyword_fc)g_raw_instruction_get_keyword;
     instr->print = (print_instruction_fc)g_raw_instruction_print;
-    instr->build_key = (build_instruction_keyword_fc)g_raw_instruction_build_keyword;
 
 }
 
@@ -409,6 +409,39 @@ static const char *g_raw_instruction_get_encoding(const GRawInstruction *instr)
 }
 
 
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr  = instruction d'assemblage à consulter.               *
+*                syntax = type de représentation demandée.                    *
+*                                                                             *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
+*                                                                             *
+*  Retour      : Mot clef de bas niveau.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_raw_instruction_get_keyword(const GRawInstruction *instr, AsmSyntax syntax)
+{
+    GArchOperand *operand;                  /* Octet décodé à afficher     */
+    MemoryDataSize size;                    /* Taille de valeur associée   */
+
+    static char *defines[] = { "dn", "db", "dw", "dd", "dq" };
+
+    operand = g_arch_instruction_get_operand(G_ARCH_INSTRUCTION(instr), 0);
+
+    if (G_IS_TARGET_OPERAND(operand))
+        size = g_target_operand_get_size(G_TARGET_OPERAND(operand));
+    else
+        size = g_imm_operand_get_size(G_IMM_OPERAND(operand));
+
+    return defines[MDS_RANGE(size)];
+
+}
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : instr  = instruction d'assemblage à représenter.             *
@@ -546,39 +579,6 @@ static GBufferLine *g_raw_instruction_print(GRawInstruction *instr, GCodeBuffer
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr  = instruction à traiter.                              *
-*                format = format du binaire manipulé.                         *
-*                syntax = type de représentation demandée.                    *
-*                                                                             *
-*  Description : Reconstruit le cache complet d'une désignation d'instruction.*
-*                                                                             *
-*  Retour      : Mot clef de bas niveau.                                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_raw_instruction_build_keyword(const GRawInstruction *instr, AsmSyntax syntax)
-{
-    GArchOperand *operand;                  /* Octet décodé à afficher     */
-    MemoryDataSize size;                    /* Taille de valeur associée   */
-
-    static char *defines[] = { "dn", "db", "dw", "dd", "dq" };
-
-    operand = g_arch_instruction_get_operand(G_ARCH_INSTRUCTION(instr), 0);
-
-    if (G_IS_TARGET_OPERAND(operand))
-        size = g_target_operand_get_size(G_TARGET_OPERAND(operand));
-    else
-        size = g_imm_operand_get_size(G_IMM_OPERAND(operand));
-
-    G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup(defines[MDS_RANGE(size)]);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : instr      = instruction à traiter.                          *
 *                is_padding = nouveau statut à associer au contenu.           *
 *                                                                             *
diff --git a/src/arch/undefined.c b/src/arch/undefined.c
index e69a399..df2e9ff 100644
--- a/src/arch/undefined.c
+++ b/src/arch/undefined.c
@@ -66,12 +66,12 @@ static void g_undef_instruction_finalize(GUndefInstruction *);
 /* Indique l'encodage d'une instruction de façon détaillée. */
 static const char *g_undef_instruction_get_encoding(const GUndefInstruction *);
 
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *g_undef_instruction_get_keyword(const GUndefInstruction *, AsmSyntax);
+
 /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
 static GBufferLine *g_undef_instruction_print(GUndefInstruction *, GCodeBuffer *, MemoryDataSize, const GBinContent *, AsmSyntax);
 
-/* Reconstruit le cache complet d'une désignation d'instruction. */
-static void g_undef_instruction_build_keyword(const GUndefInstruction *, AsmSyntax);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -108,8 +108,8 @@ static void g_undef_instruction_class_init(GUndefInstructionClass *klass)
     instr = G_ARCH_INSTRUCTION_CLASS(klass);
 
     instr->get_encoding = (get_instruction_encoding_fc)g_undef_instruction_get_encoding;
+    instr->get_keyword = (get_instruction_keyword_fc)g_undef_instruction_get_keyword;
     instr->print = (print_instruction_fc)g_undef_instruction_print;
-    instr->build_key = (build_instruction_keyword_fc)g_undef_instruction_build_keyword;
 
 }
 
@@ -220,6 +220,48 @@ static const char *g_undef_instruction_get_encoding(const GUndefInstruction *ins
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : instr  = instruction d'assemblage à consulter.               *
+*                syntax = type de représentation demandée.                    *
+*                                                                             *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
+*                                                                             *
+*  Retour      : Mot clef de bas niveau.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_undef_instruction_get_keyword(const GUndefInstruction *instr, AsmSyntax syntax)
+{
+    const char *result;                     /* Désignation à retourner     */
+
+    switch (instr->status)
+    {
+        case IBS_NOP:
+            result = "nop";
+            break;
+
+        case IBS_UNDEFINED:
+            result = "undefined";
+            break;
+
+        case IBS_UNPREDICTABLE:
+            result = "unpredictable";
+            break;
+
+        default:
+            assert(false);
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : instr  = instruction d'assemblage à représenter.             *
 *                buffer = espace où placer ledit contenu.                     *
 *                msize   = taille idéale des positions et adresses;           *
@@ -263,45 +305,6 @@ static GBufferLine *g_undef_instruction_print(GUndefInstruction *instr, GCodeBuf
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : instr  = instruction à traiter.                              *
-*                format = format du binaire manipulé.                         *
-*                syntax = type de représentation demandée.                    *
-*                                                                             *
-*  Description : Reconstruit le cache complet d'une désignation d'instruction.*
-*                                                                             *
-*  Retour      : Mot clef de bas niveau.                                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_undef_instruction_build_keyword(const GUndefInstruction *instr, AsmSyntax syntax)
-{
-    switch (instr->status)
-    {
-        case IBS_NOP:
-            G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup("nop");
-            break;
-
-        case IBS_UNDEFINED:
-            G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup("undefined");
-            break;
-
-        case IBS_UNPREDICTABLE:
-            G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup("unpredictable");
-            break;
-
-        default:
-            assert(false);
-            break;
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : instr  = instruction à consulter.                            *
 *                                                                             *
 *  Description : Indique le type de conséquences réél de l'instruction.       *
diff --git a/tools/d2c/Makefile.am b/tools/d2c/Makefile.am
index d876ab1..53904be 100644
--- a/tools/d2c/Makefile.am
+++ b/tools/d2c/Makefile.am
@@ -30,6 +30,9 @@ d2c_SOURCES =							\
 	qckcall.h qckcall.c					\
 	spec.h spec.c
 
+# _GNU_SOURCE : asprintf
+d2c_CFLAGS = -D_GNU_SOURCE
+
 d2c_LDADD =								\
 	bits/libd2cbits.la					\
 	conv/libd2cconv.la					\
diff --git a/tools/d2c/qckcall.c b/tools/d2c/qckcall.c
index aa066c4..34c810e 100644
--- a/tools/d2c/qckcall.c
+++ b/tools/d2c/qckcall.c
@@ -34,11 +34,6 @@
 
 
 
-/* Prépare au besoin la définition d'une macro de transtypage. */
-static char *build_cast_if_needed(const char *);
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : callee = fonction appelée à nommer.                          *
@@ -51,7 +46,7 @@ static char *build_cast_if_needed(const char *);
 *                                                                             *
 ******************************************************************************/
 
-static char *build_cast_if_needed(const char *callee)
+char *build_cast_if_needed(const char *callee)
 {
     char *result;                           /* Macro à retourner           */
     regex_t preg;                           /* Expression régulière        */
diff --git a/tools/d2c/qckcall.h b/tools/d2c/qckcall.h
index 0b9ac29..0c8fcf6 100644
--- a/tools/d2c/qckcall.h
+++ b/tools/d2c/qckcall.h
@@ -35,6 +35,9 @@
 
 
 
+/* Prépare au besoin la définition d'une macro de transtypage. */
+char *build_cast_if_needed(const char *);
+
 /* Réalise un appel à une fonction liée à une instruction. */
 bool call_instr_func(bool, const char *, const arg_list_t *, int, const coding_bits *, const conv_list *, const pre_processor *);
 
diff --git a/tools/d2c/spec.c b/tools/d2c/spec.c
index 5aa7066..e6f65df 100644
--- a/tools/d2c/spec.c
+++ b/tools/d2c/spec.c
@@ -26,10 +26,12 @@
 
 #include <malloc.h>
 #include <regex.h>
+#include <stdio.h>
 #include <string.h>
 
 
 #include "helpers.h"
+#include "qckcall.h"
 
 
 
@@ -304,6 +306,8 @@ bool write_encoding_spec_disass(const encoding_spec *spec, int fd, const char *a
     char *keyword;                          /* Mot clef appelable en code  */
     bool quick_exit;                        /* Inclusion de sortie rapide ?*/
     const char *new_ins;                    /* Nouvelle définition de nom  */
+    char *encoding_fc;                      /* Spécification d'encodage    */
+    char *cast;                             /* Conversion vers le format   */
 
     result = true;
 
@@ -386,7 +390,19 @@ bool write_encoding_spec_disass(const encoding_spec *spec, int fd, const char *a
         dprintf(fd, "\n");
     }
 
-    dprintf(fd, "\t\tg_arch_instruction_set_encoding(instr, \"%s\");\n", spec->prefix);
+    /* Encodage en dernier lieu */
+
+    asprintf(&encoding_fc, "g_%s_instruction_set_encoding", arch);
+
+    cast = build_cast_if_needed(encoding_fc);
+
+    dprintf(fd, "\t\t%s(%s(instr), \"%s\");\n", encoding_fc, cast, spec->prefix);
+
+    free(cast);
+
+    free(encoding_fc);
+
+    /* Conclusion globale */
 
     dprintf(fd, "\n");