Improve the object padding exploitation for operands.

3 files changed, 92 insertions, 18 deletions

diff --git a/plugins/dalvik/operand.c b/plugins/dalvik/operand.c
index a176721..4db8fa9 100644
--- a/plugins/dalvik/operand.c
+++ b/plugins/dalvik/operand.c
@@ -749,7 +749,7 @@ void dalvik_mark_first_operand_as_written(GArchInstruction *instr)
 
     operand = g_arch_instruction_get_operand(instr, 0);
 
-    g_register_operand_mark_as_written(G_REGISTER_OPERAND(operand));
+    g_arch_operand_set_flag(operand, ROF_IS_WRITTEN);
 
     g_object_unref(G_OBJECT(operand));
 
diff --git a/plugins/dalvik/operands/args.c b/plugins/dalvik/operands/args.c
index 2c7bc57..9aa948d 100644
--- a/plugins/dalvik/operands/args.c
+++ b/plugins/dalvik/operands/args.c
@@ -69,7 +69,7 @@ static void g_dalvik_args_operand_dispose(GDalvikArgsOperand *);
 static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *);
 
 /* Compare un opérande avec un autre. */
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *, bool);
 
 /* Détermine le chemin conduisant à un opérande interne. */
 static char *g_dalvik_args_operand_find_inner_operand_path(const GDalvikArgsOperand *, const GArchOperand *);
@@ -92,7 +92,7 @@ static GArchOperand **g_dalvik_args_operand_list_inner_instances(const GDalvikAr
 static void g_dalvik_args_operand_update_inner_instances(GDalvikArgsOperand *, GArchOperand **, size_t);
 
 /* Fournit l'empreinte d'un candidat à une centralisation. */
-static guint g_dalvik_args_operand_hash(const GDalvikArgsOperand *);
+static guint g_dalvik_args_operand_hash(const GDalvikArgsOperand *, bool);
 
 
 
@@ -219,8 +219,9 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : a = premier opérande à consulter.                            *
-*                b = second opérande à consulter.                             *
+*  Paramètres  : a    = premier opérande à consulter.                         *
+*                b    = second opérande à consulter.                          *
+*                lock = précise le besoin en verrouillage.                    *
 *                                                                             *
 *  Description : Compare un opérande avec un autre.                           *
 *                                                                             *
@@ -230,10 +231,13 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDalvikArgsOperand *b)
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDalvikArgsOperand *b, bool lock)
 {
     int result;                             /* Bilan à renvoyer            */
+    lockable_obj_extra_t *ea;               /* Données insérées à consulter*/
+    lockable_obj_extra_t *eb;               /* Données insérées à consulter*/
     size_t i;                               /* Boucle de parcours          */
+    GArchOperandClass *class;               /* Classe parente normalisée   */
 
     /* Création de l'objet... */
     if (b == NULL)
@@ -241,11 +245,32 @@ static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDal
 
     else
     {
+        ea = GET_GOBJECT_EXTRA(G_OBJECT(a), lockable_obj_extra_t);
+        eb = GET_GOBJECT_EXTRA(G_OBJECT(b), lockable_obj_extra_t);
+
+        if (lock)
+        {
+            LOCK_GOBJECT_EXTRA(ea);
+            LOCK_GOBJECT_EXTRA(eb);
+        }
+
         result = sort_unsigned_long(a->count, b->count);
 
         for (i = 0; i < a->count && result == 0; i++)
             result = g_arch_operand_compare(a->args[i], b->args[i]);
 
+        if (result == 0)
+        {
+            class = G_ARCH_OPERAND_CLASS(g_dalvik_args_operand_parent_class);
+            result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
+        }
+
+        if (lock)
+        {
+            UNLOCK_GOBJECT_EXTRA(eb);
+            UNLOCK_GOBJECT_EXTRA(ea);
+        }
+
     }
 
     return result;
@@ -575,6 +600,7 @@ static void g_dalvik_args_operand_update_inner_instances(GDalvikArgsOperand *ope
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = objet dont l'instance se veut unique.              *
+*                lock    = précise le besoin en verrouillage.                 *
 *                                                                             *
 *  Description : Fournit l'empreinte d'un candidat à une centralisation.      *
 *                                                                             *
@@ -584,11 +610,24 @@ static void g_dalvik_args_operand_update_inner_instances(GDalvikArgsOperand *ope
 *                                                                             *
 ******************************************************************************/
 
-static guint g_dalvik_args_operand_hash(const GDalvikArgsOperand *operand)
+static guint g_dalvik_args_operand_hash(const GDalvikArgsOperand *operand, bool lock)
 {
     guint result;                           /* Valeur à retourner          */
+    lockable_obj_extra_t *extra;            /* Données insérées à consulter*/
+    GArchOperandClass *class;               /* Classe parente normalisée   */
+
+    extra = GET_GOBJECT_EXTRA(G_OBJECT(operand), lockable_obj_extra_t);
+
+    if (lock)
+        LOCK_GOBJECT_EXTRA(extra);
+
+    class = G_ARCH_OPERAND_CLASS(g_dalvik_args_operand_parent_class);
+    result = class->hash(G_ARCH_OPERAND(operand), false);
+
+    result ^= operand->count;
 
-    result = operand->count;
+    if (lock)
+        UNLOCK_GOBJECT_EXTRA(extra);
 
     return result;
 
diff --git a/plugins/dalvik/operands/pool.c b/plugins/dalvik/operands/pool.c
index baab1f6..acec518 100644
--- a/plugins/dalvik/operands/pool.c
+++ b/plugins/dalvik/operands/pool.c
@@ -75,7 +75,7 @@ static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *);
 static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *);
 
 /* Compare un opérande avec un autre. */
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *, bool);
 
 /* Traduit un opérande en version humainement lisible. */
 static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *);
