/* 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" /* Définition d'un opérande visant un registre Dalvik (instance) */ struct _GDalvikRegisterOperand { GArchOperand parent; /* Instance parente */ 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 *); /* 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); /* 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); operand = G_ARCH_OPERAND_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_register_operand_dispose; object->finalize = (GObjectFinalizeFunc)g_dalvik_register_operand_finalize; 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 : binary = 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 : binary = 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) { GDalvikRegisterOperand *result; /* Structure à retourner */ uint8_t index8; /* Indice sur 8 bits */ uint16_t index16; /* Indice sur 16 bits */ bool test; /* Bilan de lecture */ 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) return NULL; result = g_object_new(G_TYPE_DALVIK_REGISTER_OPERAND, NULL); switch (size) { case MDS_4_BITS: case MDS_8_BITS: result->reg = g_dalvik_register_new(index8); break; case MDS_16_BITS: result->reg = g_dalvik_register_new(index16); break; default: break; } return G_ARCH_OPERAND(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) { GDalvikRegisterOperand *result; /* Structure à retourner */ result = g_object_new(G_TYPE_DALVIK_REGISTER_OPERAND, NULL); result->reg = reg; return G_ARCH_OPERAND(result); } /****************************************************************************** * * * 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 : - * * * ******************************************************************************/ GDalvikRegister *g_dalvik_register_operand_get(const GDalvikRegisterOperand *operand) { return 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 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 à 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; }