Refined the whole share system for operands.

20 files changed, 2056 insertions, 117 deletions

diff --git a/src/arch/arm/register.c b/src/arch/arm/register.c
index fc7ecde..c351f12 100644
--- a/src/arch/arm/register.c
+++ b/src/arch/arm/register.c
@@ -45,7 +45,7 @@ static void g_arm_register_finalize(GArmRegister *);
 static guint g_arm_register_hash(const GArmRegister *);
 
 /* Compare un registre avec un autre. */
-static int g_arm_register_compare(const GArmRegister * const *, const GArmRegister * const *);
+static int g_arm_register_compare(const GArmRegister *, const GArmRegister *);
 
 
 
@@ -189,11 +189,11 @@ static guint g_arm_register_hash(const GArmRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-static int g_arm_register_compare(const GArmRegister * const *a, const GArmRegister * const *b)
+static int g_arm_register_compare(const GArmRegister *a, const GArmRegister *b)
 {
     int result;                             /* Bilan à retourner           */
 
-    result = sort_unsigned_long((*a)->index, (*b)->index);
+    result = sort_unsigned_long(b->index, b->index);
 
     return result;
 
diff --git a/src/arch/arm/v7/core.c b/src/arch/arm/v7/core.c
index 299b9bd..ee43366 100644
--- a/src/arch/arm/v7/core.c
+++ b/src/arch/arm/v7/core.c
@@ -24,6 +24,17 @@
 #include "core.h"
 
 
+#include "register.h"
+#include "operands/coproc.h"
+#include "operands/estate.h"
+#include "operands/limitation.h"
+#include "operands/maccess.h"
+#include "operands/offset.h"
+#include "operands/reglist.h"
+#include "operands/rotation.h"
+#include "operands/shift.h"
+
+
 
 /******************************************************************************
 *                                                                             *
@@ -41,7 +52,31 @@ bool init_armv7_core(void)
 {
     bool result;                            /* Bilan à renvoyer            */
 
-    result = true;
+    result = init_armv7_register_sharing();
+
+    if (result)
+        result = init_armv7_coproc_operand_sharing();
+
+    if (result)
+        result = init_armv7_endian_operand_sharing();
+
+    if (result)
+        result = init_armv7_limitation_operand_sharing();
+
+    if (result)
+        result = init_armv7_maccess_operand_sharing();
+
+    if (result)
+        result = init_armv7_offset_operand_sharing();
+
+    if (result)
+        result = init_armv7_reglist_operand_sharing();
+
+    if (result)
+        result = init_armv7_rotation_operand_sharing();
+
+    if (result)
+        result = init_armv7_shift_operand_sharing();
 
     return result;
 
@@ -62,6 +97,16 @@ bool init_armv7_core(void)
 #ifdef DEBUG_DUMP_STATS
 void dump_armv7_share_stats(void)
 {
+    dump_armv7_register_share_stats();
+
+    dump_armv7_coproc_operand_share_stats();
+    dump_armv7_endian_operand_share_stats();
+    dump_armv7_limitation_operand_share_stats();
+    dump_armv7_maccess_operand_share_stats();
+    dump_armv7_offset_operand_share_stats();
+    dump_armv7_reglist_operand_share_stats();
+    dump_armv7_rotation_operand_share_stats();
+    dump_armv7_shift_operand_share_stats();
 
 }
 #endif
@@ -81,5 +126,15 @@ void dump_armv7_share_stats(void)
 
 void exit_armv7_core(void)
 {
+    exit_armv7_register_sharing();
+
+    exit_armv7_coproc_operand_sharing();
+    exit_armv7_endian_operand_sharing();
+    exit_armv7_limitation_operand_sharing();
+    exit_armv7_maccess_operand_sharing();
+    exit_armv7_offset_operand_sharing();
+    exit_armv7_reglist_operand_sharing();
+    exit_armv7_rotation_operand_sharing();
+    exit_armv7_shift_operand_sharing();
 
 }
diff --git a/src/arch/arm/v7/operands/coproc.c b/src/arch/arm/v7/operands/coproc.c
index 5f90cb2..ff34943 100644
--- a/src/arch/arm/v7/operands/coproc.c
+++ b/src/arch/arm/v7/operands/coproc.c
@@ -25,9 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande représentant un co-processeur (instance) */
 struct _GArmV7CoprocOperand
 {
@@ -58,11 +63,34 @@ static void g_armv7_coproc_operand_dispose(GArmV7CoprocOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_coproc_operand_finalize(GArmV7CoprocOperand *);
 
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_coproc_operand_define_template(const GArmV7CoprocOperand *, GArmV7CoprocOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_coproc_operand_compare(const GArmV7CoprocOperand *, const GArmV7CoprocOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_coproc_operand_print(const GArmV7CoprocOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_coproc_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_coproc_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour un co-processeur ARM. */
 G_DEFINE_TYPE(GArmV7CoprocOperand, g_armv7_coproc_operand, G_TYPE_ARCH_OPERAND);
 
@@ -90,6 +118,13 @@ static void g_armv7_coproc_operand_class_init(GArmV7CoprocOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_coproc_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_coproc_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_coproc_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)NULL;
+    operand->define_template = (define_operand_template_fc)g_armv7_coproc_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_coproc_operand_compare;
     operand->print = (operand_print_fc)g_armv7_coproc_operand_print;
 
 }
@@ -153,25 +188,44 @@ static void g_armv7_coproc_operand_finalize(GArmV7CoprocOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : raw = valeur brute du co-processeur à considérer.            *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Crée une représentation d'un co-processeur ARM.              *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_coproc_operand_new(uint8_t raw)
+static void g_armv7_coproc_operand_define_template(const GArmV7CoprocOperand *operand, GArmV7CoprocOperand *template)
 {
-    GArmV7CoprocOperand *result;            /* Structure à retourner       */
+    template->index = operand->index;
 
-    result = g_object_new(G_TYPE_ARMV7_COPROC_OPERAND, NULL);
+}
 
-    result->index = raw;
 
-    return G_ARCH_OPERAND(result);
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_coproc_operand_compare(const GArmV7CoprocOperand *a, const GArmV7CoprocOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_unsigned_long(a->index, b->index);
+
+    return result;
 
 }
 
@@ -204,6 +258,32 @@ static void g_armv7_coproc_operand_print(const GArmV7CoprocOperand *operand, GBu
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : raw = valeur brute du co-processeur à considérer.            *
+*                                                                             *
+*  Description : Crée une représentation d'un co-processeur ARM.              *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_coproc_operand_new(uint8_t raw)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7CoprocOperand template;           /* Transport d'informations    */
+
+    template.index = raw;
+
+    result = g_share_manager_build(_armv7_coproc_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Fournit l'indice d'un co-processeur ARM.                     *
@@ -219,3 +299,88 @@ uint8_t g_armv7_coproc_operand_get_index(const GArmV7CoprocOperand *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_armv7_coproc_operand_share_manager(void)
+{
+    return _armv7_coproc_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des co-processeurs.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_coproc_operand_sharing(void)
+{
+    _armv7_coproc_operand_manager = g_share_manager_new(G_TYPE_ARMV7_COPROC_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_coproc_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_coproc_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des co-processeurs.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_coproc_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_coproc_operand_manager));
+
+}
diff --git a/src/arch/arm/v7/operands/coproc.h b/src/arch/arm/v7/operands/coproc.h
index 07224d3..241db19 100644
--- a/src/arch/arm/v7/operands/coproc.h
+++ b/src/arch/arm/v7/operands/coproc.h
@@ -32,6 +32,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_COPROC_OPERAND                  g_armv7_coproc_operand_get_type()
 #define G_ARMV7_COPROC_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_coproc_operand_get_type(), GArmV7CoprocOperand))
 #define G_IS_ARMV7_COPROC_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_coproc_operand_get_type()))
@@ -58,4 +61,20 @@ uint8_t g_armv7_coproc_operand_get_index(const GArmV7CoprocOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des co-processeurs. */
+bool init_armv7_coproc_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_coproc_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des co-processeurs. */
+void exit_armv7_coproc_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_COPROC_H */
diff --git a/src/arch/arm/v7/operands/estate.c b/src/arch/arm/v7/operands/estate.c
index 32c873b..25c60ab 100644
--- a/src/arch/arm/v7/operands/estate.c
+++ b/src/arch/arm/v7/operands/estate.c
@@ -25,9 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande affichant le choix d'un boutisme (instance) */
 struct _GArmV7EndianOperand
 {
@@ -58,11 +63,34 @@ static void g_armv7_endian_operand_dispose(GArmV7EndianOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_endian_operand_finalize(GArmV7EndianOperand *);
 
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_endian_operand_define_template(const GArmV7EndianOperand *, GArmV7EndianOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_endian_operand_compare(const GArmV7EndianOperand *, const GArmV7EndianOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_endian_operand_print(const GArmV7EndianOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_endian_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_endian_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour une endian de domaine et d'accès. */
 G_DEFINE_TYPE(GArmV7EndianOperand, g_armv7_endian_operand, G_TYPE_ARCH_OPERAND);
 
@@ -90,6 +118,13 @@ static void g_armv7_endian_operand_class_init(GArmV7EndianOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_endian_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_endian_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_endian_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)NULL;
+    operand->define_template = (define_operand_template_fc)g_armv7_endian_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_endian_operand_compare;
     operand->print = (operand_print_fc)g_armv7_endian_operand_print;
 
 }
@@ -153,25 +188,44 @@ static void g_armv7_endian_operand_finalize(GArmV7EndianOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : big = indication sur le boutisme à représenter.              *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Crée une représentation de boutisme ARMv7.                   *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_endian_operand_new(bool big)
+static void g_armv7_endian_operand_define_template(const GArmV7EndianOperand *operand, GArmV7EndianOperand *template)
 {
-    GArmV7EndianOperand *result;             /* Structure à retourner       */
+    template->big = operand->big;
 
-    result = g_object_new(G_TYPE_ARMV7_ENDIAN_OPERAND, NULL);
+}
 
-    result->big = big;
 
-    return G_ARCH_OPERAND(result);
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_endian_operand_compare(const GArmV7EndianOperand *a, const GArmV7EndianOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_boolean(a->big, b->big);
+
+    return result;
 
 }
 
@@ -202,6 +256,32 @@ static void g_armv7_endian_operand_print(const GArmV7EndianOperand *operand, GBu
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : big = indication sur le boutisme à représenter.              *
+*                                                                             *
+*  Description : Crée une représentation de boutisme ARMv7.                   *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_endian_operand_new(bool big)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7EndianOperand template;           /* Transport d'informations    */
+
+    template.big = big;
+
+    result = g_share_manager_build(_armv7_endian_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Indique le type de boutisme représenté.                      *
@@ -217,3 +297,88 @@ bool g_armv7_endian_operand_is_big_endian(const GArmV7EndianOperand *operand)
     return operand->big;
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            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_armv7_endian_operand_share_manager(void)
+{
+    return _armv7_endian_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des états de boutisme.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_endian_operand_sharing(void)
+{
+    _armv7_endian_operand_manager = g_share_manager_new(G_TYPE_ARMV7_ENDIAN_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_endian_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_endian_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des états de boutisme.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_endian_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_endian_operand_manager));
+
+}
diff --git a/src/arch/arm/v7/operands/estate.h b/src/arch/arm/v7/operands/estate.h
index a1726cf..506bcb4 100644
--- a/src/arch/arm/v7/operands/estate.h
+++ b/src/arch/arm/v7/operands/estate.h
@@ -32,6 +32,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_ENDIAN_OPERAND             g_armv7_endian_operand_get_type()
 #define G_ARMV7_ENDIAN_OPERAND(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_endian_operand_get_type(), GArmV7EndianOperand))
 #define G_IS_ARMV7_ENDIAN_OPERAND(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_endian_operand_get_type()))
@@ -58,4 +61,20 @@ bool g_armv7_endian_operand_is_big_endian(const GArmV7EndianOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des états de boutisme. */
+bool init_armv7_endian_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_endian_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des états de boutisme. */
+void exit_armv7_endian_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_ESTATE_H */
diff --git a/src/arch/arm/v7/operands/limitation.c b/src/arch/arm/v7/operands/limitation.c
index 3684167..a86502c 100644
--- a/src/arch/arm/v7/operands/limitation.c
+++ b/src/arch/arm/v7/operands/limitation.c
@@ -25,9 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande déterminant une limitation de domaine et d'accès (instance) */
 struct _GArmV7LimitationOperand
 {
@@ -58,11 +63,34 @@ static void g_armv7_limitation_operand_dispose(GArmV7LimitationOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_limitation_operand_finalize(GArmV7LimitationOperand *);
 
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_limitation_operand_define_template(const GArmV7LimitationOperand *, GArmV7LimitationOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_limitation_operand_compare(const GArmV7LimitationOperand *, const GArmV7LimitationOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_limitation_operand_print(const GArmV7LimitationOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_limitation_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_limitation_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour une limitation de domaine et d'accès. */
 G_DEFINE_TYPE(GArmV7LimitationOperand, g_armv7_limitation_operand, G_TYPE_ARCH_OPERAND);
 
@@ -90,6 +118,13 @@ static void g_armv7_limitation_operand_class_init(GArmV7LimitationOperandClass *
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_limitation_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_limitation_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_limitation_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)NULL;
+    operand->define_template = (define_operand_template_fc)g_armv7_limitation_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_limitation_operand_compare;
     operand->print = (operand_print_fc)g_armv7_limitation_operand_print;
 
 }
@@ -153,29 +188,44 @@ static void g_armv7_limitation_operand_finalize(GArmV7LimitationOperand *operand
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : raw = valeur brute de la limitation à considérer.            *
+*  Paramètres  : operand  = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Crée une représentation d'une limitation pour barrière.      *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_limitation_operand_new(uint8_t raw)
+static void g_armv7_limitation_operand_define_template(const GArmV7LimitationOperand *operand, GArmV7LimitationOperand *template)
 {
-    GArmV7LimitationOperand *result;             /* Structure à retourner       */
+    template->type = operand->type;
 
-    result = g_object_new(G_TYPE_ARMV7_LIMITATION_OPERAND, NULL);
+}
 
-    if (raw < 0b0010 || raw > 0b1111)
-        result->type = BLT_RESERVED;
 
-    else
-        result->type = raw;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    return G_ARCH_OPERAND(result);
+static int g_armv7_limitation_operand_compare(const GArmV7LimitationOperand *a, const GArmV7LimitationOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_unsigned_long(a->type, b->type);
+
+    return result;
 
 }
 
@@ -241,6 +291,36 @@ static void g_armv7_limitation_operand_print(const GArmV7LimitationOperand *oper
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : raw = valeur brute de la limitation à considérer.            *
+*                                                                             *
+*  Description : Crée une représentation d'une limitation pour barrière.      *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_limitation_operand_new(uint8_t raw)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7LimitationOperand template;       /* Transport d'informations    */
+
+    if (raw < 0b0010 || raw > 0b1111)
+        template.type = BLT_RESERVED;
+
+    else
+        template.type = raw;
+
+    result = g_share_manager_build(_armv7_limitation_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Indique le type de limitation représentée.                   *
@@ -256,3 +336,88 @@ BarrierLimitationType g_armv7_limitation_operand_get_value(const GArmV7Limitatio
     return operand->type;
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            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_armv7_limitation_operand_share_manager(void)
+{
+    return _armv7_limitation_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage de limites de domaine.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_limitation_operand_sharing(void)
+{
+    _armv7_limitation_operand_manager = g_share_manager_new(G_TYPE_ARMV7_LIMITATION_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_limitation_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_limitation_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des limites de domaine.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_limitation_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_limitation_operand_manager));
+
+}
diff --git a/src/arch/arm/v7/operands/limitation.h b/src/arch/arm/v7/operands/limitation.h
index 4f7db88..6fc61d2 100644
--- a/src/arch/arm/v7/operands/limitation.h
+++ b/src/arch/arm/v7/operands/limitation.h
@@ -32,6 +32,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_LIMITATION_OPERAND                  g_armv7_limitation_operand_get_type()
 #define G_ARMV7_LIMITATION_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_limitation_operand_get_type(), GArmV7LimitationOperand))
 #define G_IS_ARMV7_LIMITATION_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_limitation_operand_get_type()))
@@ -74,4 +77,20 @@ BarrierLimitationType g_armv7_limitation_operand_get_value(const GArmV7Limitatio
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage de limites de domaine. */
+bool init_armv7_limitation_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_limitation_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des limites de domaine. */
+void exit_armv7_limitation_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_LIMITATION_H */
diff --git a/src/arch/arm/v7/operands/maccess.c b/src/arch/arm/v7/operands/maccess.c
index eeb80c4..71d55e0 100644
--- a/src/arch/arm/v7/operands/maccess.c
+++ b/src/arch/arm/v7/operands/maccess.c
@@ -25,9 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande offrant un accès à la mémoire depuis une base (instance) */
 struct _GArmV7MAccessOperand
 {
@@ -62,11 +67,37 @@ static void g_armv7_maccess_operand_dispose(GArmV7MAccessOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_maccess_operand_finalize(GArmV7MAccessOperand *);
 
+/* Initialise un nouvel objet partagé avec des informations. */
+static bool g_armv7_maccess_operand_apply_template(GArmV7MAccessOperand *, const GArmV7MAccessOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_maccess_operand_define_template(const GArmV7MAccessOperand *, GArmV7MAccessOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_maccess_operand_compare(const GArmV7MAccessOperand *, const GArmV7MAccessOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_maccess_operand_print(const GArmV7MAccessOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_maccess_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_maccess_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour un accès à la mémoire depuis une base. */
 G_DEFINE_TYPE(GArmV7MAccessOperand, g_armv7_maccess_operand, G_TYPE_ARCH_OPERAND);
 
@@ -94,6 +125,13 @@ static void g_armv7_maccess_operand_class_init(GArmV7MAccessOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_maccess_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_maccess_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_maccess_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_armv7_maccess_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_armv7_maccess_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_maccess_operand_compare;
     operand->print = (operand_print_fc)g_armv7_maccess_operand_print;
 
 }
@@ -165,34 +203,93 @@ static void g_armv7_maccess_operand_finalize(GArmV7MAccessOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : base    = représente le registre de la base d'accès.         *
-*                offset  = détermine le décallage entre l'adresse et la base. *
-*                shift   = opération de décallage pour jouer sur le décallage.*
-*                indexed = précise la forme donnée au décallage à appliquer.  *
-*                wback   = indique une mise à jour de la base après usage.    *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un accès à la mémoire depuis une base et un décallage.  *
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_maccess_operand_new(GArchOperand *base, GArchOperand *offset, GArchOperand *shift, bool indexed, bool wback)
+static bool g_armv7_maccess_operand_apply_template(GArmV7MAccessOperand *operand, const GArmV7MAccessOperand *template)
 {
-    GArmV7MAccessOperand *result;             /* Structure à retourner       */
+    g_armv7_maccess_operand_define_template(template, operand);
 
-    result = g_object_new(G_TYPE_ARMV7_MACCESS_OPERAND, NULL);
+    g_object_ref(G_OBJECT(operand->base));
 
-    result->base = base;
-    result->offset = offset;
-    result->shift = shift;
+    if (operand->offset != NULL)
+        g_object_ref(G_OBJECT(operand->offset));
 
-    result->not_post_indexed = indexed;
-    result->write_back = wback;
+    if (operand->shift != NULL)
+        g_object_ref(G_OBJECT(operand->shift));
 
-    return G_ARCH_OPERAND(result);
+    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_armv7_maccess_operand_define_template(const GArmV7MAccessOperand *operand, GArmV7MAccessOperand *template)
+{
+    template->base = operand->base;
+    template->offset = operand->offset;
+    template->shift = operand->shift;
+
+    template->not_post_indexed = operand->not_post_indexed;
+    template->write_back = operand->write_back;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_maccess_operand_compare(const GArmV7MAccessOperand *a, const GArmV7MAccessOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = g_arch_operand_compare(a->base, b->base);
+    if (result != 0) goto gamoc_done;
+
+    result = sort_pointer(a->offset, b->offset, (__compar_fn_t)g_arch_operand_compare);
+    if (result != 0) goto gamoc_done;
+
+    result = sort_pointer(a->shift, b->shift, (__compar_fn_t)g_arch_operand_compare);
+    if (result != 0) goto gamoc_done;
+
+    result = sort_boolean(a->not_post_indexed, b->not_post_indexed);
+    if (result != 0) goto gamoc_done;
+
+    result = sort_boolean(a->write_back, b->write_back);
+
+ gamoc_done:
+
+    return result;
 
 }
 
@@ -249,6 +346,41 @@ static void g_armv7_maccess_operand_print(const GArmV7MAccessOperand *operand, G
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : base    = représente le registre de la base d'accès.         *
+*                offset  = détermine le décallage entre l'adresse et la base. *
+*                shift   = opération de décallage pour jouer sur le décallage.*
+*                indexed = précise la forme donnée au décallage à appliquer.  *
+*                wback   = indique une mise à jour de la base après usage.    *
+*                                                                             *
+*  Description : Crée un accès à la mémoire depuis une base et un décallage.  *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_maccess_operand_new(GArchOperand *base, GArchOperand *offset, GArchOperand *shift, bool indexed, bool wback)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7MAccessOperand template;          /* Transport d'informations    */
+
+    template.base = base;
+    template.offset = offset;
+    template.shift = shift;
+
+    template.not_post_indexed = indexed;
+    template.write_back = wback;
+
+    result = g_share_manager_build(_armv7_maccess_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Founit la base d'un accès à la mémoire.                      *
@@ -340,3 +472,88 @@ bool g_armv7_maccess_operand_has_to_write_back(const GArmV7MAccessOperand *opera
     return operand->write_back;
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            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_armv7_maccess_operand_share_manager(void)
+{
+    return _armv7_maccess_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des accès mémmoire.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_maccess_operand_sharing(void)
+{
+    _armv7_maccess_operand_manager = g_share_manager_new(G_TYPE_ARMV7_MACCESS_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_maccess_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_maccess_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des accès mémoire.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_maccess_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_maccess_operand_manager));
+
+}
diff --git a/src/arch/arm/v7/operands/maccess.h b/src/arch/arm/v7/operands/maccess.h
index 6e99e0b..52f297d 100644
--- a/src/arch/arm/v7/operands/maccess.h
+++ b/src/arch/arm/v7/operands/maccess.h
@@ -34,6 +34,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_MACCESS_OPERAND                  g_armv7_maccess_operand_get_type()
 #define G_ARMV7_MACCESS_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_maccess_operand_get_type(), GArmV7MAccessOperand))
 #define G_IS_ARMV7_MACCESS_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_maccess_operand_get_type()))
@@ -72,4 +75,20 @@ bool g_armv7_maccess_operand_has_to_write_back(const GArmV7MAccessOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des accès mémmoire. */
+bool init_armv7_maccess_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_maccess_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des accès mémoire. */
+void exit_armv7_maccess_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_MACCESS_H */
diff --git a/src/arch/arm/v7/operands/offset.c b/src/arch/arm/v7/operands/offset.c
index 9368faf..ebd73c8 100644
--- a/src/arch/arm/v7/operands/offset.c
+++ b/src/arch/arm/v7/operands/offset.c
@@ -25,9 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande visant à constituer un décallage relatif ARMv7 (instance) */
 struct _GArmV7OffsetOperand
 {
@@ -59,11 +64,37 @@ static void g_armv7_offset_operand_dispose(GArmV7OffsetOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_offset_operand_finalize(GArmV7OffsetOperand *);
 
+/* Initialise un nouvel objet partagé avec des informations. */
+static bool g_armv7_offset_operand_apply_template(GArmV7OffsetOperand *, const GArmV7OffsetOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_offset_operand_define_template(const GArmV7OffsetOperand *, GArmV7OffsetOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_offset_operand_compare(const GArmV7OffsetOperand *, const GArmV7OffsetOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_offset_operand_print(const GArmV7OffsetOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_offset_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_offset_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour un décallage relatif ARMv7. */
 G_DEFINE_TYPE(GArmV7OffsetOperand, g_armv7_offset_operand, G_TYPE_ARCH_OPERAND);
 
@@ -91,6 +122,13 @@ static void g_armv7_offset_operand_class_init(GArmV7OffsetOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_offset_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_offset_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_offset_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_armv7_offset_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_armv7_offset_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_offset_operand_compare;
     operand->print = (operand_print_fc)g_armv7_offset_operand_print;
 
 }
@@ -156,27 +194,75 @@ static void g_armv7_offset_operand_finalize(GArmV7OffsetOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : positive = indique si la quantité doit être ajoutée ou non.  *
-*                value    = valeur du décallage à appliquer.                  *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un décallage selon un sens et une valeur donnés.        *
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_offset_operand_new(bool positive, GArchOperand *value)
+static bool g_armv7_offset_operand_apply_template(GArmV7OffsetOperand *operand, const GArmV7OffsetOperand *template)
 {
-    GArmV7OffsetOperand *result;             /* Structure à retourner       */
+    g_armv7_offset_operand_define_template(template, operand);
 
-    result = g_object_new(G_TYPE_ARMV7_OFFSET_OPERAND, NULL);
+    g_object_ref(G_OBJECT(operand->value));
 
-    result->positive = positive;
-    result->value = value;
+    return true;
 
-    return G_ARCH_OPERAND(result);
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_offset_operand_define_template(const GArmV7OffsetOperand *operand, GArmV7OffsetOperand *template)
+{
+    template->positive = operand->positive;
+
+    template->value = operand->value;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_offset_operand_compare(const GArmV7OffsetOperand *a, const GArmV7OffsetOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_boolean(a->positive, b->positive);
+    if (result != 0) goto gaooc_done;
+
+    result = g_arch_operand_compare(a->value, b->value);
+
+ gaooc_done:
+
+    return result;
 
 }
 
@@ -207,6 +293,34 @@ static void g_armv7_offset_operand_print(const GArmV7OffsetOperand *operand, GBu
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : positive = indique si la quantité doit être ajoutée ou non.  *
+*                value    = valeur du décallage à appliquer.                  *
+*                                                                             *
+*  Description : Crée un décallage selon un sens et une valeur donnés.        *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_offset_operand_new(bool positive, GArchOperand *value)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7OffsetOperand template;           /* Transport d'informations    */
+
+    template.positive = positive;
+    template.value = value;
+
+    result = g_share_manager_build(_armv7_offset_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Indique le sens du décallage représenté.                     *
@@ -238,6 +352,97 @@ bool g_armv7_offset_operand_is_positive(const GArmV7OffsetOperand *operand)
 
 GArchOperand *g_armv7_offset_operand_get_value(const GArmV7OffsetOperand *operand)
 {
-    return operand->value;
+    GArchOperand *result;                   /* Instance à retourner        */
+
+    result = operand->value;
+
+    g_object_ref(G_OBJECT(result));
+
+    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_armv7_offset_operand_share_manager(void)
+{
+    return _armv7_offset_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des décallages ARMv7. *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_offset_operand_sharing(void)
+{
+    _armv7_offset_operand_manager = g_share_manager_new(G_TYPE_ARMV7_OFFSET_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_offset_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_offset_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des décallages ARMv7.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_offset_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_offset_operand_manager));
 
 }
diff --git a/src/arch/arm/v7/operands/offset.h b/src/arch/arm/v7/operands/offset.h
index 64744df..b1e1ddc 100644
--- a/src/arch/arm/v7/operands/offset.h
+++ b/src/arch/arm/v7/operands/offset.h
@@ -34,6 +34,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_OFFSET_OPERAND                  g_armv7_offset_operand_get_type()
 #define G_ARMV7_OFFSET_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_offset_operand_get_type(), GArmV7OffsetOperand))
 #define G_IS_ARMV7_OFFSET_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_offset_operand_get_type()))
@@ -63,4 +66,20 @@ GArchOperand *g_armv7_offset_operand_get_value(const GArmV7OffsetOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des décallages ARMv7. */
+bool init_armv7_offset_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_offset_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des décallages ARMv7. */
+void exit_armv7_offset_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_OFFSET_H */
diff --git a/src/arch/arm/v7/operands/reglist.c b/src/arch/arm/v7/operands/reglist.c
index cfbc6ab..968a423 100644
--- a/src/arch/arm/v7/operands/reglist.c
+++ b/src/arch/arm/v7/operands/reglist.c
@@ -30,9 +30,14 @@
 
 #include "../../../operand-int.h"
 #include "../../../register.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 /* Définition d'un opérande listant une série de registres ARM (instance) */
 struct _GArmV7RegListOperand
 {
@@ -64,11 +69,40 @@ static void g_armv7_reglist_operand_dispose(GArmV7RegListOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_reglist_operand_finalize(GArmV7RegListOperand *);
 
+/* Initialise un nouvel objet partagé avec des informations. */
+static bool g_armv7_reglist_operand_apply_template(GArmV7RegListOperand *, const GArmV7RegListOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_reglist_operand_define_template(const GArmV7RegListOperand *, GArmV7RegListOperand *);
+
+/* Libère la mémoire utilisée par un patron d'instance. */
+static void g_armv7_reglist_operand_free_template(const GArmV7RegListOperand *, GArmV7RegListOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_reglist_operand_compare(const GArmV7RegListOperand *, const GArmV7RegListOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_reglist_operand_print(const GArmV7RegListOperand *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_reglist_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_reglist_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini par la GLib pour une liste de registres ARM. */
 G_DEFINE_TYPE(GArmV7RegListOperand, g_armv7_reglist_operand, G_TYPE_ARCH_OPERAND);
 
@@ -96,6 +130,13 @@ static void g_armv7_reglist_operand_class_init(GArmV7RegListOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_reglist_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_reglist_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_reglist_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_armv7_reglist_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_armv7_reglist_operand_define_template;
+    operand->free_template = (free_operand_template_fc)g_armv7_reglist_operand_free_template;;
+
+    operand->compare = (operand_compare_fc)g_armv7_reglist_operand_compare;
     operand->print = (operand_print_fc)g_armv7_reglist_operand_print;
 
 }
@@ -167,23 +208,131 @@ static void g_armv7_reglist_operand_finalize(GArmV7RegListOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée une liste vierge de registres ARM.                      *
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_reglist_operand_new(void)
+static bool g_armv7_reglist_operand_apply_template(GArmV7RegListOperand *operand, const GArmV7RegListOperand *template)
 {
-    GArmV7RegListOperand *result;             /* Structure à retourner       */
+    size_t i;                               /* Boucle de parcours          */
 
-    result = g_object_new(G_TYPE_ARMV7_REGLIST_OPERAND, NULL);
+    g_armv7_reglist_operand_define_template(template, operand);
 
-    return G_ARCH_OPERAND(result);
+    for (i = 0; i < operand->count; i++)
+        g_object_ref(G_OBJECT(operand->registers[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_armv7_reglist_operand_define_template(const GArmV7RegListOperand *operand, GArmV7RegListOperand *template)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    if (operand != NULL)
+        template->count = operand->count;
+    else
+        template->count = 0;
+
+    if (template->count == 0)
+        template->registers = NULL;
+
+    else
+    {
+        template->registers = (GArmV7Register **)malloc(template->count * sizeof(GArmV7Register *));
+
+        for (i = 0; i < template->count; i++)
+            template->registers[i] = operand->registers[i];
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_reglist_operand_free_template(const GArmV7RegListOperand *operand, GArmV7RegListOperand *template)
+{
+    if (template->registers != NULL)
+        free(template->registers);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_reglist_operand_compare(const GArmV7RegListOperand *a, const GArmV7RegListOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+    size_t i;                               /* Boucle de parcours          */
+    GArchRegister *ra;                      /* Registre de la liste A      */
+    GArchRegister *rb;                      /* Registre de la liste B      */
+
+    /* Création de l'objet... */
+    if (b == NULL)
+    {
+        result = 1;
+        goto garoc_done;
+    }
+
+    result = sort_unsigned_long(a->count, b->count);
+    if (result != 0) goto garoc_done;
+
+    for (i = 0; i < a->count && result == 0; i++)
+    {
+        ra = G_ARCH_REGISTER(a->registers[i]);
+        rb = G_ARCH_REGISTER(b->registers[i]);
+
+        result = g_arch_register_compare(ra, rb);
+
+    }
+
+ garoc_done:
+
+    return result;
 
 }
 
@@ -227,6 +376,29 @@ static void g_armv7_reglist_operand_print(const GArmV7RegListOperand *operand, G
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée une liste vierge de registres ARM.                      *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_reglist_operand_new(void)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+
+    result = g_share_manager_build(_armv7_reglist_operand_manager, NULL);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand  = liste de registres à compléter.                   *
 *                selected = masque de bits pour les registres à intégrer.     *
 *                                                                             *
@@ -323,3 +495,88 @@ GArmV7Register *g_armv7_reglist_operand_get_register(const GArmV7RegListOperand
     return operand->registers[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_armv7_reglist_operand_share_manager(void)
+{
+    return _armv7_reglist_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage de listes de reg.     *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_reglist_operand_sharing(void)
+{
+    _armv7_reglist_operand_manager = g_share_manager_new(G_TYPE_ARMV7_REGLIST_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_reglist_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_reglist_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des listes de registres.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_reglist_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_reglist_operand_manager));
+
+}
diff --git a/src/arch/arm/v7/operands/reglist.h b/src/arch/arm/v7/operands/reglist.h
index 7c60805..497c852 100644
--- a/src/arch/arm/v7/operands/reglist.h
+++ b/src/arch/arm/v7/operands/reglist.h
@@ -34,6 +34,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_REGLIST_OPERAND                  g_armv7_reglist_operand_get_type()
 #define G_ARMV7_REGLIST_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_reglist_operand_get_type(), GArmV7RegListOperand))
 #define G_IS_ARMV7_REGLIST_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_reglist_operand_get_type()))
@@ -69,4 +72,20 @@ GArmV7Register *g_armv7_reglist_operand_get_register(const GArmV7RegListOperand
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage de listes de registres. */
+bool init_armv7_reglist_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_reglist_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des listes de registres. */
+void exit_armv7_reglist_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_REGLIST_H */
diff --git a/src/arch/arm/v7/operands/rotation.c b/src/arch/arm/v7/operands/rotation.c
index 5733aa2..be89cd5 100644
--- a/src/arch/arm/v7/operands/rotation.c
+++ b/src/arch/arm/v7/operands/rotation.c
@@ -25,10 +25,14 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
 
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (instance) */
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
+/* Définition d'un opérande visant une opérande de rotation ARMv7 (instance) */
 struct _GArmV7RotationOperand
 {
     GArchOperand parent;                    /* Instance parente            */
@@ -38,7 +42,7 @@ struct _GArmV7RotationOperand
 };
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (classe) */
+/* Définition d'un opérande visant une opérande de rotation ARMv7 (classe) */
 struct _GArmV7RotationOperandClass
 {
     GArchOperandClass parent;               /* Classe parente              */
@@ -46,10 +50,10 @@ struct _GArmV7RotationOperandClass
 };
 
 
-/* Initialise la classe des listes d'opérandes Dalvik. */
+/* Initialise la classe des opérandes de rotation ARMv7. */
 static void g_armv7_rotation_operand_class_init(GArmV7RotationOperandClass *);
 
-/* Initialise une instance de liste d'opérandes Dalvik. */
+/* Initialise une instance d'opérande de rotation ARMv7. */
 static void g_armv7_rotation_operand_init(GArmV7RotationOperand *);
 
 /* Supprime toutes les références externes. */
@@ -58,12 +62,38 @@ static void g_armv7_rotation_operand_dispose(GArmV7RotationOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_rotation_operand_finalize(GArmV7RotationOperand *);
 
+/* Initialise un nouvel objet partagé avec des informations. */
+static bool g_armv7_rotation_operand_apply_template(GArmV7RotationOperand *, const GArmV7RotationOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_rotation_operand_define_template(const GArmV7RotationOperand *, GArmV7RotationOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_rotation_operand_compare(const GArmV7RotationOperand *, const GArmV7RotationOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_rotation_operand_print(const GArmV7RotationOperand *, GBufferLine *, AsmSyntax);
 
 
 
-/* Indique le type défini par la GLib pour une liste d'arguments Dalvik. */
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_rotation_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_rotation_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini par la GLib pour une opérande de rotation ARMv7. */
 G_DEFINE_TYPE(GArmV7RotationOperand, g_armv7_rotation_operand, G_TYPE_ARCH_OPERAND);
 
 
@@ -71,7 +101,7 @@ G_DEFINE_TYPE(GArmV7RotationOperand, g_armv7_rotation_operand, G_TYPE_ARCH_OPERA
 *                                                                             *
 *  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Initialise la classe des listes d'opérandes Dalvik.          *
+*  Description : Initialise la classe des opérandes de rotation ARMv7.        *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -90,6 +120,13 @@ static void g_armv7_rotation_operand_class_init(GArmV7RotationOperandClass *klas
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_rotation_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_rotation_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_rotation_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_armv7_rotation_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_armv7_rotation_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_rotation_operand_compare;
     operand->print = (operand_print_fc)g_armv7_rotation_operand_print;
 
 }
@@ -99,7 +136,7 @@ static void g_armv7_rotation_operand_class_init(GArmV7RotationOperandClass *klas
 *                                                                             *
 *  Paramètres  : operand = instance à initialiser.                            *
 *                                                                             *
-*  Description : Initialise une instance de liste d'opérandes Dalvik.         *
+*  Description : Initialise une instance d'opérande de rotation ARMv7.        *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -155,25 +192,68 @@ static void g_armv7_rotation_operand_finalize(GArmV7RotationOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un réceptacle pour opérandes Dalvik servant d'arguments.*
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_rotation_operand_new(GArchOperand *value)
+static bool g_armv7_rotation_operand_apply_template(GArmV7RotationOperand *operand, const GArmV7RotationOperand *template)
 {
-    GArmV7RotationOperand *result;             /* Structure à retourner       */
+    g_armv7_rotation_operand_define_template(template, operand);
 
-    result = g_object_new(G_TYPE_ARMV7_ROTATION_OPERAND, NULL);
+    g_object_ref(G_OBJECT(operand->value));
 
-    result->value = value;
+    return true;
 
-    return G_ARCH_OPERAND(result);
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_rotation_operand_define_template(const GArmV7RotationOperand *operand, GArmV7RotationOperand *template)
+{
+    template->value = operand->value;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_rotation_operand_compare(const GArmV7RotationOperand *a, const GArmV7RotationOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = g_arch_operand_compare(a->value, b->value);
+
+    return result;
 
 }
 
@@ -205,9 +285,35 @@ static void g_armv7_rotation_operand_print(const GArmV7RotationOperand *operand,
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un réceptacle pour opérandes de rotation ARMv7.         *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_rotation_operand_new(GArchOperand *value)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7RotationOperand template;         /* Transport d'informations    */
+
+    template.value = value;
+
+    result = g_share_manager_build(_armv7_rotation_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
-*  Description : Founit la valeur utilisée pour un décallage.                 *
+*  Description : Founit la valeur utilisée pour une rotation.                 *
 *                                                                             *
 *  Retour      : Opérande en place.                                           *
 *                                                                             *
@@ -217,6 +323,97 @@ static void g_armv7_rotation_operand_print(const GArmV7RotationOperand *operand,
 
 GArchOperand *g_armv7_rotation_operand_get_value(const GArmV7RotationOperand *operand)
 {
-    return operand->value;
+    GArchOperand *result;                   /* Instance à retourner        */
+
+    result = operand->value;
+
+    g_object_ref(G_OBJECT(result));
+
+    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_armv7_rotation_operand_share_manager(void)
+{
+    return _armv7_rotation_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des rotation ARMv7.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_rotation_operand_sharing(void)
+{
+    _armv7_rotation_operand_manager = g_share_manager_new(G_TYPE_ARMV7_ROTATION_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_rotation_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_rotation_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des opérandes de rotation.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_rotation_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_rotation_operand_manager));
 
 }
diff --git a/src/arch/arm/v7/operands/rotation.h b/src/arch/arm/v7/operands/rotation.h
index e42b219..399baf4 100644
--- a/src/arch/arm/v7/operands/rotation.h
+++ b/src/arch/arm/v7/operands/rotation.h
@@ -40,22 +40,38 @@
 #define G_ARMV7_ROTATION_OPERAND_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARMV7_ROTATION_OPERAND, GArmV7RotationOperandClass))
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (instance) */
+/* Définition d'un opérande visant une opérande de rotation ARMv7 (instance) */
 typedef struct _GArmV7RotationOperand GArmV7RotationOperand;
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (classe) */
+/* Définition d'un opérande visant une opérande de rotation ARMv7 (classe) */
 typedef struct _GArmV7RotationOperandClass GArmV7RotationOperandClass;
 
 
-/* Indique le type défini par la GLib pour une liste d'arguments Dalvik. */
+/* Indique le type défini par la GLib pour une opérande de rotation ARMv7. */
 GType g_armv7_rotation_operand_get_type(void);
 
-/* Crée un réceptacle pour opérandes Dalvik servant d'arguments. */
+/* Crée un réceptacle pour opérandes de rotation ARMv7. */
 GArchOperand *g_armv7_rotation_operand_new(GArchOperand *);
 
-/* Founit la valeur utilisée pour un décallage. */
+/* Founit la valeur utilisée pour une rotation. */
 GArchOperand *g_armv7_rotation_operand_get_value(const GArmV7RotationOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des rotation ARMv7. */
+bool init_armv7_rotation_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_rotation_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des opérandes de rotation. */
+void exit_armv7_rotation_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_ROTATION_H */
diff --git a/src/arch/arm/v7/operands/shift.c b/src/arch/arm/v7/operands/shift.c
index 8797c3d..3a37e81 100644
--- a/src/arch/arm/v7/operands/shift.c
+++ b/src/arch/arm/v7/operands/shift.c
@@ -25,10 +25,15 @@
 
 
 #include "../../../operand-int.h"
+#include "../../../sharing/manager.h"
+#include "../../../../common/sort.h"
 
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (instance) */
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
+/* Définition d'un opérande visant une opérande de décallage ARMv7 (instance) */
 struct _GArmV7ShiftOperand
 {
     GArchOperand parent;                    /* Instance parente            */
@@ -39,7 +44,7 @@ struct _GArmV7ShiftOperand
 };
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (classe) */
+/* Définition d'un opérande visant une opérande de décallage ARMv7 (classe) */
 struct _GArmV7ShiftOperandClass
 {
     GArchOperandClass parent;               /* Classe parente              */
@@ -47,10 +52,10 @@ struct _GArmV7ShiftOperandClass
 };
 
 
-/* Initialise la classe des listes d'opérandes Dalvik. */
+/* Initialise la classe des opérandes de décallage ARMv7. */
 static void g_armv7_shift_operand_class_init(GArmV7ShiftOperandClass *);
 
-/* Initialise une instance de liste d'opérandes Dalvik. */
+/* Initialise une instance d'opérande de décallage ARMv7. */
 static void g_armv7_shift_operand_init(GArmV7ShiftOperand *);
 
 /* Supprime toutes les références externes. */
@@ -59,12 +64,38 @@ static void g_armv7_shift_operand_dispose(GArmV7ShiftOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_shift_operand_finalize(GArmV7ShiftOperand *);
 
+/* Initialise un nouvel objet partagé avec des informations. */
+static bool g_armv7_shift_operand_apply_template(GArmV7ShiftOperand *, const GArmV7ShiftOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_shift_operand_define_template(const GArmV7ShiftOperand *, GArmV7ShiftOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_shift_operand_compare(const GArmV7ShiftOperand *, const GArmV7ShiftOperand *);
+
 /* Traduit un opérande en version humainement lisible. */
 static void g_armv7_shift_operand_print(const GArmV7ShiftOperand *, GBufferLine *, AsmSyntax);
 
 
 
-/* Indique le type défini par la GLib pour une liste d'arguments Dalvik. */
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_shift_operand_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_shift_operand_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       MANIPULATION D'OPERANDES INDIVIDUELLES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini par la GLib pour une opérande de décallage ARMv7. */
 G_DEFINE_TYPE(GArmV7ShiftOperand, g_armv7_shift_operand, G_TYPE_ARCH_OPERAND);
 
 
@@ -72,7 +103,7 @@ G_DEFINE_TYPE(GArmV7ShiftOperand, g_armv7_shift_operand, G_TYPE_ARCH_OPERAND);
 *                                                                             *
 *  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Initialise la classe des listes d'opérandes Dalvik.          *
+*  Description : Initialise la classe des opérandes de décallage ARMv7.       *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -91,6 +122,13 @@ static void g_armv7_shift_operand_class_init(GArmV7ShiftOperandClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_shift_operand_dispose;
     object->finalize = (GObjectFinalizeFunc)g_armv7_shift_operand_finalize;
 
+    operand->get_manager = (get_operand_manager_fc)get_armv7_shift_operand_share_manager;
+
+    operand->apply_template = (apply_operand_template_fc)g_armv7_shift_operand_apply_template;
+    operand->define_template = (define_operand_template_fc)g_armv7_shift_operand_define_template;
+    operand->free_template = (free_operand_template_fc)NULL;
+
+    operand->compare = (operand_compare_fc)g_armv7_shift_operand_compare;
     operand->print = (operand_print_fc)g_armv7_shift_operand_print;
 
 }
@@ -100,7 +138,7 @@ static void g_armv7_shift_operand_class_init(GArmV7ShiftOperandClass *klass)
 *                                                                             *
 *  Paramètres  : operand = instance à initialiser.                            *
 *                                                                             *
-*  Description : Initialise une instance de liste d'opérandes Dalvik.         *
+*  Description : Initialise une instance d'opérande de décallage ARMv7.       *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -156,26 +194,75 @@ static void g_armv7_shift_operand_finalize(GArmV7ShiftOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : operand  = objet partagé à initialiser.                      *
+*                template = information à utiliser pour la mise en place.     *
 *                                                                             *
-*  Description : Crée un réceptacle pour opérandes Dalvik servant d'arguments.*
+*  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
-*  Retour      : Opérande mis en place.                                       *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArchOperand *g_armv7_shift_operand_new(SRType type, GArchOperand *value)
+static bool g_armv7_shift_operand_apply_template(GArmV7ShiftOperand *operand, const GArmV7ShiftOperand *template)
 {
-    GArmV7ShiftOperand *result;             /* Structure à retourner       */
+    g_armv7_shift_operand_define_template(template, operand);
 
-    result = g_object_new(G_TYPE_ARMV7_SHIFT_OPERAND, NULL);
+    g_object_ref(G_OBJECT(operand->shift_value));
 
-    result->shift_type = type;
-    result->shift_value = value;
+    return true;
 
-    return G_ARCH_OPERAND(result);
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_shift_operand_define_template(const GArmV7ShiftOperand *operand, GArmV7ShiftOperand *template)
+{
+    template->shift_type = operand->shift_type;
+
+    template->shift_value = operand->shift_value;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_armv7_shift_operand_compare(const GArmV7ShiftOperand *a, const GArmV7ShiftOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_unsigned_long(a->shift_type, b->shift_type);
+    if (result != 0) goto gasoc_done;
+
+    result = g_arch_operand_compare(a->shift_value, b->shift_value);
+
+ gasoc_done:
+
+    return result;
 
 }
 
@@ -224,6 +311,33 @@ static void g_armv7_shift_operand_print(const GArmV7ShiftOperand *operand, GBuff
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un réceptacle pour opérande de décallage ARMv7.         *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_shift_operand_new(SRType type, GArchOperand *value)
+{
+    GSharedInstance *result;                /* Structure à retourner       */
+    GArmV7ShiftOperand template;            /* Transport d'informations    */
+
+    template.shift_type = type;
+    template.shift_value = value;
+
+    result = g_share_manager_build(_armv7_shift_operand_manager, (GSharedInstance *)&template);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = opérande à consulter.                              *
 *                                                                             *
 *  Description : Indique la forme de décallage représenté.                    *
@@ -255,6 +369,97 @@ SRType g_armv7_shift_operand_get_shift_type(const GArmV7ShiftOperand *operand)
 
 GArchOperand *g_armv7_shift_operand_get_shift_value(const GArmV7ShiftOperand *operand)
 {
-    return operand->shift_value;
+    GArchOperand *result;                   /* Instance à retourner        */
+
+    result = operand->shift_value;
+
+    g_object_ref(G_OBJECT(result));
+
+    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_armv7_shift_operand_share_manager(void)
+{
+    return _armv7_shift_operand_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des décallages ARMv7. *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_shift_operand_sharing(void)
+{
+    _armv7_shift_operand_manager = g_share_manager_new(G_TYPE_ARMV7_SHIFT_OPERAND);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_shift_operand_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_shift_operand_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des décallages ARMv7.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_shift_operand_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_shift_operand_manager));
 
 }
diff --git a/src/arch/arm/v7/operands/shift.h b/src/arch/arm/v7/operands/shift.h
index 3351056..1169946 100644
--- a/src/arch/arm/v7/operands/shift.h
+++ b/src/arch/arm/v7/operands/shift.h
@@ -33,6 +33,9 @@
 
 
 
+/* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */
+
+
 #define G_TYPE_ARMV7_SHIFT_OPERAND                  g_armv7_shift_operand_get_type()
 #define G_ARMV7_SHIFT_OPERAND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_shift_operand_get_type(), GArmV7ShiftOperand))
 #define G_IS_ARMV7_SHIFT_OPERAND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_shift_operand_get_type()))
@@ -41,17 +44,17 @@
 #define G_ARMV7_SHIFT_OPERAND_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARMV7_SHIFT_OPERAND, GArmV7ShiftOperandClass))
 
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (instance) */
+/* Définition d'un opérande visant une opérande de décallage ARMv7 (instance) */
 typedef struct _GArmV7ShiftOperand GArmV7ShiftOperand;
 
-/* Définition d'un opérande visant une liste d'opérandes Dalvik (classe) */
+/* Définition d'un opérande visant une opérande de décallage ARMv7 (classe) */
 typedef struct _GArmV7ShiftOperandClass GArmV7ShiftOperandClass;
 
 
-/* Indique le type défini par la GLib pour une liste d'arguments Dalvik. */
+/* Indique le type défini par la GLib pour une opérande de décallage ARMv7. */
 GType g_armv7_shift_operand_get_type(void);
 
-/* Crée un réceptacle pour opérandes Dalvik servant d'arguments. */
+/* Crée un réceptacle pour opérande de décallage ARMv7. */
 GArchOperand *g_armv7_shift_operand_new(SRType, GArchOperand *);
 
 /* Indique la forme de décallage représenté. */
@@ -62,4 +65,20 @@ GArchOperand *g_armv7_shift_operand_get_shift_value(const GArmV7ShiftOperand *);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des décallages ARMv7. */
+bool init_armv7_shift_operand_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_shift_operand_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des décallages ARMv7. */
+void exit_armv7_shift_operand_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_OPERANDS_SHIFT_H */
diff --git a/src/arch/arm/v7/register.c b/src/arch/arm/v7/register.c
index 1e76764..7a873b5 100644
--- a/src/arch/arm/v7/register.c
+++ b/src/arch/arm/v7/register.c
@@ -31,6 +31,9 @@
 
 
 
+/* ------------------------- ENCADREMENT DE REGISTRES BRUTS ------------------------- */
+
+
 /* Représentation d'un registre ARMv7 (instance) */
 struct _GArmV7Register
 {
@@ -62,11 +65,31 @@ static void g_armv7_register_dispose(GArmV7Register *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_register_finalize(GArmV7Register *);
 
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_armv7_register_define_template(const GArmV7Register *, GArmV7Register *);
+
 /* Traduit un registre en version humainement lisible. */
 static void g_armv7_register_print(const GArmV7Register *, GBufferLine *, AsmSyntax);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Gestionnaire des partages d'instances */
+static GShareManager *_armv7_register_manager = NULL;
+
+
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_armv7_register_share_manager(void);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           ENCADREMENT DE REGISTRES BRUTS                           */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Indique le type défini pour une représentation d'un registre ARMv7. */
 G_DEFINE_TYPE(GArmV7Register, g_armv7_register, G_TYPE_ARM_REGISTER);
 
@@ -94,6 +117,10 @@ static void g_armv7_register_class_init(GArmV7RegisterClass *klass)
     object_class->dispose = (GObjectFinalizeFunc/* ! */)g_armv7_register_dispose;
     object_class->finalize = (GObjectFinalizeFunc)g_armv7_register_finalize;
 
+    reg_class->get_manager = (get_register_manager_fc)get_armv7_register_share_manager;
+
+    reg_class->define_template = (define_register_template_fc)g_armv7_register_define_template;
+
     reg_class->print = (reg_print_fc)g_armv7_register_print;
 
 }
@@ -157,25 +184,26 @@ static void g_armv7_register_finalize(GArmV7Register *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : index = indice du registre correspondant.                    *
+*  Paramètres  : reg      = objet partagé à consulter.                        *
+*                template = informations à retrouver intégralement.           *
 *                                                                             *
-*  Description : Crée une réprésentation de registre ARMv7.                   *
+*  Description : Réalise une copie minimale d'un contenu partagé.             *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GArmV7Register *g_armv7_register_new(uint8_t index)
+static void g_armv7_register_define_template(const GArmV7Register *reg, GArmV7Register *template)
 {
-    GArmV7Register *result;                 /* Structure à retourner       */
+    GArmRegister *areg;                     /* Version parente #1          */
+    GArmRegister *treg;                     /* Version parente #2          */
 
-    result = g_object_new(G_TYPE_ARMV7_REGISTER, NULL);
+    areg = (GArmRegister *)reg;
+    treg = (GArmRegister *)template;
 
-    G_ARM_REGISTER(result)->index = index;
-
-    return result;
+    treg->index = areg->index;
 
 }
 
@@ -227,3 +255,114 @@ static void g_armv7_register_print(const GArmV7Register *reg, GBufferLine *line,
     g_buffer_line_append_text(line, BLC_ASSEMBLY, key, klen, RTT_REGISTER, NULL);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : index = indice du registre correspondant.                    *
+*                                                                             *
+*  Description : Crée une réprésentation de registre ARMv7.                   *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArmV7Register *g_armv7_register_new(uint8_t index)
+{
+    GArmV7Register *result;                 /* Structure à retourner       */
+    GArmRegister template;                  /* Transport d'informations    */
+
+    template.index = index;
+
+    result = G_ARMV7_REGISTER(g_share_manager_build(_armv7_register_manager, (GSharedInstance *)&template));
+
+    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_armv7_register_share_manager(void)
+{
+    return _armv7_register_manager;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Met en place les mécanismes de partage des registres ARMv7.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool init_armv7_register_sharing(void)
+{
+    _armv7_register_manager = g_share_manager_new(G_TYPE_ARMV7_REGISTER);
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_register_share_stats(void)
+{
+    g_share_manager_dump_stats(_armv7_register_manager);
+
+}
+#endif
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Supprime les mécanismes de partage des registres ARMv7.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_armv7_register_sharing(void)
+{
+    g_object_unref(G_OBJECT(_armv7_register_manager));
+
+}
diff --git a/src/arch/arm/v7/register.h b/src/arch/arm/v7/register.h
index de038e2..0408859 100644
--- a/src/arch/arm/v7/register.h
+++ b/src/arch/arm/v7/register.h
@@ -26,10 +26,14 @@
 
 
 #include <glib-object.h>
+#include <stdbool.h>
 #include <stdint.h>
 
 
 
+/* ------------------------- ENCADREMENT DE REGISTRES BRUTS ------------------------- */
+
+
 #define G_TYPE_ARMV7_REGISTER               g_armv7_register_get_type()
 #define G_ARMV7_REGISTER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_armv7_register_get_type(), GArmV7Register))
 #define G_IS_ARMV7_REGISTER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_armv7_register_get_type()))
@@ -53,4 +57,20 @@ GArmV7Register *g_armv7_register_new(uint8_t);
 
 
 
+/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */
+
+
+/* Met en place les mécanismes de partage des registres ARMv7. */
+bool init_armv7_register_sharing(void);
+
+/* Imprime des statistiques quant aux partages dans l'archi. */
+#ifdef DEBUG_DUMP_STATS
+void dump_armv7_register_share_stats(void);
+#endif
+
+/* Supprime les mécanismes de partage des registres ARMv7. */
+void exit_armv7_register_sharing(void);
+
+
+
 #endif  /* _ARCH_ARM_V7_REGISTER_H */