@@ -86,7 +86,7 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine
 
 
 /* Fournit l'empreinte d'un candidat à une centralisation. */
-static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *);
+static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *, bool);
 
 
 
@@ -230,8 +230,9 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : a = premier opérande à consulter.                            *
-*                b = second opérande à consulter.                             *
+*  Paramètres  : a    = premier opérande à consulter.                         *
+*                b    = second opérande à consulter.                          *
+*                lock = précise le besoin en verrouillage.                    *
 *                                                                             *
 *  Description : Compare un opérande avec un autre.                           *
 *                                                                             *
@@ -241,9 +242,21 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b)
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b, bool lock)
 {
     int result;                             /* Bilan à renvoyer            */
+    lockable_obj_extra_t *ea;               /* Données insérées à consulter*/
+    lockable_obj_extra_t *eb;               /* Données insérées à consulter*/
+    GArchOperandClass *class;               /* Classe parente normalisée   */
+
+    ea = GET_GOBJECT_EXTRA(G_OBJECT(a), lockable_obj_extra_t);
+    eb = GET_GOBJECT_EXTRA(G_OBJECT(b), lockable_obj_extra_t);
+
+    if (lock)
+    {
+        LOCK_GOBJECT_EXTRA(ea);
+        LOCK_GOBJECT_EXTRA(eb);
+    }
 
     result = sort_unsigned_long((unsigned long)a->format, (unsigned long)b->format);
 
@@ -253,6 +266,18 @@ static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDal
     if (result == 0)
         result = sort_unsigned_long(a->index, b->index);
 
+    if (result == 0)
+    {
+        class = G_ARCH_OPERAND_CLASS(g_dalvik_pool_operand_parent_class);
+        result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b), false);
+    }
+
+    if (lock)
+    {
+        UNLOCK_GOBJECT_EXTRA(eb);
+        UNLOCK_GOBJECT_EXTRA(ea);
+    }
+
     return result;
 
 }
@@ -547,6 +572,7 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = objet dont l'instance se veut unique.              *
+*                lock    = précise le besoin en verrouillage.                 *
 *                                                                             *
 *  Description : Fournit l'empreinte d'un candidat à une centralisation.      *
 *                                                                             *
@@ -556,17 +582,23 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
 *                                                                             *
 ******************************************************************************/
 
-static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand)
+static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand, bool lock)
 {
     guint result;                           /* Valeur à retourner          */
+    lockable_obj_extra_t *extra;            /* Données insérées à consulter*/
+    GArchOperandClass *class;               /* Classe parente normalisée   */
     DalvikPoolType type;                    /* Type porté par l'opérande   */
     uint32_t index;                         /* Indice de l'élément         */
 
-    result = (unsigned int)(unsigned long)operand->format;
+    extra = GET_GOBJECT_EXTRA(G_OBJECT(operand), lockable_obj_extra_t);
 
-#if __SIZEOF_INT__ != __SIZEOF_LONG__
-    result ^= ((unsigned long)operand->format) >> 32;
-#endif
+    if (lock)
+        LOCK_GOBJECT_EXTRA(extra);
+
+    class = G_ARCH_OPERAND_CLASS(g_dalvik_pool_operand_parent_class);
+    result = class->hash(G_ARCH_OPERAND(operand), false);
+
+    result ^= g_direct_hash(operand->format);
 
     type = g_dalvik_pool_operand_get_pool_type(operand);
 
@@ -576,6 +608,9 @@ static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand)
 
     result ^= index;
 
+    if (lock)
+        UNLOCK_GOBJECT_EXTRA(extra);
+
     return result;
 
 }