path: root/src/format/format.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * format.c - support des différents formats binaires
 *
 * Copyright (C) 2009-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 "format.h"


#include <assert.h>
#include <ctype.h>
#include <malloc.h>
#include <string.h>


#include "format-int.h"
#include "dex/dex.h"
#include "dwarf/dwarf.h"
#include "elf/elf.h"
#include "java/java.h"
#include "pe/pe.h"
#include "../arch/processor.h"
#include "../decomp/expr/block.h"
#include "../gui/panels/log.h"
#include "../plugins/pglist.h"



/* Initialise la classe des formats binaires génériques. */
static void g_binary_format_class_init(GBinFormatClass *);

/* Initialise une instance de format binaire générique. */
static void g_binary_format_init(GBinFormat *);

/* Retire un symbole de la collection du format binaire. */
static void _g_binary_format_remove_symbol(GBinFormat *, size_t);

/* Supprime les éventuels doublons au sein des symboles. */
static void g_binary_format_delete_duplicated_symbols(GBinFormat *);

/* Recherche le symbole associé à une adresse. */
static bool _g_binary_format_find_symbol(const GBinFormat *, const vmpa2t *, __compar_fn_t, GBinSymbol **);



/* Indique le type défini pour un format binaire générique. */
G_DEFINE_TYPE(GBinFormat, g_binary_format, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des formats binaires génériques.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_binary_format_class_init(GBinFormatClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = instance à initialiser.                             *
*                                                                             *
*  Description : Initialise une instance de format binaire générique.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_binary_format_init(GBinFormat *format)
{
    g_rw_lock_init(&format->syms_lock);
    g_atomic_int_set(&format->unsorted_symbols, false);

    format->unsorted_routines = false;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = instance à traiter.                                 *
*                                                                             *
*  Description : Effectue les ultimes opérations de chargement d'un binaire.  *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_complete_loading(GBinFormat *format)
{
    handle_binary_format(PGA_FORMAT_LOADER_LAST, format);

    g_binary_format_delete_duplicated_symbols(format);

    return true;

}




/* FIXME : g_rw_lock_clear(&format->syms_lock);*/



/******************************************************************************
*                                                                             *
*  Paramètres  : format  = description de l'exécutable à consulter.           *
*                content = contenu binaire à parcourir.                       *
*                length  = taille du contenu fourni.                          *
*                                                                             *
*  Description : Définit le contenu binaire à analyser.                       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_set_content(GBinFormat *format, GBinContent *content)
{
    assert(format->content == NULL);

    g_object_ref(G_OBJECT(content));

    format->content = content;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à consulter.            *
*                                                                             *
*  Description : Fournit une référence vers le contenu binaire analysé.       *
*                                                                             *
*  Retour      : Gestionnaire de contenu binaire en place.                    *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinContent *g_binary_format_get_content(const GBinFormat *format)
{
    g_object_ref(G_OBJECT(format->content));

    return format->content;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à consulter.            *
*                                                                             *
*  Description : Indique le boutisme employé par le format binaire analysé.   *
*                                                                             *
*  Retour      : Boutisme associé au format.                                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

SourceEndian g_binary_format_get_endianness(const GBinFormat *format)
{
    return G_BIN_FORMAT_GET_CLASS(format)->get_endian(format);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à compléter.            *
*                pt     = point de l'espace mémoire à considérer.             *
*                entry  = nature du point fourni.                             *
*                                                                             *
*  Description : Enregistre une adresse comme début d'une zone de code.       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_register_code_point(GBinFormat *format, virt_t pt, bool entry)
{
    if (entry)
    {
        format->entry_points = (virt_t *)realloc(format->entry_points,
                                                 ++format->ep_count * sizeof(virt_t));

        format->entry_points[format->ep_count - 1] = pt;

    }
    else
    {
        if (format->xp_count == format->xp_allocated)
        {
            format->xp_allocated += EXTRA_POINT_BLOCK;

            format->extra_points = (virt_t *)realloc(format->extra_points,
                                                     format->xp_allocated * sizeof(virt_t));

        }

        format->extra_points[format->xp_count++] = pt;

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à consulter.            *
*                ctx    = contexte de désassemblage à préparer.               *
*                                                                             *
*  Description : Fournit un contexte initialisé pour un désassemblage.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_setup_disassembling_context(const GBinFormat *format, GProcContext *ctx)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < format->ep_count; i++)
        g_proc_context_push_drop_point(ctx, 0, format->entry_points[i]);

    for (i = 0; i < format->xp_count; i++)
        g_proc_context_push_drop_point(ctx, 0, format->extra_points[i]);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                symbol = symbole à ajouter à la liste.                       *
*                sort   = fait état d'un obligation de tri final.             *
*                                                                             *
*  Description : Ajoute un symbole à la collection du format binaire.         *
*                                                                             *
*  Retour      : true si le symbole était bien localisé et a été inséré.      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void _g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol, bool sort)
{
#ifndef NDEBUG
    const mrange_t *range;                  /* Couverture du symbole       */
    const vmpa2t *addr;                     /* Emplacement du symbole      */
#endif

    /**
     * Lorsque les fonctions de recherche type g_binary_format_find_symbol_at()
     * sont appelées avec une localisation, cette dernière peut reposer soit sur
     * une position physique soit une adresse virtuelle uniquement.
     *
     * Pour que les comparaisons de positions puissent se réaliser, il faut donc
     * pouvoir satisfaire les deux aspects : physiques et virtuels.
     *
     * On corrige donc le tir si besoin est ici.
     */

#ifndef NDEBUG
    range = g_binary_symbol_get_range(symbol);
    addr = get_mrange_addr(range);

    assert(get_phy_addr(addr) != VMPA_NO_PHYSICAL && get_virt_addr(addr) != VMPA_NO_VIRTUAL);
#endif

    g_rw_lock_writer_lock(&format->syms_lock);

    format->symbols = (GBinSymbol **)realloc(format->symbols,
                                             ++format->symbols_count * sizeof(GBinSymbol *));

    format->symbols[format->symbols_count - 1] = symbol;

    g_atomic_int_set(&format->unsorted_symbols, true);

    switch (g_binary_symbol_get_target_type(symbol))
    {
        case STP_ROUTINE:
        case STP_ENTRY_POINT:

            format->routines = (GBinRoutine **)realloc(format->routines,
                                                       ++format->routines_count * sizeof(GBinRoutine *));

            format->routines[format->routines_count - 1] = g_binary_symbol_get_routine(symbol);

            format->unsorted_routines = true;

            break;

        default:
            break;

    }

    g_rw_lock_writer_unlock(&format->syms_lock);

    if (sort)
        g_binary_format_sort_symbols(format);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                index  = indice du symbole à retirer de la liste.            *
*                                                                             *
*  Description : Retire un symbole de la collection du format binaire.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void _g_binary_format_remove_symbol(GBinFormat *format, size_t index)
{
    GBinSymbol *symbol;                     /* Symbole visé par l'opération*/
    GBinRoutine *routine;                   /* Eventuelle routine associée */
    size_t i;                               /* Boucle de parcours          */

    /**
     * TODO : envoyer un signal pour avertir les opérandes concernées.
     * TODO : vérifier les conditions d'accès (verrou).
     */

    symbol = format->symbols[index];

    switch (g_binary_symbol_get_target_type(symbol))
    {
        case STP_ROUTINE:
        case STP_ENTRY_POINT:

            routine = g_binary_symbol_get_routine(symbol);

            for (i = 0; i < format->routines_count; i++)
                if (format->routines[i] == routine)
                    break;

            assert(i < format->routines_count);

            if ((i + 1) < format->routines_count)
                memmove(&format->routines[i], &format->routines[i + 1],
                        (format->routines_count - i - 1) * sizeof(GBinRoutine *));

            format->routines = (GBinRoutine **)realloc(format->routines,
                                                       --format->routines_count * sizeof(GBinRoutine *));

            break;

        default:
            break;

    }

    assert(index < format->symbols_count);

    if ((index + 1) < format->symbols_count)
        memmove(&format->symbols[index], &format->symbols[index + 1],
                (format->symbols_count - index - 1) * sizeof(GBinSymbol *));

    format->symbols = (GBinSymbol **)realloc(format->symbols,
                                             --format->symbols_count * sizeof(GBinSymbol *));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                symbol = symbole à retirer de la liste.                      *
*                                                                             *
*  Description : Retire un symbole de la collection du format binaire.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_remove_symbol(GBinFormat *format, GBinSymbol *symbol)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < format->symbols_count; i++)
        if (format->symbols[i] == symbol)
            break;

    _g_binary_format_remove_symbol(format, i);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à arranger.                   *
*                                                                             *
*  Description : Réorganise si besoin est les symboles collectés.             *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_sort_symbols(GBinFormat *format)
{
    if (g_atomic_int_compare_and_exchange(&format->unsorted_symbols, true, false))
    {
        g_rw_lock_writer_lock(&format->syms_lock);

        qsort(format->symbols, format->symbols_count,
              sizeof(GBinSymbol *), (__compar_fn_t)g_binary_symbol_cmp);

        if (format->unsorted_routines)
        {
            qsort(format->routines, format->routines_count,
                  sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_compare);

            format->unsorted_routines = false;

        }

        g_rw_lock_writer_unlock(&format->syms_lock);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à corriger si besoin est.     *
*                                                                             *
*  Description : Supprime les éventuels doublons au sein des symboles.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_binary_format_delete_duplicated_symbols(GBinFormat *format)
{
    size_t i;                               /* Boucle de parcours          */
    const mrange_t *range;                  /* Emplacement à consulter     */
    mrange_t last;                          /* Dernière localisation vue   */
    size_t index;                           /* Indice de suppression       */

    g_binary_format_sort_symbols(G_BIN_FORMAT(format));

    g_rw_lock_writer_lock(&format->syms_lock);

    if (format->symbols_count > 1)
    {
        range = g_binary_symbol_get_range(format->symbols[0]);
        copy_mrange(&last, range);
    }

    for (i = 1; i < format->symbols_count; i++)
    {
        range = g_binary_symbol_get_range(format->symbols[i]);

        if (cmp_vmpa(get_mrange_addr(&last), get_mrange_addr(range)) == 0)
        {
            /* TODO : établir une meilleur comparaison pour trouver le bon candidat */
            /* TODO : (éviter de) traiter selon le type aussi */
            index = (get_mrange_length(&last) == 0 ? i - 1 : i);
            /*
            printf("DELETE @ %zu / 0x%08x '%s'\n", index,
                   (unsigned int)last.addr.virtual,
                   g_binary_symbol_get_label(format->symbols[index]));
            */

            _g_binary_format_remove_symbol(format, index);

            i--;

        }

        copy_mrange(&last, range);

    }

    g_rw_lock_writer_unlock(&format->syms_lock);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille du tableau créé. [OUT]                       *
*                                                                             *
*  Description : Fournit la liste de tous les symboles détectés.              *
*                                                                             *
*  Retour      : Tableau créé ou NULL si aucun symbole trouvé.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinSymbol **g_binary_format_get_symbols(const GBinFormat *format, size_t *count)
{
    *count = format->symbols_count;

    return format->symbols;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse liée à la chaîne à traiter.                 *
*                base   = contenu complet et original d'une chaîne.           *
*                length = taille de la chaîne à représenter.                  *
*                                                                             *
*  Description : Construit une désignation pour chaîne de caractères.         *
*                                                                             *
*  Retour      : Chaîne de caractères à libérer de la mémoire.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *create_string_label(GBinFormat *format, const vmpa2t *addr, const char *base, size_t length)
{
    char *result;                           /* Nouvelle chaîne à retourner */
    unsigned int wc;                        /* Nombre de mots rencontrés   */
    size_t iter;                            /* Tête d'écriture de recopie  */
    size_t i;                               /* Boucle de parcours          */
    bool empty;                             /* Base de l'étiquette vide ?  */
    GBinSymbol *found;                      /* Symbole similaire trouvé    */
    VMPA_BUFFER(last_sfx);                  /* Dernier suffixe à intégrer  */

    result = (char *)calloc(length + 5 + VMPA_MAX_LEN + 1, sizeof(char));

    wc = 0;

    iter = 0;

    for (i = 0; i < length; i++)
    {
        if (isalnum(base[i])) result[iter++] = tolower(base[i]);

        else if (iter > 0)
        {
            if (result[iter - 1] != '_') wc++;

            if (wc == 3) break;

            if (result[iter - 1] != '_') result[iter++] = '_';

        }

    }

    /* Détermination du suffixe suffisant */

    empty = (iter == 0);

    if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';

    strcpy(&result[iter], "str");
    iter += 3;

    found = NULL;

    if (empty || g_binary_format_find_symbol_by_label(format, result, &found))
    {
        if (found != NULL)
            g_object_unref(G_OBJECT(found));

        if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';

        assert(has_phys_addr(addr) || has_virt_addr(addr));

        /* TODO : use_phy_instead_of_virt */
        if (has_virt_addr(addr))
            vmpa2_virt_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);
        else
            vmpa2_phys_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);

        strcpy(&result[iter], last_sfx);

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                label  = étiquette à retrouver lors des recherches.          *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une étiquette.          *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_symbol_by_label(const GBinFormat *format, const char *label, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const char *cur_lbl;                    /* Etiquette courante          */

    result = false;

    g_rw_lock_reader_lock(&format->syms_lock);

    for (i = 0; i < format->symbols_count && !result; i++)
    {
        cur_lbl = g_binary_symbol_get_label(format->symbols[i]);
        if (cur_lbl == NULL) continue;

        if (strcmp(label, cur_lbl) == 0)
        {
            *symbol = format->symbols[i];
            g_object_ref(G_OBJECT(*symbol));

            result = true;

        }

    }

    g_rw_lock_reader_unlock(&format->syms_lock);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                fn     = méthode de comparaison des symboles.                *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole associé à une adresse.                  *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool _g_binary_format_find_symbol(const GBinFormat *format, const vmpa2t *addr, __compar_fn_t fn, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    void *found;                            /* Résultat de recherches      */

    result = false;

    *symbol = NULL; /* TODO : vérifier les doublons côtés appelants */

    g_rw_lock_reader_lock(&format->syms_lock);

    found = bsearch(addr, format->symbols, format->symbols_count, sizeof(GBinSymbol *), fn);

    g_rw_lock_reader_unlock(&format->syms_lock);

    if (found != NULL)
    {
        *symbol = *(GBinSymbol **)found;

        g_object_ref(G_OBJECT(*symbol));
        result = true;

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une adresse.            *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_symbol_at(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */

    int find_symbol(const vmpa2t *addr, const GBinSymbol **sym)
    {
        const mrange_t *range;              /* Espace mémoire parcouru     */

        range = g_binary_symbol_get_range(*sym);

        return cmp_vmpa(addr, get_mrange_addr(range));

    }

    result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, symbol);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole contenant une adresse.                  *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_symbol_for(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */

    int find_symbol(const vmpa2t *addr, const GBinSymbol **sym)
    {
        const mrange_t *range;              /* Espace mémoire parcouru     */

        range = g_binary_symbol_get_range(*sym);

        return cmp_mrange_with_vmpa(range, addr);

    }

    result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, symbol);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole suivant celui lié à une adresse.        *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_next_symbol_at(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const mrange_t *range;                  /* Espace mémoire parcouru     */

    result = false;

    *symbol = NULL;

    g_rw_lock_reader_lock(&format->syms_lock);

    /* TODO : ajouter un peu de dichotomie ici ! */

    for (i = 0; i < format->symbols_count && !result; i++)
    {
        range = g_binary_symbol_get_range(format->symbols[i]);

        if (cmp_vmpa(get_mrange_addr(range), addr) == 0 && (i + 1) < format->symbols_count)
        {
            *symbol = format->symbols[i + 1];
            g_object_ref(G_OBJECT(*symbol));

            result = true;

        }

    }

    g_rw_lock_reader_unlock(&format->syms_lock);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                diff   = décallage entre l'adresse et le symbole. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une adresse.            *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_resolve_symbol(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol, phys_t *diff)
{
     bool result;                            /* Bilan à retourner           */
     const mrange_t *range;                  /* Espace mémoire parcouru     */

     result = g_binary_format_find_symbol_for(format, addr, symbol);

     if (result)
     {
         range = g_binary_symbol_get_range(*symbol);
         *diff = compute_vmpa_diff(get_mrange_addr(range), addr);
     }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille du tableau créé. [OUT]                       *
*                                                                             *
*  Description : Fournit le prototype de toutes les routines détectées.       *
*                                                                             *
*  Retour      : Tableau créé ou NULL si aucun symbole de routine trouvé.     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinRoutine **g_binary_format_get_routines(const GBinFormat *format, size_t *count)
{
    *count = format->routines_count;

    return format->routines;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille de la liste retournée. [OUT]                 *
*                defsrc = fichier de code principal. [OUT]                    *
*                                                                             *
*  Description : Fournit la liste des fichiers source détectés.               *
*                                                                             *
*  Retour      : Liste de noms de fichier ou NULL si aucun.                   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char * const *g_binary_format_get_source_files(const GBinFormat *format, size_t *count, size_t *defsrc)
{
    *count = format->src_count;
    *defsrc = format->def_source;

    return format->src_files;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format   = informations chargées à consulter.                *
*                buffer   = tampon mis à disposition pour la sortie.          *
*                filename = nom du fichier source à cibler.                   *
*                                                                             *
*  Description : Procède à la décompilation complète du format.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_decompile(const GBinFormat *format, GCodeBuffer *buffer, const char *filename)
{


    GBinRoutine **routines;
    size_t count;

    size_t i;

    GDecInstruction *instr;

    if (format->decompile != NULL)
        format->decompile(format, buffer, filename);
    

    routines = g_binary_format_get_routines(format, &count);



    for (i = 0; i < count; i++)
    {
        //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));

        //if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
        {
            instr = g_binary_routine_get_decomp_instructions(routines[i]);

            if (instr == NULL) continue;

            //g_dec_instruction_print(instr, buffer, NULL, g_java_output_new());



        }


    }

}