path: root/src/arch/register.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * registers.c - aides auxiliaires relatives aux registres Dalvik
 *
 * Copyright (C) 2012-2017 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 <http://www.gnu.org/licenses/>.
 */


#include "register.h"


#include "register-int.h"



/* ---------------------------- PUR REGISTRE DU MATERIEL ---------------------------- */


/* Initialise la classe des registres. */
static void g_arch_register_class_init(GArchRegisterClass *);

/* Initialise une instance de registre. */
static void g_arch_register_init(GArchRegister *);

/* Procède à l'initialisation de l'interface de partage. */
static void g_arch_register_interface_init(GSharedInstanceInterface *);

/* Supprime toutes les références externes. */
static void g_arch_register_dispose(GArchRegister *);

/* Procède à la libération totale de la mémoire. */
static void g_arch_register_finalize(GArchRegister *);

/* Fournit le gestionnaire de partages attribué à un type. */
static GShareManager *get_arch_register_share_manager(const GArchRegister *);

/* Initialise un nouvel objet partagé avec des informations. */
static bool g_arch_register_apply_template(GArchRegister *, const GArchRegister *);

/* Réalise une copie minimale d'un contenu partagé. */
static void g_arch_register_define_template(const GArchRegister *, GArchRegister *);

/* Fournit la valeur du compteur de partage. */
static unsigned int g_arch_register_get_references(const GArchRegister *);

/* Incrémente le compteur de partage. */
static void g_arch_register_inc_references(GArchRegister *);

/* Décrémente le compteur de partage. */
static void g_arch_register_dec_references(GArchRegister *);

/* Compare de façon accélérée un registre avec un autre. */
static int g_arch_register_compare_shared(const GArchRegister * const *, const GArchRegister * const *);



/* ------------------------- REGISTRE SOUS FORME D'OPERANDE ------------------------- */


/* Initialise la classe des opérandes de registre. */
static void g_register_operand_class_init(GRegisterOperandClass *);

/* Initialise une instance d'opérande de registre. */
static void g_register_operand_init(GRegisterOperand *);

/* Supprime toutes les références externes. */
static void g_register_operand_dispose(GRegisterOperand *);

/* Procède à la libération totale de la mémoire. */
static void g_register_operand_finalize(GRegisterOperand *);

/* Initialise un nouvel objet partagé avec des informations. */
static bool g_register_operand_apply_template(GRegisterOperand *, const GRegisterOperand *);

/* Réalise une copie minimale d'un contenu partagé. */
static void g_register_operand_define_template(const GRegisterOperand *, GRegisterOperand *);

/* Compare un opérande avec un autre. */
static int g_register_operand_compare(const GRegisterOperand *, const GRegisterOperand *);

/* Traduit un opérande en version humainement lisible. */
static void g_register_operand_print(const GRegisterOperand *, GBufferLine *, AsmSyntax);



/* -------------------------- PARTAGES DE CONTENUS UNIQUES -------------------------- */


/* Gestionnaire des partages d'instances */
static GShareManager *_register_operand_manager = NULL;


/* Fournit le gestionnaire de partages attribué à un type. */
static GShareManager *get_register_operand_share_manager(void);



