/* Chrysalide - Outil d'analyse de fichiers binaires
 * virtual.c - encadrement des instructions par blocs virtuels
 *
 * Copyright (C) 2012-2013 Cyrille Bagard
 *
 *  This file is part of Chrysalide.
 *
 *  OpenIDA 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.
 *
 *  OpenIDA 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 "virtual.h"


#include <malloc.h>


#include "flow.h"
#include "../block-int.h"



/* Description d'un bloc d'exécution d'instructions (instance) */
struct _GVirtualBlock
{
    GInstrBlock parent;                     /* A laisser en premier        */

    GArchInstruction *instrs;               /* Liste complète d'instruct°  */
    GArchInstruction *first;                /* Première instruction        */
    GArchInstruction *last;                 /* Dernière instruction        */

    GInstrBlock **children;                 /* Sous-blocs intégrés         */
    size_t children_count;                  /* Nombre de ces sous-blocs    */

#if 0
    reg_access *accesses;                   /* Commodités d'accès #1       */
    size_t count;                           /* Commodités d'accès #2       */
#endif

};

/* Description d'un bloc d'exécution d'instructions (classe) */
struct _GVirtualBlockClass
{
    GInstrBlockClass parent;                /* A laisser en premier        */

};


/* Initialise la classe des blocs d'instructions. */
static void g_virtual_block_class_init(GVirtualBlockClass *);

/* Initialise un bloc d'instructions. */
static void g_virtual_block_init(GVirtualBlock *);

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

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

/* Recherche le bloc contenant une adresse donnée. */
static GInstrBlock *g_virtual_block_find_by_addr(const GVirtualBlock *, const vmpa2t *, bool);

/* Parcourt le bloc d'instructions dans un ordre donné. */
static bool g_virtual_block_visit(GVirtualBlock *, instr_block_visitor_cb, void *);

/* Etablit la liste de tous les blocs présents. */
static void g_virtual_block_list_all_blocks(const GVirtualBlock *, GInstrBlock ***, size_t *);

/* Etablit la liste de tous les blocs terminaux. */
static void g_virtual_block_list_leafs_blocks(const GVirtualBlock *, GInstrBlock ***, size_t *);

/* Fournit les différents accès aux registres. */
//static const reg_access *g_virtual_block_list_regs_accesses(const GVirtualBlock *, size_t *);



/* Indique le type défini pour un bloc virtuel d'instructions. */
G_DEFINE_TYPE(GVirtualBlock, g_virtual_block, G_TYPE_INSTR_BLOCK);


/******************************************************************************
*                                                                             *
*  Paramètres  : class = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des blocs d'instructions.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_virtual_block_class_init(GVirtualBlockClass *class)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GInstrBlockClass *block_class;          /* Version parente du la classe*/

    object = G_OBJECT_CLASS(class);
    block_class = G_INSTR_BLOCK_CLASS(class);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_virtual_block_dispose;
    object->finalize = (GObjectFinalizeFunc)g_virtual_block_finalize;

    block_class->find_by_addr = (find_by_addr_fc)g_virtual_block_find_by_addr;
    block_class->visit_blocks = (visit_all_blocks_fc)g_virtual_block_visit;
    block_class->list_blocks = (list_all_blocks_fc)g_virtual_block_list_all_blocks;
    block_class->list_leafs = (list_leafs_blocks_fc)g_virtual_block_list_leafs_blocks;
    //block_class->list_regs = (list_regs_accesses_fc)g_virtual_block_list_regs_accesses;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = instance à initialiser.                              *
*                                                                             *
*  Description : Initialise un bloc d'instructions.                           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_virtual_block_init(GVirtualBlock *block)
{

}


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

static void g_virtual_block_dispose(GVirtualBlock *block)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < block->children_count; i++)
        g_object_unref(G_OBJECT(block->children[i]));

    G_OBJECT_CLASS(g_virtual_block_parent_class)->dispose(G_OBJECT(block));

}


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

