/* OpenIDA - Outil d'analyse de fichiers binaires
 * limit.c - détermination des bornes des routines
 *
 * Copyright (C) 2012 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  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 "limit.h"


#include <malloc.h>



/* Cherche l'adresse de fin d'une routine. */
static vmpa_t find_best_ending_address_for_routine(GArchInstruction *, size_t, const vmpa_t *, const off_t *, size_t);



/******************************************************************************
*                                                                             *
*  Paramètres  : list      = ensemble d'instructions désassemblées.           *
*                routines  = prototypes existants à insérer.                  *
*                count     = quantité de ces prototypes.                      *
*                statusbar = barre de statut avec progression à mettre à jour.*
*                id        = identifiant du message affiché à l'utilisateur.  *
*                                                                             *
*  Description : S'assure que toutes les routines ont une taille définie.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void limit_all_routines(GArchInstruction *list, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, bstatus_id_t id)
{
    size_t i;                               /* Boucle de parcours          */
    vmpa_t *starts;                         /* Adresses de départ          */
    off_t *lengths;                         /* Tailles des routines        */
    GArchInstruction *instr;                /* Instr. de départ / arrivée  */

    if (count == 0) return;

    starts = (vmpa_t *)calloc(count, sizeof(vmpa_t));
    lengths = (off_t *)calloc(count, sizeof(off_t));

    for (i = 0; i < count; i++)
    {
        starts[i] = g_binary_routine_get_address(routines[i]);
        lengths[i] = g_binary_routine_get_size(routines[i]);

        gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / (count * 2));

    }

    for (i = 0; i < count; i++)
    {
        /* Instruction de départ */

        instr = g_arch_instruction_find_by_address(list, starts[i], true);
        g_binary_routine_set_instructions(routines[i], instr);

        if (lengths[i] > 0) goto lar_next;

        /* Si le symbole est hors du code analysé (routine de PLT par exemple) */
        if (instr == NULL) goto lar_next;

        /* Taille de la routine */

        lengths[i] = find_best_ending_address_for_routine(instr, i, starts, lengths, count);
        lengths[i] -= starts[i];

        g_binary_routine_set_size(routines[i], lengths[i]);

 lar_next:

        gtk_extended_status_bar_update_activity(statusbar, id, (i + 1 + count) * 1.0 / (count * 2));

    }

    free(starts);
    free(lengths);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : first   = première instruction de la routine courante.       *
*                index   = indice de la routine traitée dans la liste.        *
*                starts  = adresse de départ des autres routines.             *
*                lengths = taille des différentes routines, valides ou nulles.*
*                count   = quantité de routines présentes.                    *
*                                                                             *
*  Description : Cherche l'adresse de fin d'une routine.                      *
*                                                                             *
*  Retour      : Plus grande adresse de dernière instruction de routine.      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static vmpa_t find_best_ending_address_for_routine(GArchInstruction *first, size_t index, const vmpa_t *starts, const off_t *lengths, size_t count)
{
    vmpa_t result;                          /* Haute adresse à remonter    */
    GArchInstruction *iter;                 /* Boucle de parcours #1       */
    vmpa_t candidate;                       /* Candidat potentiel          */
    size_t i;                               /* Boucle de parcours #2       */

    result = starts[index];

    for (iter = first;
         iter != NULL;
         iter = g_arch_instruction_get_next_iter(first, iter, VMPA_MAX))
    {
        g_arch_instruction_get_location(iter, NULL, NULL, &candidate);

        /* Regarde si on n'empiète pas sur une autre routine */

        for (i = 0; i < count; i++)
        {
            if (i == index) continue;

            if (starts[i] <= candidate && candidate < (starts[i] + lengths[i]))
                break;

        }

        if (i != count) break;
        else result = candidate;

        /* Retour de fonction ? */
        if (g_arch_instruction_is_return(iter)) break;

    }

    return result;

}