/* 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 du texte simple à un fichier ouvert en écriture. */
static void g_code_line_add_text(GCodeLine *, GRenderingOptions *, MainRendering, FILE *);
/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
static void g_code_line_to_buffer(GCodeLine *, GBufferLine *, GRenderingOptions *);
/* 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_text = (add_text_fc)g_code_line_add_text;
exporter_parent->export_buffer = (export_buffer_fc)g_code_line_to_buffer;
line_parent = G_RENDERING_LINE(line);
line_parent->type = RLT_CODE;
}
/******************************************************************************
* *
* Paramètres : line = ligne de représentation à représenter. *
* options = options de rendu. *
* rendering = support effectif final des lignes de code. *
* stream = flux ouvert en écriture. *
* *
* Description : Ajoute du texte simple à un fichier ouvert en écriture. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_line_add_text(GCodeLine *line, GRenderingOptions *options, MainRendering rendering, FILE *stream)
{
GContentExporter *exporter; /* Autre vision de la ligne #1 */
GRenderingLine *basic; /* Autre vision de la ligne #2 */
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 */
exporter = G_CONTENT_EXPORTER(line);
basic = G_RENDERING_LINE(line);
show_address = g_rendering_options_has_to_show_address(options, rendering);
show_code = g_rendering_options_has_to_show_code(options, rendering);
/* Eventuelle adresse virtuelle ou physique */
if (show_address)
{
msize = g_arch_processor_get_memory_size(g_rendering_options_get_processor(options));
len = vmpa_to_string(G_RENDERING_LINE(line)->offset, msize, address);
g_content_exporter_insert_text(exporter, stream, address, len, RTT_NONE);
g_content_exporter_insert_text(exporter, stream, "\t", 1, RTT_NONE);
}
/* Eventuel code brut */
if (show_code)
{
content = g_binary_format_get_content(G_BIN_FORMAT(g_rendering_options_get_format(options)), NULL);
g_arch_instruction_get_location(line->instr, &bin_offset, &bin_len, NULL);
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_text(exporter, stream, bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
free(bin_code);
g_content_exporter_insert_text(exporter, stream, "\t", 1, RTT_NONE);
}
/* Instruction proprement dite */
g_content_exporter_add_text(G_CONTENT_EXPORTER(line->instr), options, rendering, stream);
/* Commentaire ? */
if (basic->comment != NULL)
{
g_content_exporter_insert_text(exporter, stream, "\t", 1, RTT_NONE);
g_content_exporter_insert_text(exporter, stream, "; ", 2, RTT_COMMENT);
g_content_exporter_insert_text(exporter, stream, basic->comment,
strlen(basic->comment), RTT_COMMENT);
}
}
/******************************************************************************
* *
* Paramètres : line = ligne de représentation à représenter. *
* buffer = espace où placer ledit contenu. *
* options = options de rendu. *
* *
* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_line_to_buffer(GCodeLine *line, GBufferLine *buffer, GRenderingOptions *options)
{
GContentExporter *exporter; /* Autre vision de la ligne #1 */
GRenderingLine *basic; /* Autre vision de la ligne #2 */
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 */
exporter = G_CONTENT_EXPORTER(line);
basic = G_RENDERING_LINE(line);
/* Eventuelle adresse virtuelle ou physique */
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);
g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ADDRESS, address, len, RTT_RAW);
/* Eventuel code brut */
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);
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_into_buffer(exporter, buffer, BLC_BINARY,
bin_code, bin_len * 3 - 1, RTT_RAW_CODE);
free(bin_code);
/* Instruction proprement dite */
g_content_exporter_to_buffer(G_CONTENT_EXPORTER(line->instr), buffer, options);
/* Commentaire ? */
if (basic->comment != NULL)
{
g_content_exporter_insert_into_buffer(exporter, buffer, BLC_COMMENTS, "; ", 2, RTT_COMMENT);
g_content_exporter_insert_into_buffer(exporter, buffer, BLC_COMMENTS,
basic->comment, strlen(basic->comment), RTT_COMMENT);
}
}
/******************************************************************************
* *
* 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;
}