Removed the too complex memory share system.

11 files changed, 26 insertions, 838 deletions

diff --git a/src/arch/dalvik/core.c b/src/arch/dalvik/core.c
index 15095a6..acf6ff5 100644
--- a/src/arch/dalvik/core.c
+++ b/src/arch/dalvik/core.c
@@ -24,12 +24,6 @@
 #include "core.h"
 
 
-#include "register.h"
-#include "operands/args.h"
-#include "operands/pool.h"
-#include "operands/register.h"
-
-
 
 /******************************************************************************
 *                                                                             *
@@ -49,12 +43,6 @@ bool init_dalvik_core(void)
 
     result = true;
 
-    result &= init_dalvik_register_sharing();
-
-    result &= init_dalvik_args_operand_sharing();
-    result &= init_dalvik_pool_operand_sharing();
-    result &= init_dalvik_register_operand_sharing();
-
     return result;
 
 }
@@ -64,30 +52,6 @@ bool init_dalvik_core(void)
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_share_stats(void)
-{
-    dump_dalvik_register_share_stats();
-
-    dump_dalvik_args_operand_share_stats();
-    dump_dalvik_pool_operand_share_stats();
-    dump_dalvik_register_operand_share_stats();
-
-}
-#endif
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
 *  Description : Supprime les mécanismes internes de l'architecture Dalvik.   *
 *                                                                             *
 *  Retour      : -                                                            *
@@ -98,10 +62,5 @@ void dump_dalvik_share_stats(void)
 
 void exit_dalvik_core(void)
 {
-    exit_dalvik_register_sharing();
-
-    exit_dalvik_args_operand_sharing();
-    exit_dalvik_pool_operand_sharing();
-    exit_dalvik_register_operand_sharing();
 
 }
diff --git a/src/arch/dalvik/core.h b/src/arch/dalvik/core.h
index 8dd21dc..f22d0ea 100644
--- a/src/arch/dalvik/core.h
+++ b/src/arch/dalvik/core.h
@@ -32,11 +32,6 @@
 /* Met en place les mécanismes internes de l'architecture. */
 bool init_dalvik_core(void);
 
-/* Imprime des statistiques quant aux partages dans l'archi. */
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_share_stats(void);
-#endif
-
 /* Supprime les mécanismes internes de l'architecture Dalvik. */
 void exit_dalvik_core(void);
 
diff --git a/src/arch/dalvik/operand.c b/src/arch/dalvik/operand.c
index 88dbc6e..e37a0bb 100644
--- a/src/arch/dalvik/operand.c
+++ b/src/arch/dalvik/operand.c
@@ -480,7 +480,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, GDexFormat *form
         op = g_dalvik_register_operand_new(content, pos, low, MDS_4_BITS, endian);
         if (op == NULL) goto err_registers;
 
-        args = G_ARCH_OPERAND(g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op, NULL));
+        g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op);
 
     }
 
@@ -493,7 +493,7 @@ static bool dalvik_read_fixed_operands(GArchInstruction *instr, GDexFormat *form
     /* Rajout des éléments finaux déjà chargés */
 
     if (a == 5)
-        args = G_ARCH_OPERAND(g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), opg, NULL));
+        g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), opg);
 
     else
     {
@@ -573,7 +573,7 @@ static bool dalvik_read_variatic_operands(GArchInstruction *instr, GDexFormat *f
         op = g_dalvik_register_operand_new_from_existing(g_dalvik_register_new(c + i));
         if (op == NULL) goto drvo_registers;
 
-        args = G_ARCH_OPERAND(g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op, NULL));
+        g_dalvik_args_operand_add(G_DALVIK_ARGS_OPERAND(args), op);
 
     }
 
diff --git a/src/arch/dalvik/operands/args.c b/src/arch/dalvik/operands/args.c
index 2092e6b..f33f887 100644
--- a/src/arch/dalvik/operands/args.c
+++ b/src/arch/dalvik/operands/args.c
@@ -29,14 +29,10 @@
 
 
 #include "../../operand-int.h"
