Provide a serialization capability for operands.

16 files changed, 362 insertions, 770 deletions

diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index c4354d4..4de16d6 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -75,17 +75,6 @@ bool g_arch_instruction_store_destinations(GArchInstruction *, GObjectStorage *,
 
 
 
-/* -------------------- CONSERVATION SUR DISQUE DES INSTRUCTIONS -------------------- */
-
-
-/* Charge une instruction depuis une mémoire tampon. */
-static bool g_arch_instruction_unserialize(GArchInstruction *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde une instruction dans une mémoire tampon. */
-static bool g_arch_instruction_serialize(GArchInstruction *, GAsmStorage *, packed_buffer_t *);
-
-
-
 /* ------------------------ OFFRE DE CAPACITES DE GENERATION ------------------------ */
 
 
@@ -155,9 +144,6 @@ static void g_arch_instruction_class_init(GArchInstructionClass *klass)
 
     instr = G_ARCH_INSTRUCTION_CLASS(klass);
 
-    instr->unserialize = (unserialize_instruction_fc)g_arch_instruction_unserialize;
-    instr->serialize = (serialize_instruction_fc)g_arch_instruction_serialize;
-
     instr->print = (print_instruction_fc)_g_arch_instruction_print;
 
     instr->load = (load_instruction_fc)_g_arch_instruction_load;
@@ -1826,347 +1812,6 @@ const char *g_arch_instruction_get_description(const GArchInstruction *instr)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                      CONSERVATION SUR DISQUE DES INSTRUCTIONS                      */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge une instruction depuis une mémoire tampon.            *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_arch_instruction_unserialize(GArchInstruction *instr, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    packed_buffer_t op_pbuf;                /* Tampon des données à écrire */
-    size_t count;                           /* Nombre d'éléments à traiter */
-    size_t i;                               /* Boucle de parcours          */
-    off64_t pos;                            /* Position dans le flux       */
-    GArchOperand *op;                       /* Opérande à traiter          */
-    instr_link_t link;                      /* Lien vers une instruction   */
-    packed_buffer_t ins_pbuf;               /* Tampon des données à écrire */
-    instr_extra_data_t *extra;              /* Données insérées à consulter*/
-
-    result = unpack_mrange(&instr->range, pbuf);
-
-    if (result)
-    {
-        init_packed_buffer(&op_pbuf);
-
-        result = extract_packed_buffer(pbuf, &count, sizeof(size_t), true);
-
-        for (i = 0; i < count && result; i++)
-        {
-            result = extract_packed_buffer(pbuf, &pos, sizeof(off64_t), true);
-
-            if (result)
-                result = g_asm_storage_load_operand_data(storage, &op_pbuf, pos);
-
-            if (result)
-            {
-                op = g_arch_operand_load(storage, format, &op_pbuf);
-                result = (op != NULL);
-            }
-
-            if (result)
-                g_arch_instruction_attach_extra_operand(instr, op);
-
-        }
-
-        exit_packed_buffer(&op_pbuf);
-
-    }
-
-    bool unserialize_link(instr_link_t *lk)
-    {
-        bool status;                        /* Bilan d'une conservation    */
-        phys_t lk_phys;                     /* Position physique courante  */
-
-        status = extract_packed_buffer(pbuf, &lk_phys, sizeof(phys_t), true);
-
-        if (status)
-        {
-            lk->linked = g_asm_storage_get_instruction_at(storage, format, lk_phys, &ins_pbuf);
-            status = (lk->linked != NULL);
-        }
-
-        if (status)
-        {
-            status = extract_packed_buffer(pbuf, &lk->type, sizeof(InstructionLinkType), true);
-
-            if (!status)
-                g_object_unref(G_OBJECT(lk->linked));
-
-        }
-
-        return status;
-
-    }
-
-    if (result)
-    {
-        init_packed_buffer(&ins_pbuf);
-
-        result = extract_packed_buffer(pbuf, &count, sizeof(size_t), true);
-
-        for (i = 0; i < count && result; i++)
-        {
-            result = unserialize_link(&link);
-
-            if (result)
-            {
-                g_arch_instruction_link_with(instr, link.linked, link.type);
-                g_object_unref(G_OBJECT(link.linked));
-            }
-
-        }
-
-        exit_packed_buffer(&ins_pbuf);
-
-    }
-
-    if (result)
-    {
-        extra = GET_ARCH_INSTR_EXTRA(instr);
-
-        LOCK_GOBJECT_EXTRA(extra);
-
-        result = extract_packed_buffer(pbuf, &extra->uid, sizeof(itid_t), true);
-
-        if (result)
-            result = extract_packed_buffer(pbuf, &extra->flags, sizeof(ArchInstrFlag), true);
-
-        UNLOCK_GOBJECT_EXTRA(extra);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge une instruction depuis une mémoire tampon.            *
-*                                                                             *
-*  Retour      : Instruction d'assemblage constitué ou NULL en cas d'échec.   *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GArchInstruction *g_arch_instruction_load__old(GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
-{
-    GArchInstruction *result;               /* Instance à retourner        */
-    bool status;                            /* Bilan du chargement         */
-
-    result = G_ARCH_INSTRUCTION(g_asm_storage_create_object(storage, pbuf));
-
-    if (result != NULL)
-    {
-        status = G_ARCH_INSTRUCTION_GET_CLASS(result)->unserialize(result, storage, format, pbuf);
-
-        if (!status)
-        {
-            g_object_unref(G_OBJECT(result));
-            result = NULL;
-        }
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Sauvegarde une instruction dans une mémoire tampon.          *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_arch_instruction_serialize(GArchInstruction *instr, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    packed_buffer_t op_pbuf;                /* Tampon des données à écrire */
-    size_t count;                           /* Nombre d'éléments à traiter */
-    size_t i;                               /* Boucle de parcours          */
-    GArchOperand *op;                       /* Opérande à traiter          */
-    off64_t pos;                            /* Position dans le flux       */
-    size_t kept;                            /* Nombre de liens conservés   */
-    const instr_link_t *link;               /* Lien vers une instruction   */
-    instr_extra_data_t *extra;              /* Données insérées à consulter*/
-
-    result = pack_mrange(&instr->range, pbuf);
-
-    if (result)
-    {
-        init_packed_buffer(&op_pbuf);
-
-        g_arch_instruction_lock_operands(instr);
-
-        count = _g_arch_instruction_count_operands(instr);
-
-        result = extend_packed_buffer(pbuf, &count, sizeof(size_t), true);
-
-        for (i = 0; i < count && result; i++)
-        {
-            op = _g_arch_instruction_get_operand(instr, i);
-
-            result = g_arch_operand_store(op, storage, &op_pbuf);
-
-            if (result)
-                result = g_asm_storage_store_operand_data(storage, &op_pbuf, &pos);
-
-            if (result)
-                result = extend_packed_buffer(pbuf, &pos, sizeof(off64_t), true);
-
-            g_object_unref(G_OBJECT(op));
-
-        }
-
-        g_arch_instruction_unlock_operands(instr);
-
-        exit_packed_buffer(&op_pbuf);
-
-    }
-
-    bool serialize_link(const instr_link_t *lk)
-    {
-        bool status;                        /* Bilan d'une conservation    */
-        const mrange_t *range;              /* Emplacement d'une instruct° */
-        phys_t lk_phys;                     /* Position physique courante  */
-
-        if (lk->type == ILT_REF)
-            status = true;
-
-        else
-        {
-            range = g_arch_instruction_get_range(lk->linked);
-
-            lk_phys = get_phy_addr(get_mrange_addr(range));
-
-            status = extend_packed_buffer(pbuf, &lk_phys, sizeof(phys_t), true);
-
-            if (status)
-                status = extend_packed_buffer(pbuf, &lk->type, sizeof(InstructionLinkType), true);
-
-        }
-
-        return status;
-
-    }
-
-    if (result)
-    {
-        g_arch_instruction_lock_dest(instr);
-
-        count = g_arch_instruction_count_destinations(instr);
-
-        /**
-         * Le type de lien ILT_REF n'est mis en place que lors de la création
-         * d'opérandes de type G_TYPE_TARGET_OPERAND, et sera donc remis en place
-         * dynamiquement lors de la restauration de ces derniers.
-         */
-
-        kept = 0;
-
-        for (i = 0; i < count && result; i++)
-        {
-            link = g_arch_instruction_get_destination(instr, i);
-
-            if (link->type != ILT_REF)
-                kept++;
-
-            unref_instr_link(link);
-
-        }
-
-        result = extend_packed_buffer(pbuf, &kept, sizeof(size_t), true);
-
-        for (i = 0; i < count && result; i++)
-        {
-            link = g_arch_instruction_get_destination(instr, i);
-            result = serialize_link(link);
-            unref_instr_link(link);
-        }
-
-        g_arch_instruction_unlock_dest(instr);
-
-    }
-
-    if (result)
-    {
-        extra = GET_ARCH_INSTR_EXTRA(instr);
-
-        LOCK_GOBJECT_EXTRA(extra);
-
-        result = extend_packed_buffer(pbuf, &extra->uid, sizeof(itid_t), true);
-
-        if (result)
-            result = extend_packed_buffer(pbuf, &extra->flags, sizeof(ArchInstrFlag), true);
-
-        UNLOCK_GOBJECT_EXTRA(extra);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Sauvegarde une instruction dans une mémoire tampon.          *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_arch_instruction_store__old(GArchInstruction *instr, GAsmStorage *storage, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-
-    result = g_asm_storage_store_object_gtype(storage, G_OBJECT(instr), pbuf);
-
-    if (result)
-        result = G_ARCH_INSTRUCTION_GET_CLASS(instr)->serialize(instr, storage, pbuf);
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
 /*                          OFFRE DE CAPACITES DE GENERATION                          */
 /* ---------------------------------------------------------------------------------- */
 
@@ -2393,18 +2038,23 @@ static bool _g_arch_instruction_load(GArchInstruction *instr, GObjectStorage *st
     LOCK_GOBJECT_EXTRA(extra);
 
     result = unpack_uleb128(&value, pbuf);
-    if (!result) goto exit;
 
-    extra->uid = value;
+    if (result)
+        extra->uid = value;
 
-    result = unpack_uleb128(&value, pbuf);
-    if (!result) goto exit;
+    if (result)
+    {
+        result = unpack_uleb128(&value, pbuf);
 
-    extra->flags = value;
+        if (result)
+            extra->flags = value;
+
+    }
 
     UNLOCK_GOBJECT_EXTRA(extra);
 
-    result = unpack_mrange(&instr->range, pbuf);
+    if (result)
+        result = unpack_mrange(&instr->range, pbuf);
 
     if (result)
     {
@@ -2425,8 +2075,6 @@ static bool _g_arch_instruction_load(GArchInstruction *instr, GObjectStorage *st
     if (result)
         result = g_arch_instruction_load_destinations(instr, storage, pbuf);
 
- exit:
-
     return result;
 
 }
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index 683adfb..26eadc9 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -310,19 +310,4 @@ const char *g_arch_instruction_get_description(const GArchInstruction *);
 
 
 
-/* -------------------- CONSERVATION SUR DISQUE DES INSTRUCTIONS -------------------- */
-
-
-/* Depuis "storage.h" : définition d'une conservation d'instructions d'assemblage (instance) */
-typedef struct _GAsmStorage GAsmStorage;
-
-
-/* Charge une instruction depuis une mémoire tampon. */
-GArchInstruction *g_arch_instruction_load__old(GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde une instruction dans une mémoire tampon. */
-bool g_arch_instruction_store__old(GArchInstruction *, GAsmStorage *, packed_buffer_t *);
-
-
-
 #endif  /* _ARCH_INSTRUCTION_H */
diff --git a/src/arch/operand-int.h b/src/arch/operand-int.h
index c348654..d2f43f1 100644
--- a/src/arch/operand-int.h
+++ b/src/arch/operand-int.h
@@ -26,6 +26,7 @@
 
 
 #include "operand.h"
+#include "../analysis/storage/storage.h"
 #include "../glibext/objhole.h"
 
 
@@ -54,11 +55,11 @@ typedef void (* operand_update_inners_fc) (GArchOperand *, GArchOperand **, size
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 typedef guint (* operand_hash_fc) (const GArchOperand *, bool);
 
-/* Charge un opérande depuis une mémoire tampon. */
-typedef bool (* unserialize_operand_fc) (GArchOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+typedef bool (* load_operand_fc) (GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un opérande dans une mémoire tampon. */
-typedef bool (* serialize_operand_fc) (const GArchOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+typedef bool (* store_operand_fc) (GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 /* Informations glissées dans la structure GObject de GArchOperand */
@@ -113,8 +114,8 @@ struct _GArchOperandClass
     operand_update_inners_fc update_inner;  /* Mise à jour des éléments    */
     operand_hash_fc hash;                   /* Prise d'empreinte           */
 
-    unserialize_operand_fc unserialize;     /* Chargement depuis un tampon */
-    serialize_operand_fc serialize;         /* Conservation dans un tampon */
+    load_operand_fc load;                   /* Chargement depuis un tampon */
+    store_operand_fc store;                 /* Conservation dans un tampon */
 
 };
 
diff --git a/src/arch/operand.c b/src/arch/operand.c
index 944c34e..e95f24e 100644
--- a/src/arch/operand.c
+++ b/src/arch/operand.c
@@ -31,6 +31,7 @@
 
 #include "operand-int.h"
 #include "storage.h"
+#include "../analysis/storage/serialize-int.h"
 #include "../common/fnv1a.h"
 #include "../common/sort.h"
 #include "../core/logs.h"
@@ -48,7 +49,10 @@ static void g_arch_operand_class_init(GArchOperandClass *);
 static void g_arch_operand_init(GArchOperand *);
 
 /* Procède à l'initialisation de l'interface de singleton. */
-static void g_arch_operand_singleton_interface_init(GSingletonCandidateInterface *);
+static void g_arch_operand_singleton_init(GSingletonCandidateInterface *);
+
+/* Procède à l'initialisation de l'interface de sérialisation. */
+static void g_arch_operand_serializable_init(GSerializableObjectInterface *);
 
 /* Supprime toutes les références externes. */
 static void g_arch_operand_dispose(GArchOperand *);
@@ -87,14 +91,20 @@ static bool g_arch_operand_is_read_only(GArchOperand *);
 
 
 
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
+/* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */
+
+
+/* Charge un contenu depuis une mémoire tampon. */
+static bool _g_arch_operand_load(GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_arch_operand_load(GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_arch_operand_unserialize(GArchOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool _g_arch_operand_store(GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_arch_operand_serialize(const GArchOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_arch_operand_store(GArchOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -105,7 +115,8 @@ static bool g_arch_operand_serialize(const GArchOperand *, GAsmStorage *, packed
 
 /* Indique le type défini pour un opérande d'architecture. */
 G_DEFINE_TYPE_WITH_CODE(GArchOperand, g_arch_operand, G_TYPE_OBJECT,
-                        G_IMPLEMENT_INTERFACE(G_TYPE_SINGLETON_CANDIDATE, g_arch_operand_singleton_interface_init));
+                        G_IMPLEMENT_INTERFACE(G_TYPE_SINGLETON_CANDIDATE, g_arch_operand_singleton_init)
+                        G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_arch_operand_serializable_init));
 
 
 /******************************************************************************
@@ -136,8 +147,8 @@ static void g_arch_operand_class_init(GArchOperandClass *klass)
 
     operand->hash = _g_arch_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_arch_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_arch_operand_serialize;
+    operand->load = (load_operand_fc)_g_arch_operand_load;
+    operand->store = (store_operand_fc)_g_arch_operand_store;
 
 }
 
@@ -177,7 +188,7 @@ static void g_arch_operand_init(GArchOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static void g_arch_operand_singleton_interface_init(GSingletonCandidateInterface *iface)
+static void g_arch_operand_singleton_init(GSingletonCandidateInterface *iface)
 {
     iface->list_inner = (list_inner_instances_fc)g_arch_operand_list_inner_instances;
     iface->update_inner = (update_inner_instances_fc)g_arch_operand_update_inner_instances;
@@ -193,6 +204,26 @@ static void g_arch_operand_singleton_interface_init(GSingletonCandidateInterface
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de sérialisation.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_arch_operand_serializable_init(GSerializableObjectInterface *iface)
+{
+    iface->load = (load_serializable_object_cb)g_arch_operand_load;
+    iface->store = (store_serializable_object_cb)g_arch_operand_store;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = instance d'objet GLib à traiter.                   *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
@@ -746,18 +777,17 @@ static bool g_arch_operand_is_read_only(GArchOperand *operand)
 
 
 /* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
+/*                      CONSERVATION ET RECHARGEMENT DES DONNEES                      */
 /* ---------------------------------------------------------------------------------- */
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -765,11 +795,22 @@ static bool g_arch_operand_is_read_only(GArchOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_arch_operand_unserialize(GArchOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool _g_arch_operand_load(GArchOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
+    operand_extra_data_t *extra;            /* Données insérées à consulter*/
+    uleb128_t value;                        /* Valeur ULEB128 à charger    */
+
+    extra = GET_ARCH_OP_EXTRA(operand);
 
-    result = true;
+    LOCK_GOBJECT_EXTRA(extra);
+
+    result = unpack_uleb128(&value, pbuf);
+
+    if (result)
+        extra->flags = value;
+
+    UNLOCK_GOBJECT_EXTRA(extra);
 
     return result;
 
@@ -778,36 +819,26 @@ static bool g_arch_operand_unserialize(GArchOperand *operand, GAsmStorage *stora
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
-*  Retour      : Opérande d'assemblage constitué ou NULL en cas d'échec.      *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_arch_operand_load(GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_arch_operand_load(GArchOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
-    GArchOperand *result;                   /* Instance à retourner        */
-    bool status;                            /* Bilan du chargement         */
-
-    result = G_ARCH_OPERAND(g_asm_storage_create_object(storage, pbuf));
-
-    if (result != NULL)
-    {
-        status = G_ARCH_OPERAND_GET_CLASS(result)->unserialize(result, storage, format, pbuf);
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *class;               /* Classe à activer            */
 
-        if (!status)
-        {
-            g_object_unref(G_OBJECT(result));
-            result = NULL;
-        }
+    class = G_ARCH_OPERAND_GET_CLASS(operand);
 
-    }
+    result = class->load(operand, storage, pbuf);
 
     return result;
 
@@ -816,11 +847,11 @@ GArchOperand *g_arch_operand_load(GAsmStorage *storage, GBinFormat *format, pack
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -828,11 +859,18 @@ GArchOperand *g_arch_operand_load(GAsmStorage *storage, GBinFormat *format, pack
 *                                                                             *
 ******************************************************************************/
 
-static bool g_arch_operand_serialize(const GArchOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool _g_arch_operand_store(GArchOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
+    operand_extra_data_t *extra;            /* Données insérées à consulter*/
 
-    result = true;
+    extra = GET_ARCH_OP_EXTRA(operand);
+
+    LOCK_GOBJECT_EXTRA(extra);
+
+    result = pack_uleb128((uleb128_t []){ extra->flags }, pbuf);
+
+    UNLOCK_GOBJECT_EXTRA(extra);
 
     return result;
 
@@ -841,11 +879,11 @@ static bool g_arch_operand_serialize(const GArchOperand *operand, GAsmStorage *s
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = instruction d'assemblage à consulter.              *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -853,14 +891,14 @@ static bool g_arch_operand_serialize(const GArchOperand *operand, GAsmStorage *s
 *                                                                             *
 ******************************************************************************/
 
-bool g_arch_operand_store(const GArchOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_arch_operand_store(GArchOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *class;               /* Classe à activer            */
 
-    result = g_asm_storage_store_object_gtype(storage, G_OBJECT(operand), pbuf);
+    class = G_ARCH_OPERAND_GET_CLASS(operand);
 
-    if (result)
-        result = G_ARCH_OPERAND_GET_CLASS(operand)->serialize(operand, storage, pbuf);
+    result = class->store(operand, storage, pbuf);
 
     return result;
 
diff --git a/src/arch/operand.h b/src/arch/operand.h
index f8d2536..a93e898 100644
--- a/src/arch/operand.h
+++ b/src/arch/operand.h
@@ -112,12 +112,5 @@ ArchOperandFlag g_arch_operand_get_flags(const GArchOperand *);
 typedef struct _GAsmStorage GAsmStorage;
 
 
-/* Charge un opérande depuis une mémoire tampon. */
-GArchOperand *g_arch_operand_load(GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un opérande dans une mémoire tampon. */
-bool g_arch_operand_store(const GArchOperand *, GAsmStorage *, packed_buffer_t *);
-
-
 
 #endif  /* _ARCH_OPERAND_H */
diff --git a/src/arch/operands/feeder-int.h b/src/arch/operands/feeder-int.h
index 86bc98f..f2f2566 100644
--- a/src/arch/operands/feeder-int.h
+++ b/src/arch/operands/feeder-int.h
@@ -28,6 +28,9 @@
 #include "feeder.h"
 
 
+#include "../../analysis/storage/serialize-int.h"
+
+
 
 /* Compare un fournisseur avec un autre. */
 typedef int (* compare_proxy_operand_fc) (const GProxyFeeder *, const GProxyFeeder *);
@@ -35,26 +38,17 @@ typedef int (* compare_proxy_operand_fc) (const GProxyFeeder *, const GProxyFeed
 /* Traduit un fournisseur en version humainement lisible. */
 typedef void (* print_proxy_feeder_fc) (const GProxyFeeder *, GBufferLine *);
 
-/* Charge un fournisseur depuis une mémoire tampon. */
-typedef bool (* unserialize_proxy_feeder_fc) (GProxyFeeder *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un fournisseur dans une mémoire tampon. */
-typedef bool (* serialize_proxy_feeder_fc) (const GProxyFeeder *, packed_buffer_t *);
-
 
 
 /* Fournisseur d'élément non architectural (interface) */
 struct _GProxyFeederIface
 {
-    GTypeInterface base_iface;              /* A laisser en premier        */
+    GSerializableObjectInterface base_iface;/* A laisser en premier        */
 
     compare_proxy_operand_fc compare;       /* Comparaison entre éléments  */
 
     print_proxy_feeder_fc print;            /* Affichage sur une ligne     */
 
-    unserialize_proxy_feeder_fc unserialize;/* Restauration de l'élément   */
-    serialize_proxy_feeder_fc serialize;    /* Sauvegarder de l'élément    */
-
 };
 
 
diff --git a/src/arch/operands/feeder.c b/src/arch/operands/feeder.c
index f34475c..af23fea 100644
--- a/src/arch/operands/feeder.c
+++ b/src/arch/operands/feeder.c
@@ -28,13 +28,32 @@
 
 
 
+/* -------------------- DEFINITION DE L'INTERFACE DE FOURNISSEUR -------------------- */
+
+
 /* Procède à l'initialisation de l'interface de rassemblement. */
 static void g_proxy_feeder_default_init(GProxyFeederInterface *);
 
 
 
+/* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */
+
+
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_proxy_feeder_load(GProxyFeeder *, GObjectStorage *, packed_buffer_t *);
+
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_proxy_feeder_store(GProxyFeeder *, GObjectStorage *, packed_buffer_t *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                      DEFINITION DE L'INTERFACE DE FOURNISSEUR                      */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Détermine le type d'une interface pour la Fourniture d'éléments non architecturaux. */
-G_DEFINE_INTERFACE(GProxyFeeder, g_proxy_feeder, G_TYPE_OBJECT)
+G_DEFINE_INTERFACE(GProxyFeeder, g_proxy_feeder, G_TYPE_SERIALIZABLE_OBJECT)
 
 
 /******************************************************************************
@@ -104,58 +123,3 @@ void g_proxy_feeder_print(const GProxyFeeder *feeder, GBufferLine *line)
     iface->print(feeder, line);
 
 }
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : feeder = fournisseur à constituer.                           *
-*                format = format binaire chargé associé à l'architecture.     *
-*                pbuf   = zone tampon à remplir.                              *
-*                                                                             *
-*  Description : Charge un fournisseur depuis une mémoire tampon.             *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_proxy_feeder_unserialize(GProxyFeeder *feeder, GBinFormat *format, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    GProxyFeederIface *iface;               /* Interface utilisée          */
-
-    iface = G_PROXY_FEEDER_GET_IFACE(feeder);
-
-    result = iface->unserialize(feeder, format, pbuf);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : feeder = fournisseur à consulter.                            *
-*                pbuf   = zone tampon à remplir.                              *
-*                                                                             *
-*  Description : Sauvegarde un fournisseur dans une mémoire tampon.           *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_proxy_feeder_serialize(const GProxyFeeder *feeder, packed_buffer_t *pbuf)
-{
-    bool result;                            /* Bilan à retourner           */
-    GProxyFeederIface *iface;               /* Interface utilisée          */
-
-    iface = G_PROXY_FEEDER_GET_IFACE(feeder);
-
-    result = iface->serialize(feeder, pbuf);
-
-    return result;
-
-}
diff --git a/src/arch/operands/feeder.h b/src/arch/operands/feeder.h
index 2d8559e..685323b 100644
--- a/src/arch/operands/feeder.h
+++ b/src/arch/operands/feeder.h
@@ -26,11 +26,8 @@
 
 
 #include <glib-object.h>
-#include <stdbool.h>
 
 
-#include "../../common/packed.h"
-#include "../../format/format.h"
 #include "../../glibext/bufferline.h"
 
 
@@ -59,12 +56,6 @@ int g_proxy_feeder_compare(const GProxyFeeder *, const GProxyFeeder *);
 /* Traduit un fournisseur en version humainement lisible. */
 void g_proxy_feeder_print(const GProxyFeeder *, GBufferLine *);
 
-/* Charge un fournisseur depuis une mémoire tampon. */
-bool g_proxy_feeder_unserialize(GProxyFeeder *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un fournisseur dans une mémoire tampon. */
-bool g_proxy_feeder_serialize(const GProxyFeeder *, packed_buffer_t *);
-
 
 
 #endif  /* _ARCH_OPERANDS_FEEDER_H */
diff --git a/src/arch/operands/immediate.c b/src/arch/operands/immediate.c
index 00bfe99..0df8bbb 100644
--- a/src/arch/operands/immediate.c
+++ b/src/arch/operands/immediate.c
@@ -88,11 +88,11 @@ static char *g_imm_operand_build_tooltip(const GImmOperand *, const GLoadedBinar
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 static guint g_imm_operand_hash(const GImmOperand *, bool);
 
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_imm_operand_unserialize(GImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_imm_operand_load(GImmOperand *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_imm_operand_serialize(const GImmOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_imm_operand_store(GImmOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -152,8 +152,8 @@ static void g_imm_operand_class_init(GImmOperandClass *klass)
 
     operand->hash = (operand_hash_fc)g_imm_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_imm_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_imm_operand_serialize;
+    operand->load = (load_operand_fc)g_imm_operand_load;
+    operand->store = (store_operand_fc)g_imm_operand_store;
 
 }
 
@@ -1354,12 +1354,11 @@ static guint g_imm_operand_hash(const GImmOperand *operand, bool lock)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -1367,19 +1366,17 @@ static guint g_imm_operand_hash(const GImmOperand *operand, bool lock)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_imm_operand_unserialize(GImmOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_imm_operand_load(GImmOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
     immop_extra_data_t *extra;              /* Données insérées à modifier */
+    uleb128_t value;                        /* Valeur ULEB128 à charger    */
     uint8_t val;                            /* Champ de bits manipulé      */
 
     parent = G_ARCH_OPERAND_CLASS(g_imm_operand_parent_class);
 
-    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
-
-    if (result)
-        result = extract_packed_buffer(pbuf, &operand->raw, sizeof(uint64_t), true);
+    result = parent->load(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
     {
@@ -1387,24 +1384,36 @@ static bool g_imm_operand_unserialize(GImmOperand *operand, GAsmStorage *storage
 
         LOCK_GOBJECT_EXTRA(extra);
 
-        result = extract_packed_buffer(pbuf, &extra->size, sizeof(MemoryDataSize), true);
+        result = unpack_uleb128(&value, pbuf);
+
+        if (result)
+            extra->size = value;
 
         if (result)
         {
             result = extract_packed_buffer(pbuf, &val, sizeof(uint8_t), false);
-            extra->def_display = val;
+
+            if (result)
+                extra->def_display = val;
+
         }
 
         if (result)
         {
             result = extract_packed_buffer(pbuf, &val, sizeof(uint8_t), false);
-            extra->display = val;
+
+            if (result)
+                extra->display = val;
+
         }
 
         UNLOCK_GOBJECT_EXTRA(extra);
 
     }
 
+    if (result)
+        result = extract_packed_buffer(pbuf, &operand->raw, sizeof(uint64_t), true);
+
     return result;
 
 }
@@ -1412,11 +1421,11 @@ static bool g_imm_operand_unserialize(GImmOperand *operand, GAsmStorage *storage
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -1424,7 +1433,7 @@ static bool g_imm_operand_unserialize(GImmOperand *operand, GAsmStorage *storage
 *                                                                             *
 ******************************************************************************/
 
-static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_imm_operand_store(GImmOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
@@ -1432,10 +1441,7 @@ static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *sto
 
     parent = G_ARCH_OPERAND_CLASS(g_imm_operand_parent_class);
 
-    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
-
-    if (result)
-        result = extend_packed_buffer(pbuf, &operand->raw, sizeof(uint64_t), true);
+    result = parent->store(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
     {
@@ -1443,7 +1449,7 @@ static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *sto
 
         LOCK_GOBJECT_EXTRA(extra);
 
-        result = extend_packed_buffer(pbuf, &extra->size, sizeof(MemoryDataSize), true);
+        result = pack_uleb128((uleb128_t []){ extra->size }, pbuf);
 
         if (result)
             result = extend_packed_buffer(pbuf, (uint8_t []) { extra->def_display }, sizeof(uint8_t), false);
@@ -1455,6 +1461,9 @@ static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *sto
 
     }
 
+    if (result)
+        result = extend_packed_buffer(pbuf, &operand->raw, sizeof(uint64_t), true);
+
     return result;
 
 }
diff --git a/src/arch/operands/known.c b/src/arch/operands/known.c
index bf16674..a4b3844 100644
--- a/src/arch/operands/known.c
+++ b/src/arch/operands/known.c
@@ -31,6 +31,7 @@
 
 #include "immediate-int.h"
 #include "rename-int.h"
+#include "../../analysis/db/misc/rlestr.h"
 #include "../../core/logs.h"
 #include "../../gtkext/gtkblockdisplay.h"
 
@@ -85,11 +86,11 @@ static void g_known_imm_operand_print(const GKnownImmOperand *, GBufferLine *);
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 static guint g_known_imm_operand_hash(const GKnownImmOperand *, bool);
 
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_known_imm_operand_unserialize(GKnownImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_known_imm_operand_load(GKnownImmOperand *, GObjectStorage *, packed_buffer_t *);
 
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_known_imm_operand_serialize(const GKnownImmOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_known_imm_operand_store(GKnownImmOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -139,8 +140,8 @@ static void g_known_imm_operand_class_init(GKnownImmOperandClass *klass)
 
     operand->hash = (operand_hash_fc)g_known_imm_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_known_imm_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_known_imm_operand_serialize;
+    operand->load = (load_operand_fc)g_known_imm_operand_load;
+    operand->store = (store_operand_fc)g_known_imm_operand_store;
 
 }
 
@@ -386,12 +387,11 @@ static guint g_known_imm_operand_hash(const GKnownImmOperand *operand, bool lock
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -399,27 +399,30 @@ static guint g_known_imm_operand_hash(const GKnownImmOperand *operand, bool lock
 *                                                                             *
 ******************************************************************************/
 
-static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_known_imm_operand_load(GKnownImmOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
-    unsigned short len;                     /* Taille du contenu alternatif*/
+    rle_string str;                         /* Chaîne à charger            */
 
     parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
 
-    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+    result = parent->load(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
-        result = extract_packed_buffer(pbuf, &len, sizeof(unsigned short), true);
+    {
+        setup_empty_rle_string(&str);
 
-    if (result)
-        result = (len > 0);
+        result = unpack_rle_string(&str, pbuf);
 
-    if (result)
-    {
-        operand->alt_text = malloc(len);
+        if (result)
+        {
+            if (get_rle_string(&str) != NULL)
+                operand->alt_text = strdup(get_rle_string(&str));
 
-        result = extract_packed_buffer(pbuf, operand->alt_text, len, false);
+            exit_rle_string(&str);
+
+        }
 
     }
 
@@ -430,11 +433,11 @@ static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStora
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -442,33 +445,23 @@ static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStora
 *                                                                             *
 ******************************************************************************/
 
-static bool g_known_imm_operand_serialize(const GKnownImmOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_known_imm_operand_store(GKnownImmOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
-    size_t len;                             /* Taille du contenu alternatif*/
+    rle_string str;                         /* Chaîne à conserver          */
 
     parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
 
-    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+    result = parent->store(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
     {
-        len = strlen(operand->alt_text) + 1;
-        assert(len > 1);
-
-        if (len > (2 << (sizeof(unsigned short) * 8 - 1)))
-        {
-            log_variadic_message(LMT_ERROR, "Alternative text too long: '%s' (%zu bytes)",
-                                 operand->alt_text, len);
-            result = false;
-        }
+        init_static_rle_string(&str, operand->alt_text);
 
-        else
-            result = extend_packed_buffer(pbuf, (unsigned short []) { len }, sizeof(unsigned short), true);
+        result = pack_rle_string(&str, pbuf);
 
-        if (result)
-            result = extend_packed_buffer(pbuf, operand->alt_text, len, false);
+        exit_rle_string(&str);
 
     }
 
diff --git a/src/arch/operands/proxy.c b/src/arch/operands/proxy.c
index 992c481..91690a7 100644
--- a/src/arch/operands/proxy.c
+++ b/src/arch/operands/proxy.c
@@ -43,6 +43,11 @@ static void g_proxy_operand_dispose(GProxyOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_proxy_operand_finalize(GProxyOperand *);
 
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
 /* Compare un opérande avec un autre. */
 static int g_proxy_operand_compare(const GProxyOperand *, const GProxyOperand *, bool);
 
@@ -52,16 +57,11 @@ static void g_proxy_operand_print(const GProxyOperand *, GBufferLine *);
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 static guint g_proxy_operand_hash(const GProxyOperand *, bool);
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_proxy_operand_load(GProxyOperand *, GObjectStorage *, packed_buffer_t *);
 
-
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
-
-
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_proxy_operand_unserialize(GProxyOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_proxy_operand_serialize(const GProxyOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_proxy_operand_store(GProxyOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -103,8 +103,8 @@ static void g_proxy_operand_class_init(GProxyOperandClass *klass)
 
     operand->hash = (operand_hash_fc)g_proxy_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_proxy_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_proxy_operand_serialize;
+    operand->load = (load_operand_fc)g_proxy_operand_load;
+    operand->store = (store_operand_fc)g_proxy_operand_store;
 
 }
 
@@ -195,6 +195,37 @@ GArchOperand *g_proxy_operand_new(GProxyFeeder *feeder)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : operand = opérande à consulter.                              *
+*                                                                             *
+*  Description : Fournit le fournisseur représenté par l'opérande.            *
+*                                                                             *
+*  Retour      : Fournisseur associé à l'opérande.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GProxyFeeder *g_proxy_operand_get_feeder(const GProxyOperand *operand)
+{
+    GProxyFeeder *result;                   /* Instance à retourner        */
+
+    result = operand->feeder;
+
+    g_object_ref(G_OBJECT(result));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : a    = premier opérande à consulter.                         *
 *                b    = second opérande à consulter.                          *
 *                lock = précise le besoin en verrouillage.                    *
@@ -301,43 +332,11 @@ static guint g_proxy_operand_hash(const GProxyOperand *operand, bool lock)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande à consulter.                              *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Fournit le fournisseur représenté par l'opérande.            *
-*                                                                             *
-*  Retour      : Fournisseur associé à l'opérande.                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GProxyFeeder *g_proxy_operand_get_feeder(const GProxyOperand *operand)
-{
-    GProxyFeeder *result;                   /* Instance à retourner        */
-
-    result = operand->feeder;
-
-    g_object_ref(G_OBJECT(result));
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
-*                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -345,17 +344,26 @@ GProxyFeeder *g_proxy_operand_get_feeder(const GProxyOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_proxy_operand_unserialize(GProxyOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_proxy_operand_load(GProxyOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
+    GSerializableObject *feeder;            /* Fournisseur manipulé        */
 
     parent = G_ARCH_OPERAND_CLASS(g_proxy_operand_parent_class);
 
-    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+    result = parent->load(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
-        result = g_proxy_feeder_unserialize(operand->feeder, format, pbuf);
+    {
+        feeder = g_object_storage_unpack_object(storage, "operands", pbuf);
+
+        result = (feeder != NULL);
+
+        if (result)
+            operand->feeder = G_PROXY_FEEDER(feeder);
+
+    }
 
     return result;
 
@@ -364,11 +372,11 @@ static bool g_proxy_operand_unserialize(GProxyOperand *operand, GAsmStorage *sto
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -376,17 +384,21 @@ static bool g_proxy_operand_unserialize(GProxyOperand *operand, GAsmStorage *sto
 *                                                                             *
 ******************************************************************************/
 
-static bool g_proxy_operand_serialize(const GProxyOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_proxy_operand_store(GProxyOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
-    GArchOperandClass *parent;              /* Classe parente à consulter  */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */ 
+    GSerializableObject *feeder;            /* Fournisseur manipulé        */
 
     parent = G_ARCH_OPERAND_CLASS(g_proxy_operand_parent_class);
 
-    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+    result = parent->store(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
-        result = g_proxy_feeder_serialize(operand->feeder, pbuf);
+    {
+        feeder = G_SERIALIZABLE_OBJECT(operand->feeder);
+        result = g_object_storage_pack_object(storage, "operands", feeder, pbuf);
+    }
 
     return result;
 
diff --git a/src/arch/operands/register.c b/src/arch/operands/register.c
index 8cfe39f..4615a99 100644
--- a/src/arch/operands/register.c
+++ b/src/arch/operands/register.c
@@ -47,30 +47,25 @@ static void g_register_operand_dispose(GRegisterOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_register_operand_finalize(GRegisterOperand *);
 
-/* Compare un opérande avec un autre. */
-static int g_register_operand_compare(const GRegisterOperand *, const GRegisterOperand *, bool);
 
-/* Traduit un opérande en version humainement lisible. */
-static void g_register_operand_print(const GRegisterOperand *, GBufferLine *);
 
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
 
 
-/* ------------------------ CONTROLE DU VOLUME DES INSTANCES ------------------------ */
+/* Compare un opérande avec un autre. */
+static int g_register_operand_compare(const GRegisterOperand *, const GRegisterOperand *, bool);
 
+/* Traduit un opérande en version humainement lisible. */
+static void g_register_operand_print(const GRegisterOperand *, GBufferLine *);
 
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 static guint g_register_operand_hash(const GRegisterOperand *, bool);
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_register_operand_load(GRegisterOperand *, GObjectStorage *, packed_buffer_t *);
 
-
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
-
-
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_register_operand_unserialize(GRegisterOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_register_operand_serialize(const GRegisterOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_register_operand_store(GRegisterOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -113,8 +108,8 @@ static void g_register_operand_class_init(GRegisterOperandClass *klass)
 
     operand->hash = (operand_hash_fc)g_register_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_register_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_register_operand_serialize;
+    operand->load = (load_operand_fc)g_register_operand_load;
+    operand->store = (store_operand_fc)g_register_operand_store;
 
 }
 
@@ -180,6 +175,37 @@ static void g_register_operand_finalize(GRegisterOperand *operand)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : operand = opérande représentant un registre.                 *
+*                                                                             *
+*  Description : Fournit le registre associé à l'opérande.                    *
+*                                                                             *
+*  Retour      : Représentation interne du registre.                          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchRegister *g_register_operand_get_register(const GRegisterOperand *operand)
+{
+    GArchRegister *result;                  /* Instance à retourner        */
+
+    result = operand->reg;
+
+    g_object_ref(G_OBJECT(result));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : a    = premier opérande à consulter.                         *
 *                b    = second opérande à consulter.                          *
 *                lock = précise le besoin en verrouillage.                    *
@@ -232,37 +258,6 @@ static void g_register_operand_print(const GRegisterOperand *operand, GBufferLin
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande représentant un registre.                 *
-*                                                                             *
-*  Description : Fournit le registre associé à l'opérande.                    *
-*                                                                             *
-*  Retour      : Représentation interne du registre.                          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GArchRegister *g_register_operand_get_register(const GRegisterOperand *operand)
-{
-    GArchRegister *result;                  /* Instance à retourner        */
-
-    result = operand->reg;
-
-    g_object_ref(G_OBJECT(result));
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          CONTROLE DU VOLUME DES INSTANCES                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : operand = objet dont l'instance se veut unique.              *
 *                lock    = précise le besoin en verrouillage.                 *
 *                                                                             *
@@ -294,20 +289,13 @@ static guint g_register_operand_hash(const GRegisterOperand *operand, bool lock)
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -315,37 +303,24 @@ static guint g_register_operand_hash(const GRegisterOperand *operand, bool lock)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_register_operand_unserialize(GRegisterOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_register_operand_load(GRegisterOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
-    off64_t pos;                            /* Position dans le flux       */
-    packed_buffer_t reg_pbuf;               /* Tampon des données à écrire */
-    GArchRegister *reg;                     /* Registre restauré           */
+    GSerializableObject *reg;               /* Registre manipulé           */
 
     parent = G_ARCH_OPERAND_CLASS(g_register_operand_parent_class);
 
-    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
-
-    if (result)
-        result = extract_packed_buffer(pbuf, &pos, sizeof(off64_t), true);
+    result = parent->load(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
     {
-        init_packed_buffer(&reg_pbuf);
+        reg = g_object_storage_unpack_object(storage, "registers", pbuf);
 
-        result = g_asm_storage_load_register_data(storage, &reg_pbuf, pos);
+        result = (reg != NULL);
 
         if (result)
-        {
-            reg = NULL;//g_arch_register_load(storage, &reg_pbuf);
-            result = (reg != NULL);
-        }
-
-        if (result)
-            operand->reg = reg;
-
-        exit_packed_buffer(&reg_pbuf);
+            operand->reg = G_ARCH_REGISTER(reg);
 
     }
 
@@ -356,11 +331,11 @@ static bool g_register_operand_unserialize(GRegisterOperand *operand, GAsmStorag
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -368,31 +343,20 @@ static bool g_register_operand_unserialize(GRegisterOperand *operand, GAsmStorag
 *                                                                             *
 ******************************************************************************/
 
-static bool g_register_operand_serialize(const GRegisterOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_register_operand_store(GRegisterOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
-    GArchOperandClass *parent;              /* Classe parente à consulter  */
-    off64_t pos;                            /* Position dans le flux       */
-    packed_buffer_t reg_pbuf;               /* Tampon des données à écrire */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */ 
+    GSerializableObject *reg;               /* Registre manipulé           */
 
     parent = G_ARCH_OPERAND_CLASS(g_register_operand_parent_class);
 
-    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+    result = parent->store(G_ARCH_OPERAND(operand), storage, pbuf);
 
     if (result)
     {
-        init_packed_buffer(&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);
-
-        if (result)
-            result = extend_packed_buffer(pbuf, &pos, sizeof(off64_t), true);
-
-        exit_packed_buffer(&reg_pbuf);
-
+        reg = G_SERIALIZABLE_OBJECT(operand->reg);
+        result = g_object_storage_pack_object(storage, "registers", reg, pbuf);
     }
 
     return result;
diff --git a/src/arch/operands/target.c b/src/arch/operands/target.c
index 6450834..068d060 100644
--- a/src/arch/operands/target.c
+++ b/src/arch/operands/target.c
@@ -45,6 +45,9 @@
 
 
 
+/* ------------------------- POINTAGE D'UN SYMBOLE EXISTANT ------------------------- */
+
+
 /* Initialise la classe des opérandes ciblant des symboles. */
 static void g_target_operand_class_init(GTargetOperandClass *);
 
@@ -60,6 +63,11 @@ static void g_target_operand_dispose(GTargetOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_target_operand_finalize(GTargetOperand *);
 
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
 /* Compare un opérande avec un autre. */
 static int g_target_operand_compare(const GTargetOperand *, const GTargetOperand *, bool);
 
@@ -72,16 +80,11 @@ static char *g_target_operand_build_tooltip(const GTargetOperand *, const GLoade
 /* Fournit l'empreinte d'un candidat à une centralisation. */
 static guint g_target_operand_hash(const GTargetOperand *, bool);
 
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_target_operand_load(GTargetOperand *, GObjectStorage *, packed_buffer_t *);
 
-
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
-
-
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_target_operand_unserialize(GTargetOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_target_operand_serialize(const GTargetOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_target_operand_store(GTargetOperand *, GObjectStorage *, packed_buffer_t *);
 
 
 
@@ -93,6 +96,11 @@ static bool g_target_operand_get_addr(const GTargetOperand *, const vmpa2t *, GB
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                           POINTAGE D'UN SYMBOLE EXISTANT                           */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini pour un opérande de valeur numérique. */
 G_DEFINE_TYPE_WITH_CODE(GTargetOperand, g_target_operand, G_TYPE_ARCH_OPERAND,
                         G_IMPLEMENT_INTERFACE(G_TYPE_TARGETABLE_OPERAND, g_target_operand_targetable_interface_init));
@@ -128,8 +136,8 @@ static void g_target_operand_class_init(GTargetOperandClass *klass)
 
     operand->hash = (operand_hash_fc)g_target_operand_hash;
 
-    operand->unserialize = (unserialize_operand_fc)g_target_operand_unserialize;
-    operand->serialize = (serialize_operand_fc)g_target_operand_serialize;
+    operand->load = (load_operand_fc)g_target_operand_load;
+    operand->store = (store_operand_fc)g_target_operand_store;
 
 }
 
@@ -636,20 +644,13 @@ static guint g_target_operand_hash(const GTargetOperand *operand, bool lock)
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à constituer.                *
-*                storage = mécanisme de sauvegarde à manipuler.               *
-*                format  = format binaire chargé associé à l'architecture.    *
-*                pbuf    = zone tampon à remplir.                             *
+*  Paramètres  : operand = élément GLib à constuire.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
+*                pbuf    = zone tampon à lire.                                *
 *                                                                             *
-*  Description : Charge un opérande depuis une mémoire tampon.                *
+*  Description : Charge un contenu depuis une mémoire tampon.                 *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -657,7 +658,7 @@ static guint g_target_operand_hash(const GTargetOperand *operand, bool lock)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_target_operand_unserialize(GTargetOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_target_operand_load(GTargetOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -684,11 +685,11 @@ static bool g_target_operand_unserialize(GTargetOperand *operand, GAsmStorage *s
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
-*                storage = mécanisme de sauvegarde à manipuler.               *
+*  Paramètres  : operand = élément GLib à consulter.                          *
+*                storage = conservateur de données à manipuler ou NULL.       *
 *                pbuf    = zone tampon à remplir.                             *
 *                                                                             *
-*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*  Description : Sauvegarde un contenu dans une mémoire tampon.               *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -696,7 +697,7 @@ static bool g_target_operand_unserialize(GTargetOperand *operand, GAsmStorage *s
 *                                                                             *
 ******************************************************************************/
 
-static bool g_target_operand_serialize(const GTargetOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_target_operand_store(GTargetOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
 {
     bool result;                            /* Bilan à retourner           */
     MemoryDataSize size;                    /* Taille retenue              */
@@ -714,7 +715,7 @@ static bool g_target_operand_serialize(const GTargetOperand *operand, GAsmStorag
     else
         original = g_imm_operand_new_from_value(size, get_phy_addr(&operand->addr));
 
-    result = g_arch_operand_store(original, storage, pbuf);
+    result = g_object_storage_pack_object(storage, "operands", G_SERIALIZABLE_OBJECT(original), pbuf);
 
     g_object_unref(G_OBJECT(original));
 
diff --git a/src/arch/register-int.h b/src/arch/register-int.h
index 4bff491..f0b9af9 100644
--- a/src/arch/register-int.h
+++ b/src/arch/register-int.h
@@ -26,7 +26,7 @@
 
 
 #include "register.h"
-#include "../analysis/storage/storage.h"
+#include "../analysis/storage/serialize-int.h"
 
 
 
diff --git a/src/arch/register.c b/src/arch/register.c
index 112492c..f487419 100644
--- a/src/arch/register.c
+++ b/src/arch/register.c
@@ -25,7 +25,6 @@
 
 
 #include "register-int.h"
-#include "../analysis/storage/serialize-int.h"
 
 
 
diff --git a/src/arch/storage.c b/src/arch/storage.c
index d552ae3..73521df 100644
--- a/src/arch/storage.c
+++ b/src/arch/storage.c
@@ -486,7 +486,7 @@ static void g_ins_caching_process_store(GInsCaching *caching, GtkStatusStack *st
 
         instr = g_arch_processor_get_instruction(proc, i);
 
-        caching->status = g_arch_instruction_store__old(instr, storage, &pbuf);
+        caching->status = false;//g_arch_instruction_store__old(instr, storage, &pbuf);
 
         if (caching->status)
             caching->status = g_asm_storage_store_instruction_data(storage, &pbuf, &pos);
@@ -1544,7 +1544,7 @@ GArchInstruction *g_asm_storage_get_instruction_at(GAsmStorage *storage, GBinFor
                 status = g_asm_storage_load_instruction_data(storage, pbuf, target);
 
             if (status)
-                storage->collected[index] = g_arch_instruction_load__old(storage, format, pbuf);
+                storage->collected[index] = NULL;//g_arch_instruction_load__old(storage, format, pbuf);
 
             if (storage->collected[index] != NULL)
             {