Serialize registers when needed.

13 files changed, 290 insertions, 603 deletions

diff --git a/plugins/arm/register.c b/plugins/arm/register.c
index 5d24806..6a58d59 100644
--- a/plugins/arm/register.c
+++ b/plugins/arm/register.c
@@ -46,22 +46,22 @@ static void g_arm_register_dispose(GArmRegister *);
 /* Procède à la libération totale de la mémoire. */
 static void g_arm_register_finalize(GArmRegister *);
 
-/* Produit une empreinte à partir d'un registre. */
-static guint g_arm_register_hash(const GArmRegister *);
 
-/* Compare un registre avec un autre. */
-static int g_arm_register_compare(const GArmRegister *, const GArmRegister *);
 
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* Produit une empreinte à partir d'un registre. */
+static guint g_arm_register_hash(const GArmRegister *);
 
+/* Compare un registre avec un autre. */
+static int g_arm_register_compare(const GArmRegister *, const GArmRegister *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_arm_register_unserialize(GArmRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_arm_register_load(GArmRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_arm_register_serialize(const GArmRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_arm_register_store(GArmRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -88,20 +88,21 @@ G_DEFINE_TYPE(GArmRegister, g_arm_register, G_TYPE_ARCH_REGISTER);
 
 static void g_arm_register_class_init(GArmRegisterClass *klass)
 {
-    GObjectClass *object_class;             /* Autre version de la classe  */
-    GArchRegisterClass *reg_class;          /* Classe de haut niveau       */
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchRegisterClass *reg;                /* Classe de haut niveau       */
 
-    object_class = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(klass);
 
-    object_class->dispose = (GObjectFinalizeFunc/* ! */)g_arm_register_dispose;
-    object_class->finalize = (GObjectFinalizeFunc)g_arm_register_finalize;
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_arm_register_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_arm_register_finalize;
 
-    reg_class = G_ARCH_REGISTER_CLASS(klass);
+    reg = G_ARCH_REGISTER_CLASS(klass);
 
-    reg_class->hash = (reg_hash_fc)g_arm_register_hash;
-    reg_class->compare = (reg_compare_fc)g_arm_register_compare;
-    reg_class->unserialize = (reg_unserialize_fc)g_arm_register_unserialize;
-    reg_class->serialize = (reg_serialize_fc)g_arm_register_serialize;
+    reg->hash = (reg_hash_fc)g_arm_register_hash;
+    reg->compare = (reg_compare_fc)g_arm_register_compare;
+
+    reg->load = (load_register_fc)g_arm_register_load;
+    reg->store = (store_register_fc)g_arm_register_store;
 
 }
 
@@ -181,6 +182,12 @@ uint8_t g_arm_register_get_index(const GArmRegister *reg)
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : reg = opérande à consulter pour le calcul.                   *
@@ -224,19 +231,13 @@ static int g_arm_register_compare(const GArmRegister *a, const GArmRegister *b)
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -244,24 +245,17 @@ static int g_arm_register_compare(const GArmRegister *a, const GArmRegister *b)
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_arm_register_unserialize(GArmRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arm_register_load(GArmRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
+    bool result;                            /* Bilan à retourner           */
     GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-    /**
-     * L'indice de registre est utilisé par les sous-classes pour la regénération
-     * à partir du cache.
-     *
-     * Il est donc lu depuis le tempon avant l'appel à cette fonction, et est
-     * ainsi déjà pris en compte.
-     */
-
-    result = G_ARCH_REGISTER(reg);
-
     parent = G_ARCH_REGISTER_CLASS(g_arm_register_parent_class);
 
-    result = parent->unserialize(result, storage, pbuf);
+    result = parent->load(G_ARCH_REGISTER(reg), storage, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &reg->index, sizeof(uint8_t), true);
 
     return result;
 
@@ -270,11 +264,11 @@ static GArchRegister *g_arm_register_unserialize(GArmRegister *reg, GAsmStorage
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -282,20 +276,17 @@ static GArchRegister *g_arm_register_unserialize(GArmRegister *reg, GAsmStorage
 *                                                                             *
 ******************************************************************************/
 
-static bool g_arm_register_serialize(const GArmRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arm_register_store(GArmRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-    result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint8_t), false);
-
-    if (result)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_arm_register_parent_class);
+    parent = G_ARCH_REGISTER_CLASS(g_arm_register_parent_class);
 
-        result = parent->serialize(G_ARCH_REGISTER(reg), storage, pbuf);
+    result = parent->store(G_ARCH_REGISTER(reg), storage, pbuf);
 
-    }
+    if (result)
+        result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint8_t), false);
 
     return result;
 
diff --git a/plugins/arm/v7/operands/reglist.c b/plugins/arm/v7/operands/reglist.c
index 9b9a817..2b2ee10 100644
--- a/plugins/arm/v7/operands/reglist.c
+++ b/plugins/arm/v7/operands/reglist.c
@@ -457,7 +457,7 @@ static bool g_armv7_reglist_operand_unserialize(GArmV7RegListOperand *operand, G
 
             if (result)
             {
-                reg = g_arch_register_load(storage, &reg_pbuf);
+                reg = NULL;//g_arch_register_load(storage, &reg_pbuf);
                 result = (reg != NULL);
             }
 
@@ -510,7 +510,7 @@ static bool g_armv7_reglist_operand_serialize(const GArmV7RegListOperand *operan
 
         for (i = 0; i < operand->count && result; i++)
         {
-            result = g_arch_register_store(G_ARCH_REGISTER(operand->registers[i]), storage, &reg_pbuf);
+            result = false;//g_arch_register_store(G_ARCH_REGISTER(operand->registers[i]), storage, &reg_pbuf);
 
             if (result)
                 result = g_asm_storage_store_register_data(storage, &reg_pbuf, &pos);
diff --git a/plugins/arm/v7/registers/banked.c b/plugins/arm/v7/registers/banked.c
index daeae71..d565f95 100644
--- a/plugins/arm/v7/registers/banked.c
+++ b/plugins/arm/v7/registers/banked.c
@@ -78,14 +78,6 @@ static GArchRegister *_g_armv7_banked_register_new(BankedRegisterTarget);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_armv7_banked_register_unserialize(GArmV7BankedRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */
 
 
@@ -133,7 +125,6 @@ static void g_armv7_banked_register_class_init(GArmV7BankedRegisterClass *klass)
     object_class->finalize = (GObjectFinalizeFunc)g_armv7_banked_register_finalize;
 
     reg_class->print = (reg_print_fc)g_armv7_banked_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_armv7_banked_register_unserialize;
 
 }
 
@@ -567,63 +558,6 @@ BankedRegisterTarget g_armv7_banked_register_get_target(const GArmV7BankedRegist
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GArchRegister *g_armv7_banked_register_unserialize(GArmV7BankedRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint8_t index;                          /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
-
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
-
-    if (status)
-    {
-        result = get_armv7_banked_register(index);
-
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
-
-    }
-
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
-
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_banked_register_parent_class);
-
-        result = parent->unserialize(result, storage, pbuf);
-
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
 /*                          GESTION SOUS FORME DE SINGLETONS                          */
 /* ---------------------------------------------------------------------------------- */
 
diff --git a/plugins/arm/v7/registers/basic.c b/plugins/arm/v7/registers/basic.c
index d92f74e..60ef821 100644
--- a/plugins/arm/v7/registers/basic.c
+++ b/plugins/arm/v7/registers/basic.c
@@ -75,14 +75,6 @@ static GArchRegister *_g_armv7_basic_register_new(uint8_t);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_armv7_basic_register_unserialize(GArmV7BasicRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */
 
 
@@ -130,7 +122,6 @@ static void g_armv7_basic_register_class_init(GArmV7BasicRegisterClass *klass)
     object_class->finalize = (GObjectFinalizeFunc)g_armv7_basic_register_finalize;
 
     reg_class->print = (reg_print_fc)g_armv7_basic_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_armv7_basic_register_unserialize;
 
 }
 
@@ -302,63 +293,6 @@ GArchRegister *g_armv7_basic_register_new(uint8_t index)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GArchRegister *g_armv7_basic_register_unserialize(GArmV7BasicRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint8_t index;                          /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
-
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
-
-    if (status)
-    {
-        result = get_armv7_basic_register(index);
-
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
-
-    }
-
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
-
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_basic_register_parent_class);
-
-        result = parent->unserialize(result, storage, pbuf);
-
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
 /*                          GESTION SOUS FORME DE SINGLETONS                          */
 /* ---------------------------------------------------------------------------------- */
 
diff --git a/plugins/arm/v7/registers/coproc.c b/plugins/arm/v7/registers/coproc.c
index acfbb81..3d4ee8e 100644
--- a/plugins/arm/v7/registers/coproc.c
+++ b/plugins/arm/v7/registers/coproc.c
@@ -76,14 +76,6 @@ static GArchRegister *_g_armv7_cp_register_new(uint8_t);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_armv7_cp_register_unserialize(GArmV7CpRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */
 
 
@@ -131,7 +123,6 @@ static void g_armv7_cp_register_class_init(GArmV7CpRegisterClass *klass)
     object_class->finalize = (GObjectFinalizeFunc)g_armv7_cp_register_finalize;
 
     reg_class->print = (reg_print_fc)g_armv7_cp_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_armv7_cp_register_unserialize;
 
 }
 
@@ -282,63 +273,6 @@ GArchRegister *g_armv7_cp_register_new(uint8_t index)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GArchRegister *g_armv7_cp_register_unserialize(GArmV7CpRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint8_t index;                          /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
-
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
-
-    if (status)
-    {
-        result = get_armv7_cp_register(index);
-
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
-
-    }
-
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
-
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_cp_register_parent_class);
-
-        result = parent->unserialize(result, storage, pbuf);
-
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
 /*                          GESTION SOUS FORME DE SINGLETONS                          */
 /* ---------------------------------------------------------------------------------- */
 
diff --git a/plugins/arm/v7/registers/simd.c b/plugins/arm/v7/registers/simd.c
index eedd7c8..e38de0c 100644
--- a/plugins/arm/v7/registers/simd.c
+++ b/plugins/arm/v7/registers/simd.c
@@ -70,22 +70,21 @@ static void g_armv7_simd_register_dispose(GArmV7SIMDRegister *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_simd_register_finalize(GArmV7SIMDRegister *);
 
-/* Traduit un registre en version humainement lisible. */
-static void g_armv7_simd_register_print(const GArmV7SIMDRegister *, GBufferLine *);
-
 /* Crée une réprésentation de registre SIMD ARMv7. */
 static GArchRegister *_g_armv7_simd_register_new(SIMDRegisterMapping, uint8_t);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
+/* Traduit un registre en version humainement lisible. */
+static void g_armv7_simd_register_print(const GArmV7SIMDRegister *, GBufferLine *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_armv7_simd_register_unserialize(GArmV7SIMDRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_armv7_simd_register_load(GArmV7SIMDRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_armv7_simd_register_serialize(const GArmV7SIMDRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_armv7_simd_register_store(GArmV7SIMDRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -126,20 +125,20 @@ G_DEFINE_TYPE(GArmV7SIMDRegister, g_armv7_simd_register, G_TYPE_ARMV7_REGISTER);
 
 static void g_armv7_simd_register_class_init(GArmV7SIMDRegisterClass *klass)
 {
-    GObjectClass *object_class;             /* Autre version de la classe  */
-    GArchRegisterClass *reg_class;          /* Classe de haut niveau       */
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchRegisterClass *reg;                /* Classe de haut niveau       */
 
-    object_class = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(klass);
 
-    object_class->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_simd_register_dispose;
-    object_class->finalize = (GObjectFinalizeFunc)g_armv7_simd_register_finalize;
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_simd_register_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_armv7_simd_register_finalize;
 
-    reg_class = G_ARCH_REGISTER_CLASS(klass);
+    reg = G_ARCH_REGISTER_CLASS(klass);
 
-    reg_class->print = (reg_print_fc)g_armv7_simd_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_armv7_simd_register_unserialize;
-    reg_class->serialize = (reg_serialize_fc)g_armv7_simd_register_serialize;
+    reg->print = (reg_print_fc)g_armv7_simd_register_print;
 
+    reg->load = (load_register_fc)g_armv7_simd_register_load;
+    reg->store = (store_register_fc)g_armv7_simd_register_store;
 
 }
 
@@ -202,50 +201,6 @@ static void g_armv7_simd_register_finalize(GArmV7SIMDRegister *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg  = registre à transcrire.                                *
-*                line = ligne tampon où imprimer l'opérande donné.            *
-*                                                                             *
-*  Description : Traduit un registre en version humainement lisible.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_armv7_simd_register_print(const GArmV7SIMDRegister *reg, GBufferLine *line)
-{
-    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
-    size_t klen;                            /* Taille de ce mot clef       */
-
-    switch (reg->mapping)
-    {
-        case SRM_SINGLE_WORD:
-            klen = snprintf(key, MAX_REGNAME_LEN, "s%hhu", G_ARM_REGISTER(reg)->index);
-            break;
-
-        case SRM_DOUBLE_WORD:
-            klen = snprintf(key, MAX_REGNAME_LEN, "d%hhu", G_ARM_REGISTER(reg)->index);
-            break;
-
-        case SRM_QUAD_WORD:
-            klen = snprintf(key, MAX_REGNAME_LEN, "q%hhu", G_ARM_REGISTER(reg)->index);
-            break;
-
-        default:
-            assert(false);
-            klen = snprintf(key, MAX_REGNAME_LEN, "x??");
-            break;
-
-    }
-
-    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : mapping = type de registre demandé.                          *
 *                index   = indice du registre correspondant.                  *
 *                                                                             *
@@ -328,57 +283,84 @@ GArchRegister *g_armv7_simd_register_new(SIMDRegisterMapping mapping, uint8_t in
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
 /* ---------------------------------------------------------------------------------- */
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg  = registre à transcrire.                                *
+*                line = ligne tampon où imprimer l'opérande donné.            *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Traduit un registre en version humainement lisible.          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_armv7_simd_register_unserialize(GArmV7SIMDRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static void g_armv7_simd_register_print(const GArmV7SIMDRegister *reg, GBufferLine *line)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
-    SIMDRegisterMapping mapping;            /* Type de registre            */
-    bool status;                            /* Bilan d'une extraction      */
-    uint8_t index;                          /* Indice du registre          */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
+    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
+    size_t klen;                            /* Taille de ce mot clef       */
 
-    status = extract_packed_buffer(pbuf, &mapping, sizeof(SIMDRegisterMapping), true);
+    switch (reg->mapping)
+    {
+        case SRM_SINGLE_WORD:
+            klen = snprintf(key, MAX_REGNAME_LEN, "s%hhu", G_ARM_REGISTER(reg)->index);
+            break;
 
-    if (status)
-        status = extract_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
+        case SRM_DOUBLE_WORD:
+            klen = snprintf(key, MAX_REGNAME_LEN, "d%hhu", G_ARM_REGISTER(reg)->index);
+            break;
 
-    if (status)
-    {
-        result = get_armv7_simd_register(mapping, index);
+        case SRM_QUAD_WORD:
+            klen = snprintf(key, MAX_REGNAME_LEN, "q%hhu", G_ARM_REGISTER(reg)->index);
+            break;
 
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
+        default:
+            assert(false);
+            klen = snprintf(key, MAX_REGNAME_LEN, "x??");
+            break;
 
     }
 
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
+    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
 
-    if (result != NULL)
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
+*                                                                             *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_armv7_simd_register_load(GArmV7SIMDRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *parent;             /* Classe parente à consulter  */
+    uleb128_t value;                        /* Valeur à charger            */
+
+    parent = G_ARCH_REGISTER_CLASS(g_armv7_simd_register_parent_class);
+
+    result = parent->load(G_ARCH_REGISTER(reg), storage, pbuf);
+
+    if (result)
     {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_simd_register_parent_class);
+        result = unpack_uleb128(&value, pbuf);
 
-        result = parent->unserialize(G_ARCH_REGISTER(reg), storage, pbuf);
+        if (result)
+            reg->mapping = value;
 
     }
 
@@ -389,11 +371,11 @@ static GArchRegister *g_armv7_simd_register_unserialize(GArmV7SIMDRegister *reg,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -401,20 +383,17 @@ static GArchRegister *g_armv7_simd_register_unserialize(GArmV7SIMDRegister *reg,
 *                                                                             *
 ******************************************************************************/
 
-static bool g_armv7_simd_register_serialize(const GArmV7SIMDRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_armv7_simd_register_store(GArmV7SIMDRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-    result = extend_packed_buffer(pbuf, &reg->mapping, sizeof(SIMDRegisterMapping), true);
-
-    if (result)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_simd_register_parent_class);
+    parent = G_ARCH_REGISTER_CLASS(g_armv7_simd_register_parent_class);
 
-        result = parent->serialize(G_ARCH_REGISTER(reg), storage, pbuf);
+    result = parent->store(G_ARCH_REGISTER(reg), storage, pbuf);
 
-    }
+    if (result)
+        result = pack_uleb128((uleb128_t []){ reg->mapping }, pbuf);
 
     return result;
 
diff --git a/plugins/arm/v7/registers/special.c b/plugins/arm/v7/registers/special.c
index ff46a1e..d0bfb67 100644
--- a/plugins/arm/v7/registers/special.c
+++ b/plugins/arm/v7/registers/special.c
@@ -75,14 +75,6 @@ static GArchRegister *_g_armv7_special_register_new(SpecRegTarget);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_armv7_special_register_unserialize(GArmV7SpecialRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */
 
 
@@ -130,7 +122,6 @@ static void g_armv7_special_register_class_init(GArmV7SpecialRegisterClass *klas
     object_class->finalize = (GObjectFinalizeFunc)g_armv7_special_register_finalize;
 
     reg_class->print = (reg_print_fc)g_armv7_special_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_armv7_special_register_unserialize;
 
 }
 
@@ -326,63 +317,6 @@ GArchRegister *g_armv7_special_register_new(SpecRegTarget target)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GArchRegister *g_armv7_special_register_unserialize(GArmV7SpecialRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint8_t index;                          /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
-
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
-
-    if (status)
-    {
-        result = get_armv7_special_register(index);
-
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
-
-    }
-
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
-
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_armv7_special_register_parent_class);
-
-        result = parent->unserialize(result, storage, pbuf);
-
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
 /*                          GESTION SOUS FORME DE SINGLETONS                          */
 /* ---------------------------------------------------------------------------------- */
 
diff --git a/plugins/dalvik/register.c b/plugins/dalvik/register.c
index 87babfb..b350b04 100644
--- a/plugins/dalvik/register.c
+++ b/plugins/dalvik/register.c
@@ -70,25 +70,28 @@ static void g_dalvik_register_dispose(GDalvikRegister *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_register_finalize(GDalvikRegister *);
 
-/* Produit une empreinte à partir d'un registre. */
-static guint g_dalvik_register_hash(const GDalvikRegister *);
-
-/* Traduit un registre en version humainement lisible. */
-static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *);
-
 /* Crée une réprésentation de registre Dalvik. */
 static GArchRegister *_g_dalvik_register_new(uint16_t);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Produit une empreinte à partir d'un registre. */
+static guint g_dalvik_register_hash(const GDalvikRegister *);
 
+/* Compare un registre avec un autre. */
+static int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
+
+/* Traduit un registre en version humainement lisible. */
+static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_dalvik_register_load(GDalvikRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_dalvik_register_serialize(const GDalvikRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_dalvik_register_store(GDalvikRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -130,20 +133,21 @@ G_DEFINE_TYPE(GDalvikRegister, g_dalvik_register, G_TYPE_ARCH_REGISTER);
 static void g_dalvik_register_class_init(GDalvikRegisterClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
-    GArchRegisterClass *reg_class;          /* Classe de haut niveau       */
+    GArchRegisterClass *reg;                /* Classe de haut niveau       */
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_register_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dalvik_register_finalize;
 
-    reg_class = G_ARCH_REGISTER_CLASS(klass);
+    reg = G_ARCH_REGISTER_CLASS(klass);
+
+    reg->hash = (reg_hash_fc)g_dalvik_register_hash;
+    reg->compare = (reg_compare_fc)g_dalvik_register_compare;
+    reg->print = (reg_print_fc)g_dalvik_register_print;
 
-    reg_class->hash = (reg_hash_fc)g_dalvik_register_hash;
-    reg_class->compare = (reg_compare_fc)g_dalvik_register_compare;
-    reg_class->print = (reg_print_fc)g_dalvik_register_print;
-    reg_class->unserialize = (reg_unserialize_fc)g_dalvik_register_unserialize;
-    reg_class->serialize = (reg_serialize_fc)g_dalvik_register_serialize;
+    reg->load = (load_register_fc)g_dalvik_register_load;
+    reg->store = (store_register_fc)g_dalvik_register_store;
 
 }
 
@@ -206,50 +210,6 @@ static void g_dalvik_register_finalize(GDalvikRegister *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg = opérande à consulter pour le calcul.                   *
-*                                                                             *
-*  Description : Produit une empreinte à partir d'un registre.                *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static guint g_dalvik_register_hash(const GDalvikRegister *reg)
-{
-    return reg->index;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : reg  = registre à transcrire.                                *
-*                line = ligne tampon où imprimer l'opérande donné.            *
-*                                                                             *
-*  Description : Traduit un registre en version humainement lisible.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *line)
-{
-    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
-    size_t klen;                            /* Taille de ce mot clef       */
-
-    klen = snprintf(key, MAX_REGNAME_LEN, "v%hu", reg->index);
-
-    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : index = indice du registre correspondant.                    *
 *                                                                             *
 *  Description : Crée une réprésentation de registre Dalvik.                  *
@@ -315,6 +275,31 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
 }
 
 
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg = opérande à consulter pour le calcul.                   *
+*                                                                             *
+*  Description : Produit une empreinte à partir d'un registre.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static guint g_dalvik_register_hash(const GDalvikRegister *reg)
+{
+    return reg->index;
+
+}
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
@@ -328,7 +313,7 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
+static int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
 {
     int result;                             /* Bilan à retourner           */
 
@@ -339,57 +324,56 @@ int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg  = registre à transcrire.                                *
+*                line = ligne tampon où imprimer l'opérande donné.            *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Traduit un registre en version humainement lisible.          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *line)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
-    uint16_t index;                         /* Indice du registre          */
-    bool status;                            /* Bilan d'une extraction      */
-    GArchRegisterClass *parent;             /* Classe parente à consulter  */
+    char key[MAX_REGNAME_LEN];              /* Mot clef principal          */
+    size_t klen;                            /* Taille de ce mot clef       */
 
-    status = extract_packed_buffer(pbuf, &index, sizeof(uint16_t), true);
+    klen = snprintf(key, MAX_REGNAME_LEN, "v%hu", reg->index);
 
-    if (status)
-    {
-        result = get_dalvik_register(index);
+    g_buffer_line_append_text(line, DLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
 
-        if (result == NULL)
-            g_object_unref(G_OBJECT(reg));
+}
 
-    }
 
-    else
-    {
-        g_object_unref(G_OBJECT(reg));
-        result = NULL;
-    }
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
+*                                                                             *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    if (result != NULL)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
+static bool g_dalvik_register_load(GDalvikRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-        result = parent->unserialize(result, storage, pbuf);
+    parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
 
-    }
+    result = parent->load(G_ARCH_REGISTER(reg), storage, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
 
     return result;
 
@@ -398,11 +382,11 @@ static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmSt
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -410,20 +394,17 @@ static GArchRegister *g_dalvik_register_unserialize(GDalvikRegister *reg, GAsmSt
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_register_serialize(const GDalvikRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_dalvik_register_store(GDalvikRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchRegisterClass *parent;             /* Classe parente à consulter  */
 
-    result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
+    parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
 
-    if (result)
-    {
-        parent = G_ARCH_REGISTER_CLASS(g_dalvik_register_parent_class);
+    result = parent->store(G_ARCH_REGISTER(reg), storage, pbuf);
 
-        result = parent->serialize(G_ARCH_REGISTER(reg), storage, pbuf);
-
-    }
+    if (result)
+        result = extend_packed_buffer(pbuf, &reg->index, sizeof(uint16_t), true);
 
     return result;
 
diff --git a/plugins/dalvik/register.h b/plugins/dalvik/register.h
index 586d242..8c664a5 100644
--- a/plugins/dalvik/register.h
+++ b/plugins/dalvik/register.h
@@ -60,9 +60,6 @@ GArchRegister *g_dalvik_register_new(uint16_t);
 /* Fournit l'indice d'un registre Dalvik. */
 uint16_t g_dalvik_register_get_index(const GDalvikRegister *);
 
-/* Compare un registre avec un autre. */
-int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
-
 
 
 /* ------------------------ GESTION SOUS FORME DE SINGLETONS ------------------------ */
diff --git a/src/arch/operands/register.c b/src/arch/operands/register.c
index 9c0a337..8cfe39f 100644
--- a/src/arch/operands/register.c
+++ b/src/arch/operands/register.c
@@ -338,7 +338,7 @@ static bool g_register_operand_unserialize(GRegisterOperand *operand, GAsmStorag
 
         if (result)
         {
-            reg = g_arch_register_load(storage, &reg_pbuf);
+            reg = NULL;//g_arch_register_load(storage, &reg_pbuf);
             result = (reg != NULL);
         }
 
@@ -383,7 +383,7 @@ static bool g_register_operand_serialize(const GRegisterOperand *operand, GAsmSt
     {
         init_packed_buffer(&reg_pbuf);
 
-        result = g_arch_register_store(operand->reg, storage, &reg_pbuf);
+        result = false;//g_arch_register_store(operand->reg, storage, &reg_pbuf);
 
         if (result)
             result = g_asm_storage_store_register_data(storage, &reg_pbuf, &pos);
diff --git a/src/arch/register-int.h b/src/arch/register-int.h
index a162435..4bff491 100644
--- a/src/arch/register-int.h
+++ b/src/arch/register-int.h
@@ -26,9 +26,7 @@
 
 
 #include "register.h"
-
-
-#include "operand-int.h"
+#include "../analysis/storage/storage.h"
 
 
 
@@ -47,11 +45,11 @@ typedef bool (* reg_is_base_pointer_fc) (const GArchRegister *);
 /* Indique si le registre correspond à esp ou similaire. */
 typedef bool (* reg_is_stack_pointer_fc) (const GArchRegister *);
 
-/* Charge un registre depuis une mémoire tampon. */
-typedef GArchRegister * (* reg_unserialize_fc) (GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+typedef bool (* load_register_fc) (GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-typedef bool (* reg_serialize_fc) (const GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+typedef bool (* store_register_fc) (GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 /* Représentation d'un registre (instance) */
@@ -72,8 +70,8 @@ struct _GArchRegisterClass
     reg_is_base_pointer_fc is_bp;           /* Correspondance avec ebp     */
     reg_is_stack_pointer_fc is_sp;          /* Correspondance avec esp     */
 
-    reg_unserialize_fc unserialize;         /* Chargement depuis un tampon */
-    reg_serialize_fc serialize;             /* Conservation dans un tampon */
+    load_register_fc load;                  /* Chargement depuis un tampon */
+    store_register_fc store;                /* Conservation dans un tampon */
 
 };
 
diff --git a/src/arch/register.c b/src/arch/register.c
index 740a06b..112492c 100644
--- a/src/arch/register.c
+++ b/src/arch/register.c
@@ -25,7 +25,7 @@
 
 
 #include "register-int.h"
-#include "storage.h"
+#include "../analysis/storage/serialize-int.h"
 
 
 
@@ -38,6 +38,9 @@ static void g_arch_register_class_init(GArchRegisterClass *);
 /* Initialise une instance de registre. */
 static void g_arch_register_init(GArchRegister *);
 
+/* Procède à l'initialisation de l'interface de sérialisation. */
+static void g_arch_register_serializable_init(GSerializableObjectInterface *);
+
 /* Supprime toutes les références externes. */
 static void g_arch_register_dispose(GArchRegister *);
 
@@ -46,14 +49,20 @@ static void g_arch_register_finalize(GArchRegister *);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
+/* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */
+
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool _g_arch_register_load(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Charge un registre depuis une mémoire tampon. */
-static GArchRegister *g_arch_register_unserialize(GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_arch_register_load(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un registre dans une mémoire tampon. */
-static bool g_arch_register_serialize(const GArchRegister *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool _g_arch_register_store(GArchRegister *, GObjectStorage *, packed_buffer_t *);
+
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_arch_register_store(GArchRegister *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -63,7 +72,8 @@ static bool g_arch_register_serialize(const GArchRegister *, GAsmStorage *, pack
 
 
 /* Indique le type défini pour une représentation d'un registre. */
-G_DEFINE_TYPE(GArchRegister, g_arch_register, G_TYPE_OBJECT);
+G_DEFINE_TYPE_WITH_CODE(GArchRegister, g_arch_register, G_TYPE_OBJECT,
+                        G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_arch_register_serializable_init));
 
 
 /******************************************************************************
@@ -87,8 +97,8 @@ static void g_arch_register_class_init(GArchRegisterClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_arch_register_dispose;
     object->finalize = (GObjectFinalizeFunc)g_arch_register_finalize;
 
-    klass->unserialize = (reg_unserialize_fc)g_arch_register_unserialize;
-    klass->serialize = (reg_serialize_fc)g_arch_register_serialize;
+    klass->load = (load_register_fc)_g_arch_register_load;
+    klass->store = (store_register_fc)_g_arch_register_store;
 
 }
 
@@ -113,6 +123,26 @@ static void g_arch_register_init(GArchRegister *reg)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de sérialisation.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arch_register_serializable_init(GSerializableObjectInterface *iface)
+{
+    iface->load = (load_serializable_object_cb)g_arch_register_load;
+    iface->store = (store_serializable_object_cb)g_arch_register_store;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : reg = instance d'objet GLib à traiter.                       *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
@@ -262,17 +292,17 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *reg)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES REGISTRES                       */
+/*                      CONSERVATION ET RECHARGEMENT DES DONNEES                      */
 /* ---------------------------------------------------------------------------------- */
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à constituer.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -280,11 +310,11 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-static GArchRegister *g_arch_register_unserialize(GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool _g_arch_register_load(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
+    bool result;                            /* Bilan à retourner           */
 
-    result = reg;
+    result = true;
 
     return result;
 
@@ -293,36 +323,26 @@ static GArchRegister *g_arch_register_unserialize(GArchRegister *reg, GAsmStorag
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : reg     = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un registre depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
-*  Retour      : Registre d'architecture constitué ou NULL en cas d'échec.    *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arch_register_load(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchRegister *result;                  /* Instance à retourner        */
-    GArchRegister *dummy;                   /* Patron du type de registre  */
-
-    dummy = G_ARCH_REGISTER(g_asm_storage_create_object(storage, pbuf));
-
-    if (dummy != NULL)
-    {
-        result = G_ARCH_REGISTER_GET_CLASS(dummy)->unserialize(dummy, storage, pbuf);
-
-        /* Si personne ne l'a fait avant... */
-        if (result != NULL)
-            g_object_unref(G_OBJECT(dummy));
+    bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *class;              /* Classe à activer            */
 
-    }
+    class = G_ARCH_REGISTER_GET_CLASS(reg);
 
-    else
-        result = NULL;
+    result = class->load(reg, storage, pbuf);
 
     return result;
 
@@ -331,11 +351,11 @@ GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -343,7 +363,7 @@ GArchRegister *g_arch_register_load(GAsmStorage *storage, packed_buffer_t *pbuf)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool _g_arch_register_store(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -356,11 +376,11 @@ static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *sto
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg     = registre d'architecture à consulter.               *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : reg     = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un registre dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -368,14 +388,14 @@ static bool g_arch_register_serialize(const GArchRegister *reg, GAsmStorage *sto
 *                                                                             *
 ******************************************************************************/
 
-bool g_arch_register_store(const GArchRegister *reg, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arch_register_store(GArchRegister *reg, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
+    GArchRegisterClass *class;              /* Classe à activer            */
 
-    result = g_asm_storage_store_object_gtype(storage, G_OBJECT(reg), pbuf);
+    class = G_ARCH_REGISTER_GET_CLASS(reg);
 
-    if (result)
-        result = G_ARCH_REGISTER_GET_CLASS(reg)->serialize(reg, storage, pbuf);
+    result = class->store(reg, storage, pbuf);
 
     return result;
 
diff --git a/src/arch/register.h b/src/arch/register.h
index 36bd9d9..0265a73 100644
--- a/src/arch/register.h
+++ b/src/arch/register.h
@@ -71,19 +71,4 @@ bool g_arch_register_is_stack_pointer(const GArchRegister *);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES REGISTRES --------------------- */
-
-
-/* Depuis "storage.h" : définition d'une conservation d'instructions d'assemblage (instance) */
-typedef struct _GAsmStorage GAsmStorage;
-
-
-/* Charge un registre depuis une mémoire tampon. */
-GArchRegister *g_arch_register_load(GAsmStorage *, packed_buffer_t *);
-
-/* Sauvegarde un registre dans une mémoire tampon. */
-bool g_arch_register_store(const GArchRegister *, GAsmStorage *, packed_buffer_t *);
-
-
-
 #endif  /* _ARCH_REGISTER_H */