path: root/src/analysis/disass/links.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * links.c - résolution des liens entre différentes instructions
 *
 * Copyright (C) 2010-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 "links.h"



#include "../../arch/instruction.h"
#include "../../arch/target.h"



/* Complète un désassemblage accompli pour une instruction. */
static void convert_immediate_into_target(GArchInstruction *, size_t, GBinFormat *);

/* Rétablit un lien naturel coupé par un autre lien. */
static void establish_natural_link(GArchInstruction *, GArchInstruction *);



/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = instruction désassemblée à traiter.                 *
*                index  = indice de l'opérande à traiter.                     *
*                format = accès aux données du binaire d'origine.             *
*                                                                             *
*  Description : Complète un désassemblage accompli pour une instruction.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void convert_immediate_into_target(GArchInstruction *instr, size_t index, GBinFormat *format)
{
    GArchOperand *op;                       /* Opérande numérique en place */
    virt_t addr;                            /* Adresse visée par le saut   */
    MemoryDataSize msize;                   /* Taille de l'opérande        */
    GArchOperand *new;                      /* Instruction de ciblage      */

    op = g_arch_instruction_get_operand(instr, index);
    if (!G_IS_IMM_OPERAND(op)) return;

    if (g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &addr))
    {
        msize = g_imm_operand_get_size(G_IMM_OPERAND(op));

        new = g_target_operand_new(msize, addr);

        if (!g_target_operand_resolve(G_TARGET_OPERAND(new), format))
            g_object_unref(G_OBJECT(new));
        else
            g_arch_instruction_replace_operand(instr, new, op);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = instruction désassemblée à traiter.                 *
*                list   = ensemble d'instructions à relier.                   *
*                format = accès aux données du binaire d'origine.             *
*                                                                             *
*  Description : Complète un désassemblage accompli pour une instruction.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void establish_links_for_instruction(GArchInstruction *instr, GArchInstruction *list, GBinFormat *format)
{
    size_t count;                           /* Nombre d'opérandes présents */
    size_t i;                               /* Boucle de parcours          */
    GArchOperand *op;                       /* Opérande numérique en place */
    virt_t virt;                            /* Adresse liée à une cible    */
    vmpa2t addr;                            /* Localisation plus complète  */
    GArchInstruction *target;               /* Instruction visée au final  */

    count = g_arch_instruction_count_operands(instr);

    for (i = 0; i < count; i++)
    {
        convert_immediate_into_target(instr, i, format);

        op = g_arch_instruction_get_operand(instr, i);
        if (!G_IS_TARGET_OPERAND(op)) continue;

        virt = g_target_operand_get_addr(G_TARGET_OPERAND(op));
        init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);

        target = g_arch_instruction_find_by_address(list, &addr, true);

        if (target != NULL)
            g_arch_instruction_link_with(instr, target, ILT_REF);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction désassemblée à traiter.                  *
*                prev  = instruction précédente.                              *
*                                                                             *
*  Description : Rétablit un lien naturel coupé par un autre lien.            *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void establish_natural_link(GArchInstruction *instr, GArchInstruction *prev)
{
    GArchInstruction **others;              /* Instructions diverses liées */
    InstructionLinkType *types;             /* Types de lien existants     */
    size_t count;                           /* Nbre de sources affichées   */
    size_t i;                               /* Boucle de parcours          */

    /**
     * Si rien ne vient séparer les deux instructions,
     * on ne peut pas créer de lien plus naturel que l'existant.
     */

    if (!g_arch_instruction_has_sources(instr))
        return;

    /**
     * Si on se trouve à une extrémité, on ne se lie pas
     * avec le voisin.
     */

    if (g_arch_instruction_is_return(prev))
        return;

    if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START)
        return;

    /**
     * On s'assure que le lien naturel est valide.
     */

    count = g_arch_instruction_get_destinations(prev, &others, &types, NULL);

    for (i = 0; i < count; i++)
    {
        if (types[i] == ILT_EXEC_FLOW) break;
        if (types[i] == ILT_JUMP) break;
        if (types[i] == ILT_CASE_JUMP) break;
        if (types[i] == ILT_LOOP) break;
    }

    if (i < count) return;

    /**
     * On vérifie que le lien n'existe pas déjà avant d'en créer un...
     */

    count = g_arch_instruction_get_sources(instr, &others, &types);

    for (i = 0; i < count; i++)
    {
        if (others[i] == prev && types[i] == ILT_JUMP_IF_TRUE) break;
        if (others[i] == prev && types[i] == ILT_JUMP_IF_FALSE) break;
    }

    if (i == count)
        g_arch_instruction_link_with(prev, instr, ILT_EXEC_FLOW);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : list      = ensemble d'instructions à relier.                *
*                format    = accès aux données du binaire d'origine.          *
*                statusbar = barre de statut avec progression à mettre à jour.*
*                id        = identifiant du message affiché à l'utilisateur.  *
*                                                                             *
*  Description : Etablit les liens entres les différentes lignes de code.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void establish_links_between_instructions(GArchInstruction *list, GBinFormat *format, GtkExtStatusBar *statusbar, bstatus_id_t id)
{
    GArchInstruction *prev;                 /* Itération précédente        */
    GArchInstruction *iter;                 /* Boucle de parcours          */

    prev = NULL;

    for (iter = list;
         iter != NULL;
         iter = g_arch_instruction_get_next_iter(list, iter, ~0/* FIXME */))
    {
        if (prev != NULL)
            establish_natural_link(iter, prev);

        prev = iter;

        establish_links_for_instruction(iter, list, format);


    }

}












#if 0

/******************************************************************************
*                                                                             *
*  Paramètres  : list      = ensemble d'instructions à relier.                *
*                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 : Etablit les liens entres les différentes lignes de code.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, bstatus_id_t id)
{
    size_t i;                               /* Boucle de parcours          */
    vmpa_t start;                           /* Adresse de départ           */
    vmpa_t end;                             /* Adresse de fin              */
    GArchInstruction *iter;                 /* Boucle de parcours          */
    vmpa_t addr;                            /* Adresse référencée          */
    InstructionLinkType type;               /* Type de référence           */
    GArchInstruction *target;               /* Ligne visée par la référence*/
    GArchInstruction *prev;                 /* Instruction précédente      */

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

        /* Définition de toutes les destinations */
        for (iter = g_arch_instruction_find_by_address(list, start, true);
             iter != NULL;
             iter = g_arch_instruction_get_next_iter(list, iter, end))
        {
            type = g_arch_instruction_get_link(iter, &addr);

            switch (type)
            {
                case ILT_NONE:
                    break;

                case ILT_JUMP:

                    target = g_arch_instruction_find_by_address(list, addr, true);

                    if (target != NULL)
                        g_arch_instruction_link_with(iter, target, type);

                    break;

                case ILT_JUMP_IF_FALSE:
                    break;

                case ILT_JUMP_IF_TRUE:

                    target = g_arch_instruction_find_by_address(list, addr, true);

                    if (target != NULL)
                    {
                        g_arch_instruction_link_with(iter, target, type);

                        target = g_arch_instruction_get_next_iter(list, iter, end);
                        if (target != NULL)
                            g_arch_instruction_link_with(iter, target, ILT_JUMP_IF_FALSE);

                    }

                    break;

                case ILT_CALL:

                    target = g_arch_instruction_find_by_address(list, addr, true);

                    if (target != NULL)
                        g_arch_instruction_link_with(iter, target, type);

                    break;

                default:
                    /**
                     * Note pour GCC : à ce stade du désassemblage, ILT_CASE_JUMP et
                     * ILT_CATCH_EXCEPTION ne peuvent être présentes, car ne provenant
                     * que de greffons. Pour ILT_EXEC_FLOW, sa seule insertion est ici, plus bas.
                     */
                    break;

            }

        }

        /* Rattachement de deux blocs selon le flux normal */

        iter = g_arch_instruction_find_by_address(list, start, true);

        if (iter == NULL)
            printf("no match for 0x%08llx\n", start);

        if (iter != NULL)

        for (iter = g_arch_instruction_get_next_iter(list, iter, end);
             iter != NULL;
             iter = g_arch_instruction_get_next_iter(list, iter, end))
        {
            if (!g_arch_instruction_has_sources(iter))
                continue;

            prev = g_arch_instruction_get_prev_iter(list, iter);

            if (g_arch_instruction_is_return(prev))
                continue;

            if (!g_arch_instruction_has_destinations(prev))
                g_arch_instruction_link_with(prev, iter, ILT_EXEC_FLOW);

        }

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

    }

}




#endif