/* Chrysalide - Outil d'analyse de fichiers binaires
* links.c - résolution des liens entre différentes instructions
*
* Copyright (C) 2010-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 .
*/
#include "links.h"
#include
#include "../../arch/instruction.h"
#include "../../arch/raw.h"
#include "../../arch/target.h"
/* Complète un désassemblage accompli pour une instruction. */
static void convert_immediate_into_target(GArchInstruction *, size_t, GBinFormat *);
/******************************************************************************
* *
* 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 : - *
* *
******************************************************************************/
void establish_natural_link(GArchInstruction *instr, GArchInstruction *prev)
{
bool has_src; /* Présence de sources ? */
bool no_natural; /* Aucun lien naturel présent */
bool no_need; /* Pas de besoin pour ce lien */
instr_link_t *others; /* Instructions diverses liées */
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.
*/
g_arch_instruction_rlock_src(instr);
has_src = g_arch_instruction_has_sources(instr);
g_arch_instruction_runlock_src(instr);
if (!has_src)
return;
/**
* Si on se trouve à une extrémité, on ne se lie pas
* avec le voisin.
*/
if (g_arch_instruction_get_flags(prev) & AIF_RETURN_POINT)
return;
if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START)
return;
/**
* On s'assure que le lien naturel est nécessaire et qu'il n'est pas
* déjà en place.
*/
no_natural = true;
no_need = true;
g_arch_instruction_rlock_dest(prev);
count = g_arch_instruction_get_destinations(prev, &others);
for (i = 0; i < count && no_natural; i++)
switch (others[i].type)
{
case ILT_EXEC_FLOW:
no_natural = false;
break;
case ILT_JUMP_IF_TRUE:
case ILT_JUMP_IF_FALSE:
if (others[i].linked != instr)
no_need = false;
else
{
no_need = true;
goto check_done;
}
break;
default:
break;
}
check_done:
g_arch_instruction_runlock_dest(prev);
if (no_natural && !no_need)
{
/* Vérification de la cohérence de l'ensemble */
#ifndef NDEBUG
g_arch_instruction_rlock_src(instr);
count = g_arch_instruction_get_sources(instr, &others);
for (i = 0; i < count; i++)
switch (others[i].type)
{
case ILT_NONE:
case ILT_EXEC_FLOW:
assert(false);
break;
case ILT_JUMP:
case ILT_CASE_JUMP:
case ILT_JUMP_IF_TRUE:
case ILT_JUMP_IF_FALSE:
case ILT_LOOP:
case ILT_CATCH_EXCEPTION:
assert(others[i].linked != prev);
break;
default:
break;
}
g_arch_instruction_runlock_src(instr);
#endif
g_arch_instruction_link_with(prev, instr, ILT_EXEC_FLOW);
}
}
/******************************************************************************
* *
* 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 */
GImmOperand *imm; /* Version native de l'opérande*/
virt_t addr; /* Adresse visée par le saut */
MemoryDataSize msize; /* Taille de l'opérande */
vmpa2t target; /* Défination finale précise */
GArchOperand *new; /* Instruction de ciblage */
op = _g_arch_instruction_get_operand(instr, index);
if (!G_IS_IMM_OPERAND(op))
goto ciit_done;
imm = G_IMM_OPERAND(op);
if (g_imm_operand_get_display(imm) != IOD_HEX)
goto ciit_done;
if (g_imm_operand_to_virt_t(imm, &addr))
{
msize = g_imm_operand_get_size(imm);
if (g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), addr, &target))
{
new = g_target_operand_new(msize, &target);
if (!g_target_operand_resolve(G_TARGET_OPERAND(new), format, false))
g_object_unref(G_OBJECT(new));
else
_g_arch_instruction_replace_operand(instr, new, op);
}
}
ciit_done:
;
}
/******************************************************************************
* *
* Paramètres : instr = instruction désassemblée à traiter. *
* format = accès aux données du binaire d'origine. *
* proc = ensemble d'instructions à relier. *
* *
* Description : Complète un désassemblage accompli pour une instruction. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void establish_links_for_instruction(GArchInstruction *instr, GBinFormat *format, GArchProcessor *proc)
{
bool skip; /* Saut des conversions */
size_t count; /* Nombre d'opérandes présents */
size_t i; /* Boucle de parcours */
GArchOperand *op; /* Opérande numérique en place */
vmpa2t addr; /* Localisation plus complète */
GArchInstruction *target; /* Instruction visée au final */
if (G_IS_RAW_INSTRUCTION(instr))
skip = g_raw_instruction_is_string(G_RAW_INSTRUCTION(instr));
else
skip = false;
g_arch_instruction_lock_operands(instr);
count = _g_arch_instruction_count_operands(instr);
for (i = 0; i < count; i++)
{
if (!skip)
convert_immediate_into_target(instr, i, format);
op = _g_arch_instruction_get_operand(instr, i);
if (!G_IS_TARGET_OPERAND(op)) continue;
g_target_operand_get_addr(G_TARGET_OPERAND(op), &addr);
target = g_arch_processor_find_instr_by_address(proc, &addr);
if (target != NULL)
{
g_arch_instruction_link_with(instr, target, ILT_REF);
g_object_unref(G_OBJECT(target));
}
}
g_arch_instruction_unlock_operands(instr);
}