Used a fast sorted array to track shared instances instead of a simple hash table.

5 files changed, 85 insertions, 176 deletions

diff --git a/src/arch/dalvik/operands/args.c b/src/arch/dalvik/operands/args.c
index 9e75604..5ba552b 100644
--- a/src/arch/dalvik/operands/args.c
+++ b/src/arch/dalvik/operands/args.c
@@ -30,6 +30,7 @@
 
 #include "../../operand-int.h"
 #include "../../sharing/manager.h"
+#include "../../../common/sort.h"
 
 
 
@@ -70,11 +71,8 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *);
 /* Initialise un nouvel objet partagé avec des informations. */
 static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *, const GDalvikArgsOperand *);
 
-/* Indique l'objet partagé correspond à une description donnée. */
-static gboolean g_dalvik_args_operand_compare_info(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
-
 /* Compare un opérande avec un autre. */
-static bool g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *, const GDalvikArgsOperand * const *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine *, AsmSyntax);
@@ -122,7 +120,6 @@ static void g_dalvik_args_operand_class_init(GDalvikArgsOperandClass *klass)
     object->finalize = (GObjectFinalizeFunc)g_dalvik_args_operand_finalize;
 
     operand->init = (init_shared_fc)g_dalvik_args_operand_do_init;
-    operand->cmp_info = (compare_shared_info_fc)g_dalvik_args_operand_compare_info;
 
     operand->compare = (operand_compare_fc)g_dalvik_args_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_args_operand_print;
@@ -253,30 +250,6 @@ static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *operand, const GDa
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = objet partagé à consulter.                         *
-*                fake    = coquille vide contenant les infos à comparer.      *
-*                                                                             *
-*  Description : Indique l'objet partagé correspond à une description donnée. *
-*                                                                             *
-*  Retour      : TRUE si les détails centraux sont partagés, FALSE sinon.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gboolean g_dalvik_args_operand_compare_info(const GDalvikArgsOperand *operand, const GDalvikArgsOperand *fake)
-{
-    gboolean result;                        /* Bilan à retourner           */
-
-    result = g_dalvik_args_operand_compare(operand, fake);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -288,20 +261,26 @@ static gboolean g_dalvik_args_operand_compare_info(const GDalvikArgsOperand *ope
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDalvikArgsOperand *b)
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *a, const GDalvikArgsOperand * const *b)
 {
-    bool result;                            /* Bilan à renvoyer            */
+    int result;                             /* Bilan à renvoyer            */
+    const GDalvikArgsOperand *_a;           /* Accès rapide à l'élément A  */
+    const GDalvikArgsOperand *_b;           /* Accès rapide à l'élément B  */
     size_t i;                               /* Boucle de parcours          */
 
-    if (b == NULL)
-        result = (a->count == 0);
+    _a = *a;
+    _b = *b;
+
+    if (_b == NULL)
+        result = sort_unsigned_long(_a->count, 0);
 
     else
     {
-        result = (a->count == b->count);
+        result = sort_unsigned_long(_a->count, _b->count);
 
-        for (i = 0; i < a->count && result; i++)
-            result = g_arch_operand_compare(a->args[i], b->args[i]);
+        for (i = 0; i < _a->count && result == 0; i++)
+            result = g_arch_operand_compare((const GArchOperand * const *)&_a->args[i],
+                                            (const GArchOperand * const *)&_b->args[i]);
 
     }
 
@@ -377,7 +356,8 @@ GDalvikArgsOperand *g_dalvik_args_operand_add(GDalvikArgsOperand *operand, GArch
 
     fake.args[i] = arg;
 
-    result = g_share_manager_update(_dalvik_args_operand_manager, G_SHARED_INSTANCE(operand), &fake, container);
+    result = g_share_manager_update(_dalvik_args_operand_manager, G_SHARED_INSTANCE(operand),
+                                    (GSharedInstance *)&fake, container);
 
     free(fake.args);
 
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index 4884867..be38ca3 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -33,6 +33,7 @@
 
 #include "../../operand-int.h"
 #include "../../sharing/manager.h"
+#include "../../../common/sort.h"
 #include "../../../format/dex/pool.h"
 
 
@@ -75,11 +76,8 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *);
 /* Initialise un nouvel objet partagé avec des informations. */
 static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *, const GDalvikPoolOperand *);
 
