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.c154
-rw-r--r--src/arch/dalvik/operands/pool.c172
-rw-r--r--src/arch/dalvik/operands/register.c194
-rw-r--r--src/arch/dalvik/register.c101
-rw-r--r--src/arch/dalvik/register.h2
5 files changed, 414 insertions, 209 deletions
diff --git a/src/arch/dalvik/operands/args.c b/src/arch/dalvik/operands/args.c
index 8a687db..2092e6b 100644
--- a/src/arch/dalvik/operands/args.c
+++ b/src/arch/dalvik/operands/args.c
@@ -69,10 +69,16 @@ static void g_dalvik_args_operand_dispose(GDalvikArgsOperand *);
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 *);
+static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *, const GDalvikArgsOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
+
+/* Libère la mémoire utilisée par un patron d'instance. */
+static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *, GDalvikArgsOperand *);
/* Compare un opérande avec un autre. */
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *, const GDalvikArgsOperand * const *);
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *, const GDalvikArgsOperand *);
/* Traduit un opérande en version humainement lisible. */
static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine *, AsmSyntax);
@@ -86,6 +92,10 @@ static void g_dalvik_args_operand_print(const GDalvikArgsOperand *, GBufferLine
static GShareManager *_dalvik_args_operand_manager = NULL;
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_args_operand_share_manager(void);
+
+
/* ---------------------------------------------------------------------------------- */
/* MANIPULATION D'OPERANDES INDIVIDUELLES */
@@ -119,7 +129,11 @@ static void g_dalvik_args_operand_class_init(GDalvikArgsOperandClass *klass)
object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_args_operand_dispose;
object->finalize = (GObjectFinalizeFunc)g_dalvik_args_operand_finalize;
- operand->init = (operand_do_init_fc)g_dalvik_args_operand_do_init;
+ operand->get_manager = (get_operand_manager_fc)get_dalvik_args_operand_share_manager;
+
+ operand->apply_template = (apply_operand_template_fc)g_dalvik_args_operand_apply_template;
+ operand->define_template = (define_operand_template_fc)g_dalvik_args_operand_define_template;
+ operand->free_template = (free_operand_template_fc)g_dalvik_args_operand_free_template;
operand->compare = (operand_compare_fc)g_dalvik_args_operand_compare;
operand->print = (operand_print_fc)g_dalvik_args_operand_print;
@@ -190,62 +204,95 @@ static void g_dalvik_args_operand_finalize(GDalvikArgsOperand *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_dalvik_args_operand_new(void)
+static bool g_dalvik_args_operand_apply_template(GDalvikArgsOperand *operand, const GDalvikArgsOperand *template)
{
- GArchOperand *result; /* Structure à retourner */
+ size_t i; /* Boucle de parcours */
+
+ if (template == NULL)
+ {
+ operand->args = NULL;
+ operand->count = 0;
+ }
- result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_args_operand_manager, NULL));
+ else
+ {
+ g_dalvik_args_operand_define_template(template, operand);
- return result;
+ for (i = 0; i < operand->count; i++)
+ g_object_ref(G_OBJECT(operand->args[i]));
+
+ }
+
+ return true;
}
/******************************************************************************
* *
-* Paramètres : operand = objet partagé à initialiser. *
-* fake = coquille vide contenant les infos à enregistrer. *
+* Paramètres : operand = objet partagé à consulter. *
+* template = informations à retrouver intégralement. *
* *
-* Description : Initialise un nouvel objet partagé avec des informations. *
+* Description : Réalise une copie minimale d'un contenu partagé. *
* *
-* Retour : Bilan de l'opération. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *operand, const GDalvikArgsOperand *fake)
+static void g_dalvik_args_operand_define_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
{
size_t i; /* Boucle de parcours */
- if (fake == NULL)
+ if (operand->count == 0)
{
- operand->args = NULL;
- operand->count = 0;
+ template->args = NULL;
+ template->count = 0;
}
else
{
- operand->args = (GArchOperand **)calloc(fake->count, sizeof(GArchOperand *));
+ template->args = (GArchOperand **)calloc(operand->count, sizeof(GArchOperand *));
- for (i = 0; i < fake->count; i++)
- operand->args[i] = fake->args[i];
+ for (i = 0; i < operand->count; i++)
+ template->args[i] = operand->args[i];
- operand->count = fake->count;
+ template->count = operand->count;
}
- return true;
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = objet partagé à consulter. *
+* template = informations dont le contenu est à libérer. *
+* *
+* Description : Libère la mémoire utilisée par un patron d'instance. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dalvik_args_operand_free_template(const GDalvikArgsOperand *operand, GDalvikArgsOperand *template)
+{
+ if (template != NULL && template->args != NULL)
+ free(template->args);
}
@@ -263,26 +310,21 @@ static bool g_dalvik_args_operand_do_init(GDalvikArgsOperand *operand, const GDa
* *
******************************************************************************/
-static int g_dalvik_args_operand_compare(const GDalvikArgsOperand * const *a, const GDalvikArgsOperand * const *b)
+static int g_dalvik_args_operand_compare(const GDalvikArgsOperand *a, const GDalvikArgsOperand *b)
{
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 */
- _a = *a;
- _b = *b;
-
- if (_b == NULL)
- result = sort_unsigned_long(_a->count, 0);
+ /* Création de l'objet... */
+ if (b == NULL)
+ result = 1;
else
{
- result = sort_unsigned_long(_a->count, _b->count);
+ result = sort_unsigned_long(a->count, b->count);
- 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]);
+ for (i = 0; i < a->count && result == 0; i++)
+ result = g_arch_operand_compare(a->args[i], b->args[i]);
}
@@ -333,6 +375,29 @@ static void g_dalvik_args_operand_print(const GDalvikArgsOperand *operand, GBuff
/******************************************************************************
* *
+* Paramètres : - *
+* *
+* Description : Crée un réceptacle pour opérandes Dalvik servant d'arguments.*
+* *
+* Retour : Opérande mis en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GArchOperand *g_dalvik_args_operand_new(void)
+{
+ GArchOperand *result; /* Structure à retourner */
+
+ result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_args_operand_manager, NULL));
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : operand = opérande à compléter. *
* arg = nouvel argument pour un appel. *
* *
@@ -419,6 +484,25 @@ GArchOperand *g_dalvik_args_operand_get(const GDalvikArgsOperand *operand, size_
* *
* Paramètres : - *
* *
+* Description : Fournit le gestionnaire de partages attribué à un type. *
+* *
+* Retour : Gestionnaire de partages en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GShareManager *get_dalvik_args_operand_share_manager(void)
+{
+ return _dalvik_args_operand_manager;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
* Description : Met en place les mécanismes de partage des opérandes Dalvik. *
* *
* Retour : Bilan de l'opération. *
diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c
index fa7ed54..d97c93b 100644
--- a/src/arch/dalvik/operands/pool.c
+++ b/src/arch/dalvik/operands/pool.c
@@ -74,10 +74,13 @@ static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *);
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 *);
+static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *, const GDalvikPoolOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *, GDalvikPoolOperand *);
/* Compare un opérande avec un autre. */
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *, const GDalvikPoolOperand * const *);
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *);
/* Traduit un opérande en version humainement lisible. */
static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *, AsmSyntax);
@@ -91,6 +94,10 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine
static GShareManager *_dalvik_pool_operand_manager = NULL;
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_pool_operand_share_manager(void);
+
+
/* ---------------------------------------------------------------------------------- */
/* MANIPULATION D'OPERANDES INDIVIDUELLES */
@@ -125,7 +132,11 @@ static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *klass)
operand = G_ARCH_OPERAND_CLASS(klass);
- operand->init = (operand_do_init_fc)g_dalvik_pool_operand_do_init;
+ operand->get_manager = (get_operand_manager_fc)get_dalvik_pool_operand_share_manager;
+
+ operand->apply_template = (apply_operand_template_fc)g_dalvik_pool_operand_apply_template;
+ operand->define_template = (define_operand_template_fc)g_dalvik_pool_operand_define_template;
+ operand->free_template = (free_operand_template_fc)NULL;
operand->compare = (operand_compare_fc)g_dalvik_pool_operand_compare;
operand->print = (operand_print_fc)g_dalvik_pool_operand_print;
@@ -193,82 +204,47 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
/******************************************************************************
* *
-* Paramètres : format = format du fichier contenant le code. *
-* type = type de table visée avec la référence. *
-* content = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* size = taille de l'opérande, et donc du registre. *
-* endian = ordre des bits dans la source. *
+* Paramètres : operand = objet partagé à initialiser. *
+* template = information à utiliser pour la mise en place. *
* *
-* Description : Crée un opérande visant un élément constant Dalvik. *
+* Description : Initialise un nouvel objet partagé avec des informations. *
* *
-* Retour : Opérande mis en place. *
+* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
-GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
+static bool g_dalvik_pool_operand_apply_template(GDalvikPoolOperand *operand, const GDalvikPoolOperand *template)
{
- GArchOperand *result; /* Structure à retourner */
- uint8_t index8; /* Indice sur 8 bits */
- uint16_t index16; /* Indice sur 16 bits */
- bool test; /* Bilan de lecture */
- GDalvikPoolOperand fake; /* Transport d'informations */
+ g_dalvik_pool_operand_define_template(template, operand);
- result = NULL;
+ g_object_ref(G_OBJECT(operand->format));
- switch (size)
- {
- case MDS_8_BITS:
- test = g_binary_content_read_u8(content, pos, &index8);
- break;
- case MDS_16_BITS:
- test = g_binary_content_read_u16(content, pos, endian, &index16);
- break;
- default:
- test = false;
- break;
- }
-
- if (!test)
- goto gdpon_exit;
-
- fake.format = format;
- fake.type = type;
- fake.index = (size == MDS_8_BITS ? index8 : index16);
-
- result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
-
- gdpon_exit:
-
- return result;
+ return true;
}
/******************************************************************************
* *
-* Paramètres : operand = objet partagé à initialiser. *
-* fake = coquille vide contenant les infos à enregistrer. *
+* Paramètres : operand = objet partagé à consulter. *
+* template = informations à retrouver intégralement. *
* *
-* Description : Initialise un nouvel objet partagé avec des informations. *
+* Description : Réalise une copie minimale d'un contenu partagé. *
* *
-* Retour : Bilan de l'opération. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *operand, const GDalvikPoolOperand *fake)
+static void g_dalvik_pool_operand_define_template(const GDalvikPoolOperand *operand, GDalvikPoolOperand *template)
{
- operand->format = fake->format;
- g_object_ref(G_OBJECT(fake->format));
-
- operand->type = fake->type;
- operand->index = fake->index;
+ template->format = operand->format;
- return true;
+ template->type = operand->type;
+ template->index = operand->index;
}
@@ -286,22 +262,17 @@ static bool g_dalvik_pool_operand_do_init(GDalvikPoolOperand *operand, const GDa
* *
******************************************************************************/
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand * const *a, const GDalvikPoolOperand * const *b)
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b)
{
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);
+ result = sort_unsigned_long((unsigned long)a->format, (unsigned long)b->format);
if (result == 0)
- result = sort_unsigned_long(_a->type, _b->type);
+ result = sort_unsigned_long(a->type, b->type);
if (result == 0)
- result = sort_unsigned_long(_a->index, _b->index);
+ result = sort_unsigned_long(a->index, b->index);
return result;
@@ -471,6 +442,62 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
/******************************************************************************
* *
+* Paramètres : format = format du fichier contenant le code. *
+* type = type de table visée avec la référence. *
+* content = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* size = taille de l'opérande, et donc du registre. *
+* endian = ordre des bits dans la source. *
+* *
+* Description : Crée un opérande visant un élément constant Dalvik. *
+* *
+* Retour : Opérande mis en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
+{
+ GArchOperand *result; /* Structure à retourner */
+ uint8_t index8; /* Indice sur 8 bits */
+ uint16_t index16; /* Indice sur 16 bits */
+ bool test; /* Bilan de lecture */
+ GDalvikPoolOperand fake; /* Transport d'informations */
+
+ result = NULL;
+
+ switch (size)
+ {
+ case MDS_8_BITS:
+ test = g_binary_content_read_u8(content, pos, &index8);
+ break;
+ case MDS_16_BITS:
+ test = g_binary_content_read_u16(content, pos, endian, &index16);
+ break;
+ default:
+ test = false;
+ break;
+ }
+
+ if (!test)
+ goto gdpon_exit;
+
+ fake.format = format;
+ fake.type = type;
+ fake.index = (size == MDS_8_BITS ? index8 : index16);
+
+ result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_pool_operand_manager, (GSharedInstance *)&fake));
+
+ gdpon_exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : operand = opérande à consulter. *
* *
* Description : Indique la nature de la table de constantes visée ici. *
@@ -517,6 +544,25 @@ uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
* *
* Paramètres : - *
* *
+* Description : Fournit le gestionnaire de partages attribué à un type. *
+* *
+* Retour : Gestionnaire de partages en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GShareManager *get_dalvik_pool_operand_share_manager(void)
+{
+ return _dalvik_pool_operand_manager;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
* Description : Met en place les mécanismes de partage des opérandes Dalvik. *
* *
* Retour : Bilan de l'opération. *
diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c
index b415d3f..cf29455 100644
--- a/src/arch/dalvik/operands/register.c
+++ b/src/arch/dalvik/operands/register.c
@@ -65,10 +65,13 @@ 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 GDalvikRegisterOperand *);
+static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
+
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *, GDalvikRegisterOperand *);
/* Compare un opérande avec un autre. */
-static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *, const GDalvikRegisterOperand * const *);
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand *, const GDalvikRegisterOperand *);
/* Traduit un opérande en version humainement lisible. */
static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBufferLine *, AsmSyntax);
@@ -82,6 +85,10 @@ static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBuf
static GShareManager *_dalvik_register_operand_manager = NULL;
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_register_operand_share_manager(void);
+
+
/* ---------------------------------------------------------------------------------- */
/* MANIPULATION D'OPERANDES INDIVIDUELLES */
@@ -116,7 +123,11 @@ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *kl
operand = G_ARCH_OPERAND_CLASS(klass);
- operand->init = (operand_do_init_fc)g_dalvik_register_operand_do_init;
+ operand->get_manager = (get_operand_manager_fc)get_dalvik_register_operand_share_manager;
+
+ operand->apply_template = (apply_operand_template_fc)g_dalvik_register_operand_apply_template;
+ operand->define_template = (define_operand_template_fc)g_dalvik_register_operand_define_template;
+ operand->free_template = (free_operand_template_fc)NULL;
operand->compare = (operand_compare_fc)g_dalvik_register_operand_compare;
operand->print = (operand_print_fc)g_dalvik_register_operand_print;
@@ -183,6 +194,95 @@ static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *operand)
/******************************************************************************
* *
+* Paramètres : operand = objet partagé à initialiser. *
+* template = information à utiliser pour la mise en place. *
+* *
+* Description : Initialise un nouvel objet partagé avec des informations. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_dalvik_register_operand_apply_template(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *template)
+{
+ g_dalvik_register_operand_define_template(template, operand);
+
+ g_object_ref(G_OBJECT(operand->reg));
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = objet partagé à consulter. *
+* template = informations à retrouver intégralement. *
+* *
+* Description : Réalise une copie minimale d'un contenu partagé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dalvik_register_operand_define_template(const GDalvikRegisterOperand *operand, GDalvikRegisterOperand *template)
+{
+ template->reg = operand->reg;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : a = premier opérande à consulter. *
+* b = second opérande à consulter. *
+* *
+* Description : Compare un opérande avec un autre. *
+* *
+* Retour : Bilan de la comparaison. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand *a, const GDalvikRegisterOperand *b)
+{
+ int result; /* Bilan à retourner */
+
+ result = g_dalvik_register_compare(a->reg, b->reg);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à traiter. *
+* line = ligne tampon où imprimer l'opérande donné. *
+* syntax = type de représentation demandée. *
+* *
+* Description : Traduit un opérande en version humainement lisible. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+ g_arch_register_print(G_ARCH_REGISTER(operand->reg), line, syntax);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : content = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* low = position éventuelle des 4 bits visés. [OUT] *
@@ -275,53 +375,7 @@ GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg)
fake.reg = reg;
- result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : operand = objet partagé à initialiser. *
-* fake = coquille vide contenant les infos à enregistrer. *
-* *
-* Description : Initialise un nouvel objet partagé avec des informations. *
-* *
-* Retour : Bilan de l'opération. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool g_dalvik_register_operand_do_init(GDalvikRegisterOperand *operand, const GDalvikRegisterOperand *fake)
-{
- operand->reg = fake->reg;
-
- return true;
-
-}
-
-
-/******************************************************************************
-* *
-* 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_dalvik_register_operand_compare(const GDalvikRegisterOperand * const *a, const GDalvikRegisterOperand * const *b)
-{
- int result; /* Bilan à retourner */
-
- result = g_dalvik_register_compare(&(*a)->reg, &(*b)->reg);
+ result = G_ARCH_OPERAND(g_share_manager_build(_dalvik_register_operand_manager, (GSharedInstance *)&fake));
return result;
@@ -330,27 +384,6 @@ static int g_dalvik_register_operand_compare(const GDalvikRegisterOperand * cons
/******************************************************************************
* *
-* Paramètres : operand = opérande à traiter. *
-* line = ligne tampon où imprimer l'opérande donné. *
-* syntax = type de représentation demandée. *
-* *
-* Description : Traduit un opérande en version humainement lisible. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
-{
- g_arch_register_print(G_ARCH_REGISTER(operand->reg), line, syntax);
-
-}
-
-
-/******************************************************************************
-* *
* Paramètres : operand = opérande représentant un registre. *
* *
* Description : Fournit le registre Dalvik associé à l'opérande. *
@@ -416,6 +449,25 @@ bool g_dalvik_register_operand_is_written(const GDalvikRegisterOperand *operand)
* *
* Paramètres : - *
* *
+* Description : Fournit le gestionnaire de partages attribué à un type. *
+* *
+* Retour : Gestionnaire de partages en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GShareManager *get_dalvik_register_operand_share_manager(void)
+{
+ return _dalvik_register_operand_manager;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
* Description : Met en place les mécanismes de partage des opérandes Dalvik. *
* *
* Retour : Bilan de l'opération. *
diff --git a/src/arch/dalvik/register.c b/src/arch/dalvik/register.c
index 45b2224..2b5a285 100644
--- a/src/arch/dalvik/register.c
+++ b/src/arch/dalvik/register.c
@@ -69,8 +69,8 @@ static void g_dalvik_register_dispose(GDalvikRegister *);
/* Procède à la libération totale de la mémoire. */
static void g_dalvik_register_finalize(GDalvikRegister *);
-/* Initialise un nouvel objet partagé avec des informations. */
-static bool g_dalvik_register_do_init(GDalvikRegister *, const GDalvikRegister *);
+/* Réalise une copie minimale d'un contenu partagé. */
+static void g_dalvik_register_define_template(const GDalvikRegister *, GDalvikRegister *);
/* Produit une empreinte à partir d'un registre. */
static guint g_dalvik_register_hash(const GDalvikRegister *);
@@ -87,6 +87,10 @@ static void g_dalvik_register_print(const GDalvikRegister *, GBufferLine *, AsmS
static GShareManager *_dalvik_register_manager = NULL;
+/* Fournit le gestionnaire de partages attribué à un type. */
+static GShareManager *get_dalvik_register_share_manager(void);
+
+
/* ---------------------------------------------------------------------------------- */
/* ENCADREMENT DE REGISTRES BRUTS */
@@ -121,7 +125,9 @@ 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->get_manager = (get_register_manager_fc)get_dalvik_register_share_manager;
+
+ register_class->define_template = (define_register_template_fc)g_dalvik_register_define_template;
register_class->hash = (reg_hash_fc)g_dalvik_register_hash;
register_class->compare = (reg_compare_fc)g_dalvik_register_compare;
@@ -188,48 +194,20 @@ static void g_dalvik_register_finalize(GDalvikRegister *reg)
/******************************************************************************
* *
-* Paramètres : index = indice du registre correspondant. *
-* *
-* Description : Crée une réprésentation de registre Dalvik. *
-* *
-* Retour : Adresse de la structure mise en place. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-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, (GSharedInstance *)&fake));
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : reg = objet partagé à initialiser. *
-* fake = coquille vide contenant les infos à enregistrer. *
+* Paramètres : reg = objet partagé à consulter. *
+* template = informations à retrouver intégralement. *
* *
-* Description : Initialise un nouvel objet partagé avec des informations. *
+* Description : Réalise une copie minimale d'un contenu partagé. *
* *
-* Retour : Bilan de l'opération. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static bool g_dalvik_register_do_init(GDalvikRegister *reg, const GDalvikRegister *fake)
+static void g_dalvik_register_define_template(const GDalvikRegister *reg, GDalvikRegister *template)
{
- reg->index = fake->index;
-
- return true;
+ template->index = reg->index;
}
@@ -295,6 +273,32 @@ static void g_dalvik_register_print(const GDalvikRegister *reg, GBufferLine *lin
/******************************************************************************
* *
+* Paramètres : index = indice du registre correspondant. *
+* *
+* Description : Crée une réprésentation de registre Dalvik. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDalvikRegister *g_dalvik_register_new(uint16_t index)
+{
+ GDalvikRegister *result; /* Structure à retourner */
+ GDalvikRegister template; /* Transport d'informations */
+
+ template.index = index;
+
+ result = G_DALVIK_REGISTER(g_share_manager_build(_dalvik_register_manager, (GSharedInstance *)&template));
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : reg = registre à consulter. *
* *
* Description : Fournit l'indice d'un registre Dalvik. *
@@ -325,11 +329,11 @@ uint16_t g_dalvik_register_get_index(const GDalvikRegister *reg)
* *
******************************************************************************/
-int g_dalvik_register_compare(const GDalvikRegister * const *a, const GDalvikRegister * const *b)
+int g_dalvik_register_compare(const GDalvikRegister *a, const GDalvikRegister *b)
{
int result; /* Bilan à retourner */
- result = sort_unsigned_long((*a)->index, (*b)->index);
+ result = sort_unsigned_long(a->index, b->index);
return result;
@@ -345,6 +349,25 @@ int g_dalvik_register_compare(const GDalvikRegister * const *a, const GDalvikReg
* *
* Paramètres : - *
* *
+* Description : Fournit le gestionnaire de partages attribué à un type. *
+* *
+* Retour : Gestionnaire de partages en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GShareManager *get_dalvik_register_share_manager(void)
+{
+ return _dalvik_register_manager;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
* Description : Met en place les mécanismes de partage des registres Dalvik. *
* *
* Retour : Bilan de l'opération. *
diff --git a/src/arch/dalvik/register.h b/src/arch/dalvik/register.h
index 136741c..3bd6286 100644
--- a/src/arch/dalvik/register.h
+++ b/src/arch/dalvik/register.h
@@ -62,7 +62,7 @@ GDalvikRegister *g_dalvik_register_new(uint16_t);
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 *);
+int g_dalvik_register_compare(const GDalvikRegister *, const GDalvikRegister *);
generated by cgit v0.11.2-87-g4458 at 2024-12-26 04:24:37 (GMT)