/* ---------------------------------------------------------------------------------- */
/*                              PUR REGISTRE DU MATERIEL                              */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini pour une représentation d'un registre. */
G_DEFINE_TYPE_WITH_CODE(GArchRegister, g_arch_register, G_TYPE_OBJECT,
                        G_IMPLEMENT_INTERFACE(G_TYPE_SHARED_INSTANCE, g_arch_register_interface_init));


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des registres.                          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_class_init(GArchRegisterClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_arch_register_dispose;
    object->finalize = (GObjectFinalizeFunc)g_arch_register_finalize;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = instance à initialiser.                                *
*                                                                             *
*  Description : Initialise une instance de registre.                         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_init(GArchRegister *reg)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : iface = interface GLib à initialiser.                        *
*                                                                             *
*  Description : Procède à l'initialisation de l'interface de partage.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_interface_init(GSharedInstanceInterface *iface)
{
    iface->get_manager = (get_share_manager_fc)get_arch_register_share_manager;

    iface->apply_template = (apply_shared_template_fc)g_arch_register_apply_template;
    iface->define_template = (define_shared_template_fc)g_arch_register_define_template;
    iface->free_template = (free_shared_template_fc)NULL;

    iface->get_ref = (get_shared_ref_fc)g_arch_register_get_references;
    iface->inc_ref = (inc_shared_ref_fc)g_arch_register_inc_references;
    iface->dec_ref = (dec_shared_ref_fc)g_arch_register_dec_references;

    iface->compare = (compare_shared_fc)g_arch_register_compare_shared;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = instance d'objet GLib à traiter.                       *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_dispose(GArchRegister *reg)
{
    G_OBJECT_CLASS(g_arch_register_parent_class)->dispose(G_OBJECT(reg));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = instance d'objet GLib à traiter.                       *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_finalize(GArchRegister *reg)
{
    G_OBJECT_CLASS(g_arch_register_parent_class)->finalize(G_OBJECT(reg));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = instance partagée à consulter.                         *
*                                                                             *
*  Description : Fournit le gestionnaire de partages attribué à un type.      *
*                                                                             *
*  Retour      : Gestionnaire de partages en place.                           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static GShareManager *get_arch_register_share_manager(const GArchRegister *reg)
{
    GShareManager *result;                  /* Instance à retourner        */

    result = G_ARCH_REGISTER_GET_CLASS(reg)->get_manager();

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg      = 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_arch_register_apply_template(GArchRegister *reg, const GArchRegister *template)
{
    bool result;                            /* Bilan à retourner           */
    apply_register_template_fc func;         /* Fonction à appeler          */

    func = G_ARCH_REGISTER_GET_CLASS(reg)->apply_template;

    if (func != NULL)
        result = func(reg, template);

    else
    {
        G_ARCH_REGISTER_GET_CLASS(reg)->define_template(template, reg);
        result = true;
    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg      = objet partagé à consulter.                        *
*                template = informations à retrouver intégralement.           *
*                                                                             *
*  Description : Réalise une copie minimale d'un contenu partagé.             *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_define_template(const GArchRegister *reg, GArchRegister *template)
{
    G_ARCH_REGISTER_GET_CLASS(reg)->define_template(reg, template);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = objet partagé à consulter.                             *
*                                                                             *
*  Description : Fournit la valeur du compteur de partage.                    *
*                                                                             *
*  Retour      : Nombre de partages courant.                                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static unsigned int g_arch_register_get_references(const GArchRegister *reg)
{
    return reg->shared_count;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = objet partagé à modifier.                              *
*                                                                             *
*  Description : Incrémente le compteur de partage.                           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_inc_references(GArchRegister *reg)
{
    reg->shared_count++;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = objet partagé à modifier.                              *
*                                                                             *
*  Description : Décrémente le compteur de partage.                           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_register_dec_references(GArchRegister *reg)
{
    reg->shared_count--;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : a = premier registre à consulter.                            *
*                b = second registre à consulter.                             *
*                                                                             *
*  Description : Compare de façon accélérée un registre avec un autre.        *
*                                                                             *
*  Retour      : Bilan de la comparaison.                                     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static int g_arch_register_compare_shared(const GArchRegister * const *a, const GArchRegister * const *b)
{
    int result;                             /* Bilan à faire remonter      */

    result = G_ARCH_REGISTER_GET_CLASS(*a)->compare(*a, *b);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = opérande à consulter pour le calcul.                   *
*                                                                             *
*  Description : Produit une empreinte à partir d'un registre.                *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

guint g_arch_register_hash(const GArchRegister *reg)
{
    return G_ARCH_REGISTER_GET_CLASS(reg)->hash(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_arch_register_compare(const GArchRegister *a, const GArchRegister *b)
{
    return G_ARCH_REGISTER_GET_CLASS(a)->compare(a, b);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg    = registre à transcrire.                              *
*                line   = ligne tampon où imprimer l'opérande donné.          *
*                syntax = type de représentation demandée.                    *
*                                                                             *
*  Description : Traduit un registre en version humainement lisible.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_register_print(const GArchRegister *reg, GBufferLine *line, AsmSyntax syntax)
{
    G_ARCH_REGISTER_GET_CLASS(reg)->print(reg, line, syntax);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre à consulter.                                  *
*                                                                             *
*  Description : Indique si le registre correspond à ebp ou similaire.        *
*                                                                             *
*  Retour      : true si la correspondance est avérée, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_arch_register_is_base_pointer(const GArchRegister *reg)
{
    bool result;                            /* Bilan à renvoyer            */

    if (G_ARCH_REGISTER_GET_CLASS(reg)->is_bp != NULL)
        result = G_ARCH_REGISTER_GET_CLASS(reg)->is_bp(reg);
    else
        result = false;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre à consulter.                                  *
*                                                                             *
*  Description : Indique si le registre correspond à esp ou similaire.        *
*                                                                             *
*  Retour      : true si la correspondance est avérée, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_arch_register_is_stack_pointer(const GArchRegister *reg)
{
    bool result;                            /* Bilan à renvoyer            */

    if (G_ARCH_REGISTER_GET_CLASS(reg)->is_sp != NULL)
        result = G_ARCH_REGISTER_GET_CLASS(reg)->is_sp(reg);
    else
        result = false;

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                           REGISTRE SOUS FORME D'OPERANDE                           */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande de registre Dalvik. */
G_DEFINE_TYPE(GRegisterOperand, g_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_register_operand_class_init(GRegisterOperandClass *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_register_operand_dispose;
    object->finalize = (GObjectFinalizeFunc)g_register_operand_finalize;

    operand->get_manager = (get_operand_manager_fc)get_register_operand_share_manager;

    operand->apply_template = (apply_operand_template_fc)g_register_operand_apply_template;
    operand->define_template = (define_operand_template_fc)g_register_operand_define_template;
    operand->free_template = (free_operand_template_fc)NULL;

    operand->compare = (operand_compare_fc)g_register_operand_compare;
    operand->print = (operand_print_fc)g_register_operand_print;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande de registre Dalvik.       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_register_operand_init(GRegisterOperand *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_register_operand_dispose(GRegisterOperand *operand)
{
    g_object_unref(G_OBJECT(operand->reg));

    G_OBJECT_CLASS(g_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_register_operand_finalize(GRegisterOperand *operand)
{
    G_OBJECT_CLASS(g_register_operand_parent_class)->finalize(G_OBJECT(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_register_operand_apply_template(GRegisterOperand *operand, const GRegisterOperand *template)
{
    g_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_register_operand_define_template(const GRegisterOperand *operand, GRegisterOperand *template)
{
    template->reg = operand->reg;

    template->is_written = operand->is_written;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre déjà en place.                                *
*                                                                             *
*  Description : Crée un opérande visant un registre.                         *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_register_operand_new(GArchRegister *reg)
{
    GRegisterOperand *result;         /* Structure à retourner       */

    result = g_object_new(G_TYPE_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   : -                                                            *
*                                                                             *
******************************************************************************/

GArchRegister *g_register_operand_get_register(const GRegisterOperand *operand)
{
    g_object_ref(G_OBJECT(operand->reg));

    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 int g_register_operand_compare(const GRegisterOperand *a, const GRegisterOperand *b)
{
    int result;                             /* Bilan à retourner           */

    result = g_arch_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_register_operand_print(const GRegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
{
    g_arch_register_print(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_register_operand_mark_as_written(GRegisterOperand *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_register_operand_is_written(const GRegisterOperand *operand)
{
    return operand->is_written;

}



/* ---------------------------------------------------------------------------------- */
/*                            PARTAGES DE CONTENUS UNIQUES                            */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Fournit le gestionnaire de partages attribué à un type.      *
*                                                                             *
*  Retour      : Gestionnaire de partages en place.                           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static GShareManager *get_register_operand_share_manager(void)
{
    return _register_operand_manager;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Met en place les mécanismes de partage des registres.        *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool init_register_operand_sharing(void)
{
    _register_operand_manager = g_share_manager_new(G_TYPE_REGISTER_OPERAND);

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Imprime des statistiques quant aux partages dans l'archi.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/
#ifdef DEBUG_DUMP_STATS
void dump_register_operand_share_stats(void)
{
    g_share_manager_dump_stats(_register_operand_manager);

}
#endif


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Supprime les mécanismes de partage des opérandes de registre.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void exit_register_operand_sharing(void)
{
    g_object_unref(G_OBJECT(_register_operand_manager));

}