/* OpenIDA - Outil d'analyse de fichiers binaires * cond.c - représentation des conditions * * Copyright (C) 2010 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 . */ #include "ite.h" #include "../instruction-int.h" /* Définition d'un aiguillage du flux d'exécution (instance) */ struct _GITEInstruction { GDecInstruction parent; /* A laisser en premier */ bool inverse; /* Condition inversée */ GDecExpression *cond; /* Condition prise en compte */ GDecInstruction *true_branch; /* Condition vérifiée */ GDecInstruction *false_branch; /* Condition non vérifiée */ union { vmpa_t addr; /* Adresse de saut */ GDecExpression *expr; /* Expressions équivalentes */ } if_true; union { vmpa_t addr; /* Adresse de saut */ GDecExpression *expr; /* Expressions équivalentes */ } if_false; }; /* Définition d'un aiguillage du flux d'exécution (classe) */ struct _GITEInstructionClass { GDecInstructionClass parent; /* A laisser en premier */ }; /* Initialise la classe des aiguillages de flux d'exécution. */ static void g_ite_instruction_class_init(GITEInstructionClass *); /* Initialise une instance d'aiguillage du flux d'exécution. */ static void g_ite_instruction_init(GITEInstruction *); /* Visite un ensemble hiérarchique d'instructions décompilées. */ static bool g_ite_instruction_visit(GITEInstruction *, dec_instr_visitor_cb, DecInstrVisitFlags, void *); /* Remplace une instruction décompilée par une autre. */ static bool g_ite_instruction_replace(GITEInstruction *, GDecInstruction *, GDecInstruction *); /* Imprime pour l'écran un version humaine d'une instruction. */ static GBufferLine *g_ite_instruction_print(const GITEInstruction *, GCodeBuffer *, GBufferLine *, GLangOutput *); /* Indique le type défini pour un aiguillage du flux d'exécution. */ G_DEFINE_TYPE(GITEInstruction, g_ite_instruction, G_TYPE_DEC_INSTRUCTION); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe des aiguillages de flux d'exécution. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_ite_instruction_class_init(GITEInstructionClass *klass) { } /****************************************************************************** * * * Paramètres : expr = instance à initialiser. * * * * Description : Initialise une instance d'aiguillage du flux d'exécution. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_ite_instruction_init(GITEInstruction *expr) { GDecInstruction *instr; /* Autre version de l'objet */ instr = G_DEC_INSTRUCTION(expr); instr->visit = (dec_instr_visit_fc)g_ite_instruction_visit; instr->replace = (dec_instr_replace_fc)g_ite_instruction_replace; instr->print = (dec_instr_print_fc)g_ite_instruction_print; } /****************************************************************************** * * * Paramètres : cond = expression fixant le choix de l'aiguillage. * * if_true = adresse du saut si la condition est vérifiée. * * if_true = adresse du saut si la condition n'est pas vérifiée.* * * * Description : Exprime un aiguillage du flux en fonction d'une condition. * * * * Retour : Expression mise en place. * * * * Remarques : - * * * ******************************************************************************/ GDecInstruction *g_ite_instruction_new(GDecExpression *cond, vmpa_t if_true, vmpa_t if_false) { GITEInstruction *result; /* Expression à retourner */ result = g_object_new(G_TYPE_ITE_INSTRUCTION, NULL); result->cond = cond; result->if_true.addr = if_true; result->if_false.addr = if_false; return G_DEC_INSTRUCTION(result); } /****************************************************************************** * * * Paramètres : instr = première instruction à venir visiter. * * callback = procédure à appeler à chaque instruction visitée. * * flags = moments des appels à réaliser en retour. * * data = données quelconques associées au visiteur. * * * * Description : Visite un ensemble hiérarchique d'instructions décompilées. * * * * Retour : true si le parcours a été jusqu'à son terme, false sinon. * * * * Remarques : - * * * ******************************************************************************/ static bool g_ite_instruction_visit(GITEInstruction *instr, dec_instr_visitor_cb callback, DecInstrVisitFlags flags, void *data) { bool result; /* Bilan à retourner */ result = g_dec_instruction_visit(G_DEC_INSTRUCTION(instr->cond), callback, flags, data); if (result) result = g_dec_instruction_visit(instr->true_branch, callback, flags, data); if (result && instr->false_branch != NULL) result = g_dec_instruction_visit(instr->false_branch, callback, flags, data); return result; } /****************************************************************************** * * * Paramètres : instr = première instruction à venir ausculter. * * old = instruction décompilée à venir remplacer. * * new = instruction décompilée à utiliser dorénavant. * * * * Description : Remplace une instruction décompilée par une autre. * * * * Retour : true si un remplacement a été effectué, false sinon. * * * * Remarques : - * * * ******************************************************************************/ static bool g_ite_instruction_replace(GITEInstruction *instr, GDecInstruction *old, GDecInstruction *new) { bool result; /* Bilan à retourner */ result = g_dec_instruction_replace(G_DEC_INSTRUCTION(instr->cond), old, new); result |= g_dec_instruction_replace(instr->true_branch, old, new); if (instr->false_branch != NULL) result |= g_dec_instruction_replace(instr->false_branch, old, new); return result; } /****************************************************************************** * * * Paramètres : expr = instruction à transcrire en version humaine. * * buffer = tampon où doit se réaliser l'insertion. * * line = ligne d'impression prête à emploi ou NULL. * * output = langage de programmation de sortie. * * * * Description : Imprime pour l'écran un version humaine d'une instruction. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_ite_instruction_print(const GITEInstruction *expr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) { GBufferLine *result; /* Ligne à retourner */ g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "if ", 3, RTT_KEY_WORD); if (expr->inverse) g_buffer_line_insert_text(line /* FIXME */, BLC_ASSEMBLY_HEAD, "!", 1, RTT_KEY_WORD); result = g_dec_instruction_print(G_DEC_INSTRUCTION(expr->cond), buffer, line, output); result = g_dec_instruction_print(expr->true_branch, buffer, result, output); if (expr->false_branch != NULL) { g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "else", 4, RTT_KEY_WORD); result = g_dec_instruction_print(expr->false_branch, buffer, result, output); } return result; } /****************************************************************************** * * * Paramètres : cond = expression fixant le choix de l'aiguillage. * * true_branch = instructions si la condition est vérifiée. * * false_branch = instructions si la cond. n'est pas vérifiée. * * * * Description : Détermine le corps des différentes branches possibles. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_ite_instruction_set_branches(GITEInstruction *expr, GDecInstruction *true_branch, GDecInstruction *false_branch) { if (true_branch == NULL) { expr->inverse = true; expr->true_branch = false_branch; expr->false_branch = true_branch; } else { expr->true_branch = true_branch; expr->false_branch = false_branch; } }