-/* Indique l'objet partagé correspond à une description donnée. */
-static gboolean g_dalvik_pool_operand_compare_info(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
-
 /* Compare un opérande avec un autre. */
-static bool g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *, const GDalvikPoolOperand * const *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *, AsmSyntax);
@@ -128,7 +126,6 @@ static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *klass)
     operand = G_ARCH_OPERAND_CLASS(klass);
 
     operand->init = (init_shared_fc)g_dalvik_pool_operand_do_init;
-    operand->cmp_info = (compare_shared_info_fc)g_dalvik_pool_operand_compare_info;
 
     operand->compare = (operand_compare_fc)g_dalvik_pool_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_pool_operand_print;
@@ -241,7 +238,7 @@ GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type,
     fake.type = type;
     fake.index = (size == MDS_8_BITS ? index8 : index16);
 
-    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_pool_operand_manager, &fake));
+    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
 
  gdpon_exit:
 
@@ -278,30 +275,6 @@ static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *operand, const GDa
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = objet partagé à consulter.                         *
-*                fake    = coquille vide contenant les infos à comparer.      *
-*                                                                             *
-*  Description : Indique l'objet partagé correspond à une description donnée. *
-*                                                                             *
-*  Retour      : TRUE si les détails centraux sont partagés, FALSE sinon.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gboolean g_dalvik_pool_operand_compare_info(const GDalvikPoolOperand *operand, const GDalvikPoolOperand *fake)
-{
-    gboolean result;                        /* Bilan à retourner           */
-
-    result = g_dalvik_pool_operand_compare(operand, fake);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -313,13 +286,22 @@ static gboolean g_dalvik_pool_operand_compare_info(const GDalvikPoolOperand *ope
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b)
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *a, const GDalvikPoolOperand * const *b)
 {
-    bool result;                            /* Bilan à renvoyer            */
+    int result;                             /* Bilan à renvoyer            */
+    const GDalvikPoolOperand *_a;           /* Accès rapide à l'élément A  */
+    const GDalvikPoolOperand *_b;           /* Accès rapide à l'élément B  */
+
+    _a = *a;
+    _b = *b;
+
+    result = sort_unsigned_long((unsigned long)_a->format, (unsigned long)_b->format);
+
+    if (result == 0)
+        result = sort_unsigned_long(_a->type, _b->type);
 
-    result = (a->format == b->format);
-    result &= (a->type == b->type);
-    result &= (a->index == b->index);
+    if (result == 0)
+        result = sort_unsigned_long(_a->index, _b->index);
 
     return result;
 
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index dcdcbac..613e0d4 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -65,13 +65,10 @@ static void g_dalvik_register_operand_dispose(GDalvikRegisterOperand *);
 static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *);
 
 /* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *, const GDalvikRegister *);
-
-/* Indique l'objet partagé correspond à une description donnée. */
-static gboolean g_dalvik_register_operand_compare_info(const GDalvikRegisterOperand *, const GDalvikRegister *);
+static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
 
 /* Compare un opérande avec un autre. */
-static bool g_dalvik_register_operand_compare(const GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *, const GDalvikRegisterOperand * const *);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBufferLine *, AsmSyntax);
@@ -120,7 +117,6 @@ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *kl
     operand = G_ARCH_OPERAND_CLASS(klass);
 
     operand->init = (init_shared_fc)g_dalvik_register_operand_do_init;
-    operand->cmp_info = (compare_shared_info_fc)g_dalvik_register_operand_compare_info;
 
     operand->compare = (operand_compare_fc)g_dalvik_register_operand_compare;
     operand->print = (operand_print_fc)g_dalvik_register_operand_print;