-#include "../../sharing/manager.h"
 #include "../../../common/sort.h"
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 /* Définition d'un opérande visant une liste d'opérandes Dalvik (instance) */
 struct _GDalvikArgsOperand
 {
@@ -68,15 +64,6 @@ static void g_dalvik_args_operand_dispose(GDalvikArgsOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *);
 
-/* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *, const GDalvikArgsOperand *);
-
-/* Réalise une copie minimale d'un contenu partagé. */
-static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
-
-/* Libère la mémoire utilisée par un patron d'instance. */
-static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
-
 /* Compare un opérande avec un autre. */
 static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
 
@@ -85,23 +72,6 @@ static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Gestionnaire des partages d'instances */
-static GShareManager *_dalvik_args_operand_manager = NULL;
-
-
-/* Fournit le gestionnaire de partages attribué à un type. */
-static GShareManager *get_dalvik_args_operand_share_manager(void);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /* Indique le type défini par la GLib pour une liste d'arguments Dalvik. */
 G_DEFINE_TYPE(GDalvikArgsOperand, g_dalvik_args_operand, G_TYPE_ARCH_OPERAND);
 
@@ -129,12 +99,6 @@ static void g_dalvik_args_operand_class_init(GDalvikArgsOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_args_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dalvik_args_operand_finalize;
 
-    operand->get_manager = (get_operand_manager_fc)get_dalvik_args_operand_share_manager;
-
-    operand->apply_template = (apply_operand_template_fc)g_dalvik_args_operand_apply_template;
-    operand->define_template = (define_operand_template_fc)g_dalvik_args_operand_define_template;
-    operand->free_template = (free_operand_template_fc)g_dalvik_args_operand_free_template;
-
     operand->compare = (operand_compare_fc)g_dalvik_args_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_args_operand_print;
 
@@ -204,101 +168,6 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand  = objet partagé à initialiser.                      *
-*                template = information à utiliser pour la mise en place.     *
-*                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *operand, const GDalvikArgsOperand *template)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    if (template == NULL)
-    {
-        operand->args = NULL;
-        operand->count = 0;
-    }
-
-    else
-    {
-        g_dalvik_args_operand_define_template(template, operand);
-
-        for (i = 0; i < operand->count; i++)
-            g_object_ref(G_OBJECT(operand->args[i]));
-
-    }
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand  = objet partagé à consulter.                        *
-*                template = informations à retrouver intégralement.           *
-*                                                                             *
-*  Description : Réalise une copie minimale d'un contenu partagé.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    if (operand->count == 0)
-    {
-        template->args = NULL;
-        template->count = 0;
-    }
-
-    else
-    {
-        template->args = (GArchOperand **)calloc(operand->count, sizeof(GArchOperand *));
-
-        for (i = 0; i < operand->count; i++)
-            template->args[i] = operand->args[i];
-
-        template->count = operand->count;
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand  = objet partagé à consulter.                        *
-*                template = informations dont le contenu est à libérer.       *
-*                                                                             *
-*  Description : Libère la mémoire utilisée par un patron d'instance.         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
-{
-    if (template != NULL && template->args != NULL)
-        free(template->args);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -389,7 +258,7 @@ GArchOperand *g_dalvik_args_operand_new(void)
 {
     GArchOperand *result;                   /* Structure à retourner       */
 
-    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_args_operand_manager, NULL));
+    result = g_object_new(G_TYPE_DALVIK_ARGS_OPERAND, NULL);
 
     return result;
 
@@ -409,26 +278,13 @@ GArchOperand *g_dalvik_args_operand_new(void)
 *                                                                             *
 ******************************************************************************/
 
-GDalvikArgsOperand *g_dalvik_args_operand_add(GDalvikArgsOperand *operand, GArchOperand *arg, GShareContainer *container)
+void g_dalvik_args_operand_add(GDalvikArgsOperand *operand, GArchOperand *arg)
 {
-    GSharedInstance *result;                /* Nouvelle version à renvoyer */
-    GDalvikArgsOperand fake;                /* Transport d'informations    */
-    size_t i;                               /* Boucle de parcours          */
-
-    fake.count = operand->count + 1;
-    fake.args = (GArchOperand **)calloc(fake.count, sizeof(GArchOperand *));
-
-    for (i = 0; i < operand->count; i++)
-        fake.args[i] = operand->args[i];
-
-    fake.args[i] = arg;
 
-    result = g_share_manager_update(_dalvik_args_operand_manager, G_SHARED_INSTANCE(operand),
-                                    (GSharedInstance *)&fake, container);
+    operand->count++;
+    operand->args = (GArchOperand **)realloc(operand->args, operand->count * sizeof(GArchOperand *));
 
-    free(fake.args);
-
-    return G_DALVIK_ARGS_OPERAND(result);
+    operand->args[operand->count - 1] = arg;
 
 }
 
@@ -472,88 +328,3 @@ GArchOperand *g_dalvik_args_operand_get(const GDalvikArgsOperand *operand, size_
     return operand->args[index];
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                            PARTAGES DE CONTENUS UNIQUES                            */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Fournit le gestionnaire de partages attribué à un type.      *
-*                                                                             *
-*  Retour      : Gestionnaire de partages en place.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GShareManager *get_dalvik_args_operand_share_manager(void)
-{
-    return _dalvik_args_operand_manager;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool init_dalvik_args_operand_sharing(void)
-{
-    _dalvik_args_operand_manager = g_share_manager_new(G_TYPE_DALVIK_ARGS_OPERAND);
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_args_operand_share_stats(void)
-{
-    g_share_manager_dump_stats(_dalvik_args_operand_manager);
-
-}
-#endif
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Supprime les mécanismes de partage des opérandes Dalvik.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void exit_dalvik_args_operand_sharing(void)
-{
-    g_object_unref(G_OBJECT(_dalvik_args_operand_manager));
-
-}
diff --git a/src/arch/dalvik/operands/args.h b/src/arch/dalvik/operands/args.h
index b4f5e69..993e551 100644
--- a/src/arch/dalvik/operands/args.h
+++ b/src/arch/dalvik/operands/args.h
@@ -29,13 +29,9 @@
 
 
 #include "../../operand.h"
-#include "../../sharing/container.h"
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 #define G_TYPE_DALVIK_ARGS_OPERAND                  g_dalvik_args_operand_get_type()
 #define G_DALVIK_ARGS_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dalvik_args_operand_get_type(), GDalvikArgsOperand))
 #define G_IS_DALVIK_ARGS_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dalvik_args_operand_get_type()))
@@ -58,7 +54,7 @@ GType g_dalvik_args_operand_get_type(void);
 GArchOperand *g_dalvik_args_operand_new(void);
 
 /* Ajoute un élément à la liste d'arguments Dalvik. */
-GDalvikArgsOperand *g_dalvik_args_operand_add(GDalvikArgsOperand *, GArchOperand *, GShareContainer *);
+void g_dalvik_args_operand_add(GDalvikArgsOperand *, GArchOperand *);
 
 /* Fournit le nombre d'arguments pris en charge. */
 size_t g_dalvik_args_count(const GDalvikArgsOperand *);
@@ -68,20 +64,4 @@ GArchOperand *g_dalvik_args_operand_get(const GDalvikArgsOperand *, size_t);
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Met en place les mécanismes de partage des opérandes Dalvik. */
-bool init_dalvik_args_operand_sharing(void);
-
-/* Imprime des statistiques quant aux partages dans l'archi. */
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_args_operand_share_stats(void);
-#endif
-
-/* Supprime les mécanismes de partage des opérandes Dalvik. */
-void exit_dalvik_args_operand_sharing(void);
-
-
-
 #endif  /* _ARCH_DALVIK_OPERANDS_ARGS_H */
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index d97c93b..055f58e 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -32,15 +32,11 @@
 
 
 #include "../../operand-int.h"
-#include "../../sharing/manager.h"
 #include "../../../common/sort.h"
 #include "../../../format/dex/pool.h"
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 /* Définition d'un opérande visant un élément de table de constantes Dalvik (instance) */
 struct _GDalvikPoolOperand
 {
@@ -73,12 +69,6 @@ static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *);
 
-/* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *, const GDalvikPoolOperand *);
-
-/* Réalise une copie minimale d'un contenu partagé. */
-static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *, GDalvikPoolOperand *);
-
 /* Compare un opérande avec un autre. */
 static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
 
@@ -87,23 +77,6 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Gestionnaire des partages d'instances */
-static GShareManager *_dalvik_pool_operand_manager = NULL;
-
-
-/* Fournit le gestionnaire de partages attribué à un type. */
-static GShareManager *get_dalvik_pool_operand_share_manager(void);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /* Indique le type défini par la GLib pour un un élément de table de constantes Dalvik. */
 G_DEFINE_TYPE(GDalvikPoolOperand, g_dalvik_pool_operand, G_TYPE_ARCH_OPERAND);
 
@@ -132,12 +105,6 @@ static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *klass)
 
     operand = G_ARCH_OPERAND_CLASS(klass);
 
-    operand->get_manager = (get_operand_manager_fc)get_dalvik_pool_operand_share_manager;
-
-    operand->apply_template = (apply_operand_template_fc)g_dalvik_pool_operand_apply_template;
-    operand->define_template = (define_operand_template_fc)g_dalvik_pool_operand_define_template;
-    operand->free_template = (free_operand_template_fc)NULL;
-
     operand->compare = (operand_compare_fc)g_dalvik_pool_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_pool_operand_print;
 
@@ -204,53 +171,6 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand  = objet partagé à initialiser.                      *
-*                template = information à utiliser pour la mise en place.     *
-*                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *operand, const GDalvikPoolOperand *template)
-{
-    g_dalvik_pool_operand_define_template(template, operand);
-
-    g_object_ref(G_OBJECT(operand->format));
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand  = objet partagé à consulter.                        *
-*                template = informations à retrouver intégralement.           *
-*                                                                             *
-*  Description : Réalise une copie minimale d'un contenu partagé.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *operand, GDalvikPoolOperand *template)
-{
-    template->format = operand->format;
-
-    template->type = operand->type;
-    template->index = operand->index;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -459,13 +379,10 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
 
 GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
 {
-    GArchOperand *result;                   /* Structure à retourner       */
+    GDalvikPoolOperand *result;             /* Structure à retourner       */
     uint8_t index8;                         /* Indice sur 8 bits           */
     uint16_t index16;                       /* Indice sur 16 bits          */
     bool test;                              /* Bilan de lecture            */
-    GDalvikPoolOperand fake;                /* Transport d'informations    */
-
-    result = NULL;
 
     switch (size)
     {
@@ -483,15 +400,17 @@ GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type,
     if (!test)
         goto gdpon_exit;
 
-    fake.format = format;
-    fake.type = type;
-    fake.index = (size == MDS_8_BITS ? index8 : index16);
+    result = g_object_new(G_TYPE_DALVIK_POOL_OPERAND, NULL);
+
+    result->format = format;
+    result->type = type;
+    result->index = (size == MDS_8_BITS ? index8 : index16);
 
-    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
+    return G_ARCH_OPERAND(result);
 
  gdpon_exit:
 
-    return result;
+    return NULL;
 
 }
 
@@ -532,88 +451,3 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
     return operand->index;
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                            PARTAGES DE CONTENUS UNIQUES                            */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Fournit le gestionnaire de partages attribué à un type.      *
-*                                                                             *
-*  Retour      : Gestionnaire de partages en place.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GShareManager *get_dalvik_pool_operand_share_manager(void)
-{
-    return _dalvik_pool_operand_manager;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool init_dalvik_pool_operand_sharing(void)
-{
-    _dalvik_pool_operand_manager = g_share_manager_new(G_TYPE_DALVIK_POOL_OPERAND);
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_pool_operand_share_stats(void)
-{
-    g_share_manager_dump_stats(_dalvik_pool_operand_manager);
-
-}
-#endif
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Supprime les mécanismes de partage des opérandes Dalvik.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void exit_dalvik_pool_operand_sharing(void)
-{
-    g_object_unref(G_OBJECT(_dalvik_pool_operand_manager));
-
-}
diff --git a/src/arch/dalvik/operands/pool.h b/src/arch/dalvik/operands/pool.h
index f382128..3319f66 100644
--- a/src/arch/dalvik/operands/pool.h
+++ b/src/arch/dalvik/operands/pool.h
@@ -35,9 +35,6 @@
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 #define G_TYPE_DALVIK_POOL_OPERAND            g_dalvik_pool_operand_get_type()
 #define G_DALVIK_POOL_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DALVIK_POOL_OPERAND, GDalvikPoolOperand))
 #define G_IS_DALVIK_POOL_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DALVIK_POOL_OPERAND))
@@ -80,20 +77,4 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *);
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Met en place les mécanismes de partage des opérandes Dalvik. */
-bool init_dalvik_pool_operand_sharing(void);
-
-/* Imprime des statistiques quant aux partages dans l'archi. */
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_pool_operand_share_stats(void);
-#endif
-
-/* Supprime les mécanismes de partage des opérandes Dalvik. */
-void exit_dalvik_pool_operand_sharing(void);
-
-
-
 #endif  /* _ARCH_DALVIK_OPERANDS_POOL_H */
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index cf29455..1516e8e 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -26,13 +26,9 @@
 
 #include "../../operand-int.h"
 #include "../../register.h"
-#include "../../sharing/manager.h"
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 /* Définition d'un opérande visant un registre Dalvik (instance) */
 struct _GDalvikRegisterOperand
 {
@@ -64,12 +60,6 @@ static void g_dalvik_register_operand_dispose(GDalvikRegisterOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *);
 
-/* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
-
-/* Réalise une copie minimale d'un contenu partagé. */
-static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *, GDalvikRegisterOperand *);
-
 /* Compare un opérande avec un autre. */
 static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
 
@@ -78,23 +68,6 @@ static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBuf
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Gestionnaire des partages d'instances */
-static GShareManager *_dalvik_register_operand_manager = NULL;
-
-
-/* Fournit le gestionnaire de partages attribué à un type. */
-static GShareManager *get_dalvik_register_operand_share_manager(void);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /* Indique le type défini par la GLib pour un opérande de registre Dalvik. */
 G_DEFINE_TYPE(GDalvikRegisterOperand, g_dalvik_register_operand, G_TYPE_ARCH_OPERAND);
 
@@ -123,12 +96,6 @@ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *kl
 
     operand = G_ARCH_OPERAND_CLASS(klass);
 
-    operand->get_manager = (get_operand_manager_fc)get_dalvik_register_operand_share_manager;
-
-    operand->apply_template = (apply_operand_template_fc)g_dalvik_register_operand_apply_template;
-    operand->define_template = (define_operand_template_fc)g_dalvik_register_operand_define_template;
-    operand->free_template = (free_operand_template_fc)NULL;
-
     operand->compare = (operand_compare_fc)g_dalvik_register_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_register_operand_print;
 
@@ -194,50 +161,6 @@ static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand  = objet partagé à initialiser.                      *
-*                template = information à utiliser pour la mise en place.     *
-*                                                                             *
-*  Description : Initialise un nouvel objet partagé avec des informations.    *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *template)
-{
-    g_dalvik_register_operand_define_template(template, operand);
-
-    g_object_ref(G_OBJECT(operand->reg));
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : operand  = objet partagé à consulter.                        *
-*                template = informations à retrouver intégralement.           *
-*                                                                             *
-*  Description : Réalise une copie minimale d'un contenu partagé.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *operand, GDalvikRegisterOperand *template)
-{
-    template->reg = operand->reg;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -349,9 +272,11 @@ GArchOperand *g_dalvik_register_operand_new(const GBinContent *content, vmpa2t *
 
     }
 
+    return result;
+
  gdron_exit:
 
-    return result;
+    return NULL;
 
 }
 
@@ -370,14 +295,13 @@ GArchOperand *g_dalvik_register_operand_new(const GBinContent *content, vmpa2t *
 
 GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
 {
-    GArchOperand *result;                   /* Structure à retourner       */
-    GDalvikRegisterOperand fake;            /* Transport d'informations    */
+    GDalvikRegisterOperand *result;         /* Structure à retourner       */
 
-    fake.reg = reg;
+    result = g_object_new(G_TYPE_DALVIK_REGISTER_OPERAND, NULL);
 
-    result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
+    result->reg = reg;
 
-    return result;
+    return G_ARCH_OPERAND(result);
 
 }
 
@@ -437,88 +361,3 @@ bool g_dalvik_register_operand_is_written(const GDalvikRegisterOperand *operand)
     return operand->is_written;
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                            PARTAGES DE CONTENUS UNIQUES                            */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Fournit le gestionnaire de partages attribué à un type.      *
-*                                                                             *
-*  Retour      : Gestionnaire de partages en place.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GShareManager *get_dalvik_register_operand_share_manager(void)
-{
-    return _dalvik_register_operand_manager;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Met en place les mécanismes de partage des opérandes Dalvik. *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool init_dalvik_register_operand_sharing(void)
-{
-    _dalvik_register_operand_manager = g_share_manager_new(G_TYPE_DALVIK_REGISTER_OPERAND);
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_register_operand_share_stats(void)
-{
-    g_share_manager_dump_stats(_dalvik_register_operand_manager);
-
-}
-#endif
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Supprime les mécanismes de partage des opérandes Dalvik.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void exit_dalvik_register_operand_sharing(void)
-{
-    g_object_unref(G_OBJECT(_dalvik_register_operand_manager));
-
-}
diff --git a/src/arch/dalvik/operands/register.h b/src/arch/dalvik/operands/register.h
index eeb7697..5798e5c 100644
--- a/src/arch/dalvik/operands/register.h
+++ b/src/arch/dalvik/operands/register.h
@@ -35,9 +35,6 @@
 
 
 
-/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
-
-
 #define G_TYPE_DALVIK_REGISTER_OPERAND            g_dalvik_register_operand_get_type()
 #define G_DALVIK_REGISTER_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DALVIK_REGISTER_OPERAND, GDalvikRegisterOperand))
 #define G_IS_DALVIK_REGISTER_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DALVIK_REGISTER_OPERAND))
@@ -73,20 +70,4 @@ bool g_dalvik_register_operand_is_written(const GDalvikRegisterOperand *);
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Met en place les mécanismes de partage des opérandes Dalvik. */
-bool init_dalvik_register_operand_sharing(void);
-
-/* Imprime des statistiques quant aux partages dans l'archi. */
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_register_operand_share_stats(void);
-#endif
-
-/* Supprime les mécanismes de partage des opérandes Dalvik. */
-void exit_dalvik_register_operand_sharing(void);
-
-
-
 #endif  /* _ARCH_DALVIK_OPERANDS_REGISTER_H */
diff --git a/src/arch/dalvik/register.c b/src/arch/dalvik/register.c
index 2b5a285..068b925 100644
--- a/src/arch/dalvik/register.c
+++ b/src/arch/dalvik/register.c
@@ -28,14 +28,10 @@
 
 
 #include "../register-int.h"
-#include "../sharing/manager.h"
 #include "../../common/sort.h"
 
 
 
-/* ------------------------- ENCADREMENT DE REGISTRES BRUTS ------------------------- */
-
-
 /* Représentation d'un registre Dalvik (instance) */
 struct _GDalvikRegister
 {
@@ -69,9 +65,6 @@ static void g_dalvik_register_dispose(GDalvikRegister *);
 /* Procède à la libération totale de la mémoire. */
 static void g_dalvik_register_finalize(GDalvikRegister *);
 
-/* Réalise une copie minimale d'un contenu partagé. */
-static void g_dalvik_register_define_template(const GDalvikRegister *, GDalvikRegister *);
-
 /* Produit une empreinte à partir d'un registre. */
 static guint g_dalvik_register_hash(const GDalvikRegister *);
 
@@ -80,23 +73,6 @@ static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *, AsmS
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Gestionnaire des partages d'instances */
-static GShareManager *_dalvik_register_manager = NULL;
-
-
-/* Fournit le gestionnaire de partages attribué à un type. */
-static GShareManager *get_dalvik_register_share_manager(void);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           ENCADREMENT DE REGISTRES BRUTS                           */
-/* ---------------------------------------------------------------------------------- */
-
-
 /* Indique le type défini pour une représentation d'un registre Dalvik. */
 G_DEFINE_TYPE(GDalvikRegister, g_dalvik_register, G_TYPE_ARCH_REGISTER);
 
@@ -125,10 +101,6 @@ static void g_dalvik_register_class_init(GDalvikRegisterClass *klass)
 
     register_class = G_ARCH_REGISTER_CLASS(klass);
 
-    register_class->get_manager = (get_register_manager_fc)get_dalvik_register_share_manager;
-
-    register_class->define_template = (define_register_template_fc)g_dalvik_register_define_template;
-
     register_class->hash = (reg_hash_fc)g_dalvik_register_hash;
     register_class->compare = (reg_compare_fc)g_dalvik_register_compare;
     register_class->print = (reg_print_fc)g_dalvik_register_print;
@@ -194,26 +166,6 @@ static void g_dalvik_register_finalize(GDalvikRegister *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg      = objet partagé à consulter.                        *
-*                template = informations à retrouver intégralement.           *
-*                                                                             *
-*  Description : Réalise une copie minimale d'un contenu partagé.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_register_define_template(const GDalvikRegister *reg, GDalvikRegister *template)
-{
-    template->index = reg->index;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : reg = opérande à consulter pour le calcul.                   *
 *                                                                             *
 *  Description : Produit une empreinte à partir d'un registre.                *
@@ -286,11 +238,10 @@ static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *lin
 GDalvikRegister *g_dalvik_register_new(uint16_t index)
 {
     GDalvikRegister *result;                /* Structure à retourner       */
-    GDalvikRegister template;               /* Transport d'informations    */
 
-    template.index = index;
+    result = g_object_new(G_TYPE_DALVIK_REGISTER, NULL);
 
-    result = G_DALVIK_REGISTER(g_share_manager_build(_dalvik_register_manager, (GSharedInstance *)&template));
+    result->index = index;
 
     return result;
 
@@ -338,87 +289,3 @@ int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b
     return result;
 
 }
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                            PARTAGES DE CONTENUS UNIQUES                            */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Fournit le gestionnaire de partages attribué à un type.      *
-*                                                                             *
-*  Retour      : Gestionnaire de partages en place.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GShareManager *get_dalvik_register_share_manager(void)
-{
-    return _dalvik_register_manager;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Met en place les mécanismes de partage des registres Dalvik. *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool init_dalvik_register_sharing(void)
-{
-    _dalvik_register_manager = g_share_manager_new(G_TYPE_DALVIK_REGISTER);
-
-    return true;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_register_share_stats(void)
-{
-    g_share_manager_dump_stats(_dalvik_register_manager);
-
-}
-#endif
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Supprime les mécanismes de partage des registres Dalvik.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void exit_dalvik_register_sharing(void)
-{
-    g_object_unref(G_OBJECT(_dalvik_register_manager));
-
-}
diff --git a/src/arch/dalvik/register.h b/src/arch/dalvik/register.h
index 3bd6286..b20bdf5 100644
--- a/src/arch/dalvik/register.h
+++ b/src/arch/dalvik/register.h
@@ -34,9 +34,6 @@
 
 
 
-/* ------------------------- ENCADREMENT DE REGISTRES BRUTS ------------------------- */
-
-
 #define G_TYPE_DALVIK_REGISTER               g_dalvik_register_get_type()
 #define G_DALVIK_REGISTER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dalvik_register_get_type(), GDalvikRegister))
 #define G_IS_DALVIK_REGISTER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dalvik_register_get_type()))
@@ -66,20 +63,4 @@ int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
 
 
 
-/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
-
-
-/* Met en place les mécanismes de partage des registres Dalvik. */
-bool init_dalvik_register_sharing(void);
-
-/* Imprime des statistiques quant aux partages dans l'archi. */
-#ifdef DEBUG_DUMP_STATS
-void dump_dalvik_register_share_stats(void);
-#endif
-
-/* Supprime les mécanismes de partage des registres Dalvik. */
-void exit_dalvik_register_sharing(void);
-
-
-
 #endif  /* _ARCH_DALVIK_REGISTERS_H */