/* OpenIDA - Outil d'analyse de fichiers binaires
* line_code.c - représentation des lignes de code binaire.
*
* Copyright (C) 2008 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 "line_code.h"
#include
#include
#include "line-int.h"
#include "../format/format.h"
/* Ligne de représentation de code binaire (instance) */
struct _GCodeLine
{
GRenderingLine parent; /* Instance parente */
GArchInstruction *instr; /* Instruction représentée */
const GRenderingOptions *options; /* Options de représentation */
};
/* Ligne de représentation de code binaire (classe) */
struct _GCodeLineClass
{
GRenderingLineClass parent; /* Classe parente */
};
/* Initialise la classe des lignes de code binaire. */
static void g_code_line_class_init(GCodeLineClass *);
/* Initialise la classe des lignes de code binaire. */
static void g_code_line_init(GCodeLine *);
/* Ajoute à un texte GTK le contenu de la ligne de code. */
static void g_code_line_add_to_gtk_buffer(GCodeLine *, MainRendering, GtkTextBuffer *, GtkTextIter *, size_t [SAR_COUNT]);
/* Indique le type définit par la GLib pour la ligne. */
G_DEFINE_TYPE(GCodeLine, g_code_line, G_TYPE_RENDERING_LINE);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des lignes de code binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_line_class_init(GCodeLineClass *klass)
{
}
/******************************************************************************
* *
* Paramètres : line = instance à initialiser. *
* *
* Description : Initialise la classe des lignes de code binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_line_init(GCodeLine *line)
{
GContentExporter *exporter_parent; /* Instance parente #1 */
GRenderingLine *line_parent; /* Instance parente #2 */
exporter_parent = G_CONTENT_EXPORTER(line);
exporter_parent->add_to_gtk_buffer = (add_to_gtk_buffer_fc)g_code_line_add_to_gtk_buffer;
line_parent = G_RENDERING_LINE(line);
line_parent->type = RLT_CODE;
}
/******************************************************************************
* *
* Paramètres : line = ligne de représentation à actualiser. *
* rendering = support effectif final des lignes de code. *
* buffer = zone de texte à venir compléter. *
* iter = point d'insertion du nouveau texte. *
* lengths = taille des différentes composantes de la ligne. *
* *
* Description : Ajoute à un texte GTK le contenu de la ligne de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_line_add_to_gtk_buffer(GCodeLine *line, MainRendering rendering, GtkTextBuffer *buffer, GtkTextIter *iter, size_t lengths[SAR_COUNT])
{
bool show_address; /* Affichage de l'adresse ? */
bool show_code; /* Affichage du code brut ? */
MemoryDataSize msize; /* Taille du bus d'adresses */
char address[VMPA_MAX_SIZE]; /* Adresse au format texte */
size_t len; /* Taille de l'élément inséré */
const bin_t *content; /* Contenu binaire global */
off_t bin_offset; /* Début de l'instruction */
off_t bin_len; /* Taille d'instruction */
char *bin_code; /* Tampon du code binaire */
off_t i; /* Boucle de parcours */
show_address = g_rendering_options_has_to_show_address(line->options, rendering);
show_code = g_rendering_options_has_to_show_code(line->options, rendering);
/* Eventuelle adresse virtuelle ou physique */
if (show_address)
{
msize = g_arch_processor_get_memory_size(g_rendering_options_get_processor(line->options));
len = vmpa_to_string(G_RENDERING_LINE(line)->offset, msize, address);
lengths[SAR_ADDRESS] = len;
g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(line), buffer, iter,
address, len, RTT_NONE);
g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(line), buffer, iter,
"\t", 1, RTT_NONE);
}
/* Eventuel code brut */
if (show_code)
{
content = g_binary_format_get_content(G_BIN_FORMAT(g_rendering_options_get_format(line->options)), NULL);
g_arch_instruction_get_location(line->instr, &bin_offset, &bin_len, NULL);
lengths[SAR_CODE] = MAX(lengths[SAR_CODE], bin_len * 3 - 1);
bin_code = (char *)calloc(bin_len * 3, sizeof(char));
for (i = 0; i < bin_len; i++)
{
if ((i + 1) < bin_len)
snprintf(&bin_code[i * (2 + 1)], 4, "%02hhx ", content[bin_offset + i]);
else
snprintf(&bin_code[i * (2 + 1)], 3, "%02hhx", content[bin_offset + i]);
}
g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(line), buffer, iter,
bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
free(bin_code);
g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(line), buffer, iter,
"\t", 1, RTT_NONE);
}
/* Instruction proprement dite */
g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(line->instr),
g_rendering_options_get_format(line->options),
ASX_INTEL/*FIXME*/, buffer, iter);
lengths[SAR_INSTRUCTION] = MAX(lengths[SAR_INSTRUCTION], 4 /* FIXME */);
}
/******************************************************************************
* *
* Paramètres : offset = emplacement physique ou en mémoire. *
* instr = instruction à représenter. *
* options = paramétrage du rendu. *
* *
* Description : Crée une ligne de code binaire. *
* *
* Retour : Adresse de la structure mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
GRenderingLine *g_code_line_new(uint64_t offset, GArchInstruction *instr, const GRenderingOptions *options)
{
GCodeLine *result; /* Structure à retourner */
result = g_object_new(G_TYPE_CODE_LINE, NULL);
G_RENDERING_LINE(result)->offset = offset;
g_arch_instruction_get_location(instr, NULL, &G_RENDERING_LINE(result)->length, NULL);
result->instr = instr;
result->options = options;
return G_RENDERING_LINE(result);
}
/******************************************************************************
* *
* Paramètres : line = line de rendu à consulter. *
* *
* Description : Fournit l'instruction associée à la ligne de code binaire. *
* *
* Retour : Adresse de l'instruction associée. *
* *
* Remarques : - *
* *
******************************************************************************/
GArchInstruction *g_code_line_get_instruction(const GCodeLine *line)
{
return line->instr;
}