@@ -275,8 +271,11 @@ GArchOperand *g_dalvik_register_operand_new(const GBinContent *content, vmpa2t *
 GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
 {
     GArchOperand *result;                   /* Structure à retourner       */
+    GDalvikRegisterOperand fake;            /* Transport d'informations    */
+
+    fake.reg = reg;
 
-    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_register_operand_manager, reg));
+    result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
 
     return result;
 
@@ -286,7 +285,7 @@ GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = objet partagé à initialiser.                       *
-*                reg     = registre Dalvik à associer à l'opérande.           *
+*                fake    = coquille vide contenant les infos à enregistrer.   *
 *                                                                             *
 *  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
@@ -296,9 +295,9 @@ GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *operand, const GDalvikRegister *reg)
+static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *fake)
 {
-    operand->reg = reg;
+    operand->reg = fake->reg;
 
     return true;
 
@@ -307,30 +306,6 @@ static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *operand, c
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : operand = objet partagé à consulter.                         *
-*                reg     = registre Dalvik utilisé comme description.         *
-*                                                                             *
-*  Description : Indique l'objet partagé correspond à une description donnée. *
-*                                                                             *
-*  Retour      : TRUE si les détails centraux sont partagés, FALSE sinon.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gboolean g_dalvik_register_operand_compare_info(const GDalvikRegisterOperand *operand, const GDalvikRegister *reg)
-{
-    gboolean result;                        /* Bilan à retourner           */
-
-    result = g_arch_register_equal(G_ARCH_REGISTER(operand->reg), G_ARCH_REGISTER(reg));
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : a = premier opérande à consulter.                            *
 *                b = second opérande à consulter.                             *
 *                                                                             *
@@ -342,9 +317,13 @@ static gboolean g_dalvik_register_operand_compare_info(const GDalvikRegisterOper
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_register_operand_compare(const GDalvikRegisterOperand *a, const GDalvikRegisterOperand *b)
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *a, const GDalvikRegisterOperand * const *b)
 {
-    return (g_arch_register_compare(G_ARCH_REGISTER(a->reg), G_ARCH_REGISTER(b->reg)) == 0);
+    int result;                             /* Bilan à retourner           */
+
+    result = g_dalvik_register_compare(&(*a)->reg, &(*b)->reg);
+
+    return result;
 
 }
 
diff --git a/src/arch/dalvik/register.c b/src/arch/dalvik/register.c
index d455eb2..d11b4d0 100644
--- a/src/arch/dalvik/register.c
+++ b/src/arch/dalvik/register.c
@@ -29,6 +29,7 @@
 
 #include "../register-int.h"
 #include "../sharing/manager.h"
+#include "../../common/sort.h"
 
 
 
@@ -69,17 +70,11 @@ static void g_dalvik_register_dispose(GDalvikRegister *);
 static void g_dalvik_register_finalize(GDalvikRegister *);
 
 /* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_register_do_init(GDalvikRegister *, const uint16_t *);
-
-/* Indique l'objet partagé correspond à une description donnée. */
-static gboolean g_dalvik_register_compare_info(const GDalvikRegister *, const uint16_t *);
+static bool g_dalvik_register_do_init(GDalvikRegister *, const GDalvikRegister *);
 
 /* Produit une empreinte à partir d'un registre. */
 static guint g_dalvik_register_hash(const GDalvikRegister *);
 
-/* Compare un registre avec un autre. */
-static int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
-
 /* Traduit un registre en version humainement lisible. */
 static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *, AsmSyntax);
 
@@ -127,7 +122,6 @@ static void g_dalvik_register_class_init(GDalvikRegisterClass *klass)
     register_class = G_ARCH_REGISTER_CLASS(klass);
 
     register_class->init = (init_shared_fc)g_dalvik_register_do_init;
-    register_class->cmp_info = (compare_shared_info_fc)g_dalvik_register_compare_info;
 
     register_class->hash = (reg_hash_fc)g_dalvik_register_hash;
     register_class->compare = (reg_compare_fc)g_dalvik_register_compare;
@@ -207,8 +201,11 @@ static void g_dalvik_register_finalize(GDalvikRegister *reg)
 GDalvikRegister *g_dalvik_register_new(uint16_t index)
 {
     GDalvikRegister *result;                /* Structure à retourner       */
+    GDalvikRegister fake;                   /* Transport d'informations    */
+
+    fake.index = index;
 
-    result = G_DALVIK_REGISTER(g_share_manager_get(_dalvik_register_manager, &index));
+    result = G_DALVIK_REGISTER(g_share_manager_get(_dalvik_register_manager, (GSharedInstance *)&fake));
 
     return result;
 
@@ -217,8 +214,8 @@ GDalvikRegister *g_dalvik_register_new(uint16_t index)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg   = objet partagé à initialiser.                         *
-*                index = indice du registre correspondant.                    *
+*  Paramètres  : reg  = objet partagé à initialiser.                          *
+*                fake = coquille vide contenant les infos à enregistrer.      *
 *                                                                             *
 *  Description : Initialise un nouvel objet partagé avec des informations.    *
 *                                                                             *
@@ -228,9 +225,9 @@ GDalvikRegister *g_dalvik_register_new(uint16_t index)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_dalvik_register_do_init(GDalvikRegister *reg, const uint16_t *index)
+static bool g_dalvik_register_do_init(GDalvikRegister *reg, const GDalvikRegister *fake)
 {
-    reg->index = *index;
+    reg->index = fake->index;
 
     return true;
 
@@ -239,30 +236,6 @@ static bool g_dalvik_register_do_init(GDalvikRegister *reg, const uint16_t *inde
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : reg   = objet partagé à consulter.                           *
-*                index = indice du registre correspondant.                    *
-*                                                                             *
-*  Description : Indique l'objet partagé correspond à une description donnée. *
-*                                                                             *
-*  Retour      : TRUE si les détails centraux sont partagés, FALSE sinon.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gboolean g_dalvik_register_compare_info(const GDalvikRegister *reg, const uint16_t *index)
-{
-    gboolean result;                        /* Bilan à retourner           */
-
-    result = (reg->index == *index);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : reg = opérande à consulter pour le calcul.                   *
 *                                                                             *
 *  Description : Produit une empreinte à partir d'un registre.                *
@@ -282,37 +255,6 @@ static guint g_dalvik_register_hash(const GDalvikRegister *reg)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : a = premier opérande à consulter.                            *
-*                b = second opérande à consulter.                             *
-*                                                                             *
-*  Description : Compare un registre avec un autre.                           *
-*                                                                             *
-*  Retour      : Bilan de la comparaison.                                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
-{
-    int result;                             /* Bilan à retourner           */
-
-    if (a->index < b->index)
-        result = -1;
-
-    else if (a->index > b->index)
-        result = 1;
-
-    else
-        result = 0;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : reg    = registre à transcrire.                              *
 *                line   = ligne tampon où imprimer l'opérande donné.          *
 *                syntax = type de représentation demandée.                    *
@@ -370,6 +312,29 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un registre avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int g_dalvik_register_compare(const GDalvikRegister * const *a, const GDalvikRegister * const *b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = sort_unsigned_long((*a)->index, (*b)->index);
+
+    return result;
+
+}
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                            PARTAGES DE CONTENUS UNIQUES                            */
diff --git a/src/arch/dalvik/register.h b/src/arch/dalvik/register.h
index 03faf76..78523f7 100644
--- a/src/arch/dalvik/register.h
+++ b/src/arch/dalvik/register.h
@@ -61,6 +61,9 @@ GDalvikRegister *g_dalvik_register_new(uint16_t);
 /* Fournit l'indice d'un registre Dalvik. */
 uint16_t g_dalvik_register_get_index(const GDalvikRegister *);
 
+/* Compare un registre avec un autre. */
+int g_dalvik_register_compare(const GDalvikRegister * const *, const GDalvikRegister * const *);
+
 
 
 /* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */