summaryrefslogtreecommitdiff
path: root/src/arch/dalvik
diff options
context:
space:
mode:
Diffstat (limited to 'src/arch/dalvik')
-rw-r--r--src/arch/dalvik/operands/args.c54
-rw-r--r--src/arch/dalvik/operands/pool.c52
-rw-r--r--src/arch/dalvik/operands/register.c51
-rw-r--r--src/arch/dalvik/register.c101
-rw-r--r--src/arch/dalvik/register.h3
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 -------------------------- */
generated by cgit v0.11.2-87-g4458 at 2024-12-26 17:01:27 (GMT)