static void g_virtual_block_finalize(GVirtualBlock *block)
{
    if (block->children != NULL)
        free(block->children);

    G_OBJECT_CLASS(g_virtual_block_parent_class)->finalize(G_OBJECT(block));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Crée un bloc virtuel d'instructions.                         *
*                                                                             *
*  Retour      : Adresse de la structure mise en place.                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GInstrBlock *g_virtual_block_new(void)
{
    GVirtualBlock *result;                     /* Structure à retourner       */

    result = g_object_new(G_TYPE_VIRTUAL_BLOCK, NULL);

    return G_INSTR_BLOCK(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc de départ des recherches.                       *
*                addr  = ensemble de blocs à parcourir.                       *
*                final = indique si la cible ou le conteneur est renvoyée.    *
*                                                                             *
*  Description : Recherche le bloc contenant une adresse donnée.              *
*                                                                             *
*  Retour      : bloc basique trouvé ou NULL en cas d'échec.                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static GInstrBlock *g_virtual_block_find_by_addr(const GVirtualBlock *block, const vmpa2t *addr, bool final)
{
    GInstrBlock *result;                    /* Resultat à retourner        */
    size_t i;                               /* Boucle de parcours          */
    GInstrBlock *ret;                       /* Retour des inspections      */

    result = NULL;

    for (i = 0; i < block->children_count && result == NULL; i++)
    {
        ret = g_instr_block_find_by_addr(block->children[i], addr, final);

        if (ret != NULL)
        {
            if (final) result = ret;
            else result = (G_IS_FLOW_BLOCK(ret) ? G_INSTR_BLOCK(block) : ret);
        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block    = bloc d'instructions concerné par la visite.       *
*                callback = ensemble de blocs à parcourir.                    *
*                data     = donnée utilisateur à associer au parcours.        *
*                                                                             *
*  Description : Parcourt le bloc d'instructions dans un ordre donné.         *
*                                                                             *
*  Retour      : true si le parcours a été jusqu'à son terme, false sinon.    *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_virtual_block_visit(GVirtualBlock *block, instr_block_visitor_cb callback, void *data)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */

    result = callback(G_INSTR_BLOCK(block), BVO_IN, data);

    for (i = 0; i < block->children_count && result; i++)
        result = g_instr_block_visit(block->children[i], callback, data);

    result &= callback(G_INSTR_BLOCK(block), BVO_OUT, data);

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à consulter.                     *
*                list  = ensemble de blocs à compléter. [OUT]                 *
*                count = nombre de blocs au total. [OUT]                      *
*                                                                             *
*  Description : Etablit la liste de tous les blocs présents.                 *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_virtual_block_list_all_blocks(const GVirtualBlock *block, GInstrBlock ***list, size_t *count)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < block->children_count; i++)
        g_instr_block_list_all_blocks(block->children[i], list, count);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à consulter.                     *
*                list  = ensemble de blocs à compléter. [OUT]                 *
*                count = nombre de blocs au total. [OUT]                      *
*                                                                             *
*  Description : Etablit la liste de tous les blocs terminaux.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_virtual_block_list_leafs_blocks(const GVirtualBlock *block, GInstrBlock ***list, size_t *count)
{
    if (block->children_count > 0)
        g_instr_block_list_leafs_blocks(block->children[block->children_count - 1], list, count);

}


#if 0
/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à consulter.                     *
*                count = nombre de registres consignés. [OUT]                 *
*                                                                             *
*  Description : Fournit les différents accès aux registres.                  *
*                                                                             *
*  Retour      : Liste des accès aux registres.                               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static const reg_access *g_virtual_block_list_regs_accesses(const GVirtualBlock *block, size_t *count)
{
    *count = 0;

    return NULL;

}
#endif


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à compléter.                     *
*                child = sous-bloc à insérer.                                 *
*                                                                             *
*  Description : Ajoute un bloc au groupe courant.                            *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_virtual_block_add_child(GVirtualBlock *block, GInstrBlock *child)
{
    block->children = (GInstrBlock **)realloc(block->children,
                                              ++block->children_count * sizeof(GInstrBlock *));

    block->children[block->children_count - 1] = child;

    g_object_ref(G_OBJECT(child));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à consulter.                     *
*                                                                             *
*  Description : Compte le nombre de blocs contenus dans le groupe courant.   *
*                                                                             *
*  Retour      : Quantité normalement non nulle.                              *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

size_t g_virtual_block_count_children(const GVirtualBlock *block)
{
    return block->children_count;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : block = bloc d'instructions à consulter.                     *
*                index = indice du sous-bloc recherché.                       *
*                                                                             *
*  Description : Renvoie un des blocs contenus dans le groupe courant.        *
*                                                                             *
*  Retour      : Un des blocs du groupe.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GInstrBlock *g_virtual_block_get_child(const GVirtualBlock *block, size_t index)
{
    if (index >= block->children_count)
        return NULL;

    else
        return block->children[index];

}