/* Chrysalide - Outil d'analyse de fichiers binaires * register.c - opérandes visant un registre Dalvik * * Copyright (C) 2010-2012 Cyrille Bagard * * This file is part of Chrysalide. * * Chrysalide is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * Chrysalide is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Foobar. If not, see . */ #include "register.h" #include "../../operand-int.h" #include "../../register.h" #include "../../sharing/manager.h" /* --------------------- MANIPULATION D'OPERANDES INDIVIDUELLES --------------------- */ /* Définition d'un opérande visant un registre Dalvik (instance) */ struct _GDalvikRegisterOperand { GArchOperand parent; /* Instance parente */ const GDalvikRegister *reg; /* Registre représenté */ bool is_written; /* Changement de contenu */ }; /* Définition d'un opérande visant un registre Dalvik (classe) */ struct _GDalvikRegisterOperandClass { GArchOperandClass parent; /* Classe parente */ }; /* Initialise la classe des opérandes de registre Dalvik. */ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *); /* Initialise une instance d'opérande de registre Dalvik. */ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *); /* Supprime toutes les références externes. */ static void g_dalvik_register_operand_dispose(GDalvikRegisterOperand *); /* Procède à la libération totale de la mémoire. */ 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 *); /* Compare un opérande avec un autre. */ static bool 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); /* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */ /* Gestionnaire des partages d'instances */ static GShareManager *_dalvik_register_operand_manager = NULL; /* ---------------------------------------------------------------------------------- */ /* MANIPULATION D'OPERANDES INDIVIDUELLES */ /* ---------------------------------------------------------------------------------- */ /* Indique le type défini par la GLib pour un opérande de registre Dalvik. */ G_DEFINE_TYPE(GDalvikRegisterOperand, g_dalvik_register_operand, G_TYPE_ARCH_OPERAND); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe des opérandes de registre Dalvik. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_dalvik_register_operand_class_init(GDalvikRegisterOperandClass *klass) { GObjectClass *object; /* Autre version de la classe */ GArchOperandClass *operand; /* Version de classe parente */ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_register_operand_dispose; object->finalize = (GObjectFinalizeFunc)g_dalvik_register_operand_finalize; 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; } /****************************************************************************** * * * Paramètres : operand = instance à initialiser. * * * * Description : Initialise une instance d'opérande de registre Dalvik. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_dalvik_register_operand_init(GDalvikRegisterOperand *operand) { operand->is_written = false; } /****************************************************************************** * * * Paramètres : operand = instance d'objet GLib à traiter. * * * * Description : Supprime toutes les références externes. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_dalvik_register_operand_dispose(GDalvikRegisterOperand *operand) { G_OBJECT_CLASS(g_dalvik_register_operand_parent_class)->dispose(G_OBJECT(operand)); } /****************************************************************************** * * * Paramètres : operand = instance d'objet GLib à traiter. * * * * Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_dalvik_register_operand_finalize(GDalvikRegisterOperand *operand) { G_OBJECT_CLASS(g_dalvik_register_operand_parent_class)->finalize(G_OBJECT(operand)); } /****************************************************************************** * * * Paramètres : content = flux de données à analyser. * * pos = position courante dans ce flux. [OUT] * * low = position éventuelle des 4 bits visés. [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 registre Dalvik. * * * * Retour : Opérande mis en place. * * * * Remarques : - * * * ******************************************************************************/ GArchOperand *g_dalvik_register_operand_new(const GBinContent *content, vmpa2t *pos, bool *low, 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 */ GDalvikRegister *reg; /* Registre à représenter */ result = NULL; switch (size) { case MDS_4_BITS: test = g_binary_content_read_u4(content, pos, low, &index8); break; 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 gdron_exit; switch (size) { case MDS_4_BITS: case MDS_8_BITS: reg = g_dalvik_register_new(index8); break; case MDS_16_BITS: reg = g_dalvik_register_new(index16); break; default: reg = NULL; break; } if (reg != NULL) { result = g_dalvik_register_operand_new_from_existing(reg); if (result == NULL) g_object_unref(G_OBJECT(reg)); } gdron_exit: return result; } /****************************************************************************** * * * Paramètres : reg = registre déjà en place. * * * * Description : Crée un opérande visant un registre Dalvik. * * * * Retour : Opérande mis en place. * * * * Remarques : - * * * ******************************************************************************/ GArchOperand *g_dalvik_register_operand_new_from_existing(GDalvikRegister *reg) { GArchOperand *result; /* Structure à retourner */ result = G_ARCH_OPERAND(g_share_manager_get(_dalvik_register_operand_manager, reg)); return result; } /****************************************************************************** * * * Paramètres : operand = objet partagé à initialiser. * * reg = registre Dalvik à associer à l'opérande. * * * * 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 GDalvikRegister *reg) { operand->reg = reg; return true; } /****************************************************************************** * * * 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. * * * * Description : Compare un opérande avec un autre. * * * * Retour : Bilan de la comparaison. * * * * Remarques : - * * * ******************************************************************************/ static bool g_dalvik_register_operand_compare(const GDalvikRegisterOperand *a, const GDalvikRegisterOperand *b) { return (g_arch_register_compare(G_ARCH_REGISTER(a->reg), G_ARCH_REGISTER(b->reg)) == 0); } /****************************************************************************** * * * 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. * * * * Retour : Représentation interne du registre. * * * * Remarques : - * * * ******************************************************************************/ const GDalvikRegister *g_dalvik_register_operand_get(const GDalvikRegisterOperand *operand) { return operand->reg; } /****************************************************************************** * * * Paramètres : operand = opérande représentant un registre à mettre à jour. * * * * Description : Marque l'opérande comme étant écrit plutôt que consulté. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_dalvik_register_operand_mark_as_written(GDalvikRegisterOperand *operand) { operand->is_written = true; } /****************************************************************************** * * * Paramètres : operand = opérande représentant un registre à consulter. * * * * Description : Indique le type d'accès réalisé sur l'opérande. * * * * Retour : Type d'accès : true en cas d'écriture, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool g_dalvik_register_operand_is_written(const GDalvikRegisterOperand *operand) { return operand->is_written; } /* ---------------------------------------------------------------------------------- */ /* PARTAGES DE CONTENUS UNIQUES */ /* ---------------------------------------------------------------------------------- */ /****************************************************************************** * * * Paramètres : - * * * * Description : Met en place les mécanismes de partage des opérandes Dalvik. * * * * Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ bool init_dalvik_register_operand_sharing(void) { _dalvik_register_operand_manager = g_share_manager_new(G_TYPE_DALVIK_REGISTER_OPERAND); return true; } /****************************************************************************** * * * Paramètres : - * * * * Description : Imprime des statistiques quant aux partages dans l'archi. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ #ifdef DEBUG_DUMP_STATS void dump_dalvik_register_operand_share_stats(void) { g_share_manager_dump_stats(_dalvik_register_operand_manager); } #endif /****************************************************************************** * * * Paramètres : - * * * * Description : Supprime les mécanismes de partage des opérandes Dalvik. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void exit_dalvik_register_operand_sharing(void) { g_object_unref(G_OBJECT(_dalvik_register_operand_manager)); }