/* Chrysalide - Outil d'analyse de fichiers binaires
* block.h - encadrement des blocs de code
*
* Copyright (C) 2012-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 Chrysalide. If not, see .
*/
#include "block.h"
#include
#include
#include "block-int.h"
/* ----------------------------- BLOC DE CODE GENERIQUE ----------------------------- */
/* Initialise la classe des blocs de code. */
static void g_code_block_class_init(GCodeBlockClass *);
/* Initialise un bloc de code. */
static void g_code_block_init(GCodeBlock *);
/* Supprime toutes les références externes. */
static void g_code_block_dispose(GCodeBlock *);
/* Procède à la libération totale de la mémoire. */
static void g_code_block_finalize(GCodeBlock *);
/* Indique l'indice d'intégration du bloc dans une liste. */
static void g_code_block_set_index(GCodeBlock *, size_t);
/* Etablit les liens entre un bloc de code et ses voisins. */
static void g_code_block_resolve_links(GCodeBlock *, const GBlockList *);
/* ------------------------- REGROUPEMENT EN LISTE DE BLOCS ------------------------- */
/* Description d'une liste de blocs de code (instance) */
struct _GBlockList
{
GObject parent; /* A laisser en premier */
GCodeBlock **blocks; /* Blocs de code rassemblés */
size_t count; /* Quantité de ces blocs */
};
/* Description d'une liste de blocs de code (classe) */
struct _GBlockListClass
{
GObjectClass parent; /* A laisser en premier */
};
/* Initialise la classe des listes de blocs de code. */
static void g_block_list_class_init(GBlockListClass *);
/* Initialise une liste de blocs de code. */
static void g_block_list_init(GBlockList *);
/* Supprime toutes les références externes. */
static void g_block_list_dispose(GBlockList *);
/* Procède à la libération totale de la mémoire. */
static void g_block_list_finalize(GBlockList *);
/* ---------------------------------------------------------------------------------- */
/* BLOC DE CODE GENERIQUE */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour un bloc de code. */
G_DEFINE_TYPE(GCodeBlock, g_code_block, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : class = classe à initialiser. *
* *
* Description : Initialise la classe des blocs de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_class_init(GCodeBlockClass *class)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)g_code_block_dispose;
object->finalize = (GObjectFinalizeFunc)g_code_block_finalize;
}
/******************************************************************************
* *
* Paramètres : block = instance à initialiser. *
* *
* Description : Initialise un bloc de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_init(GCodeBlock *block)
{
block->index = (size_t)-1;
block->rank = (size_t)-1;
block->from = NULL;
block->to = NULL;
block->view = NULL;
}
/******************************************************************************
* *
* Paramètres : block = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_dispose(GCodeBlock *block)
{
#ifndef NDEBUG
g_code_block_lock_src(block);
assert(count_flat_array_items(block->from) == 0);
g_code_block_unlock_src(block);
#endif
#ifndef NDEBUG
g_code_block_lock_dest(block);
assert(count_flat_array_items(block->to) == 0);
g_code_block_unlock_dest(block);
#endif
g_clear_object(&block->view);
G_OBJECT_CLASS(g_code_block_parent_class)->dispose(G_OBJECT(block));
}
/******************************************************************************
* *
* Paramètres : block = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_finalize(GCodeBlock *block)
{
delete_bit_field(block->domination);
G_OBJECT_CLASS(g_code_block_parent_class)->finalize(G_OBJECT(block));
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à consulter. *
* *
* Description : Indique la liste des blocs de code dominés. *
* *
* Retour : Champ de bits représentant des blocs. *
* *
* Remarques : - *
* *
******************************************************************************/
const bitfield_t *g_code_block_get_domination(const GCodeBlock *block)
{
return block->domination;
}
/******************************************************************************
* *
* Paramètres : block = bloc à mettre à jour. *
* index = indice valide dans la liste d'appartenance. *
* *
* Description : Indique l'indice d'intégration du bloc dans une liste. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_set_index(GCodeBlock *block, size_t index)
{
assert(block->index == (size_t)-1);
block->index = index;
}
/******************************************************************************
* *
* Paramètres : block = bloc à consulter. *
* *
* Description : Indique l'indice d'intégration du bloc dans une liste. *
* *
* Retour : Indice valide dans une liste. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_code_block_get_index(const GCodeBlock *block)
{
size_t result; /* Indice à retourner */
assert(block->index != (size_t)-1);
result = block->index;
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à consulter. *
* addr = localisation à comparer. *
* *
* Description : Détermine si un bloc de code débute à une adresse donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_code_block_is_starting_with(const GCodeBlock *block, const vmpa2t *addr)
{
bool result; /* Bilan à retourner */
GCodeBlockClass *class; /* Classe des blocs de code */
class = G_CODE_BLOCK_GET_CLASS(block);
result = class->is_starting(block, addr);
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à mettre à jour. *
* list = ensemble des blocs de code à disposition. *
* *
* Description : Etablit les liens entre un bloc de code et ses voisins. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_code_block_resolve_links(GCodeBlock *block, const GBlockList *list)
{
GCodeBlockClass *class; /* Classe des blocs de code */
class = G_CODE_BLOCK_GET_CLASS(block);
class->link(block, list);
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à consulter. *
* *
* Description : Fournit le rang du bloc de code dans le flot d'exécution. *
* *
* Retour : Indice supérieur ou égal à zéro. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_code_block_get_rank(const GCodeBlock *block)
{
size_t result; /* Rang à retourner */
result = block->rank;
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à mettre à jour. *
* rank = indice supérieur à zéro à prendre en compte. *
* *
* Description : Définit le rang du bloc de code dans le flot d'exécution. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_block_set_rank(GCodeBlock *block, size_t rank)
{
block->rank = rank;
}
/******************************************************************************
* *
* Paramètres : block = bloc de code à manipuler. *
* highlighted = gestionnaire de surbrillance pour segments. *
* *
* Description : Fournit la représentation graphique d'un bloc de code. *
* *
* Retour : Vue d'un cache de lignes. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferView *g_code_block_get_view(GCodeBlock *block, segcnt_list *highlighted)
{
GBufferView *result; /* Instance à retourner */
GCodeBlockClass *class; /* Classe des blocs de code */
if (block->view == NULL)
{
class = G_CODE_BLOCK_GET_CLASS(block);
block->view = class->build(block, highlighted);
}
result = block->view;
g_object_ref(G_OBJECT(result));
return result;
}
/* ---------------------------------------------------------------------------------- */
/* DEFINITION DE LIAISONS ENTRE BLOCS DE CODE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : block = bloc de code à mettre à jour. *
* src = sélection de l'extrémité à traiter. *
* lock = indique le sens du verrouillage à mener. *
* *
* Description : Met à disposition un encadrement des accès aux liens. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_block_lock_unlock_links(GCodeBlock *block, bool src, bool lock)
{
flat_array_t **array; /* Choix du tableau ciblé */
array = (src ? &block->from : &block->to);
if (lock)
lock_flat_array(array);
else
unlock_flat_array(array);
}
/******************************************************************************
* *
* Paramètres : block = bloc dont les informations sont à consulter. *
* dest = bloc de code visé par la liaison (côté destination). *
* type = type de lien à construire. *
* *
* Description : Etablit un lien entre deux blocs de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_block_link_with(GCodeBlock *block, GCodeBlock *dest, InstructionLinkType type)
{
block_link_t new_src; /* Nouveau lien à définir #1 */
block_link_t new_dst; /* Nouveau lien à définir #2 */
/* Côté destination */
new_src.linked = block;
new_src.type = type;
ref_block_link((&new_src));
/* Côté point de départ */
new_dst.linked = dest;
new_dst.type = type;
ref_block_link((&new_dst));
/* Ajout dans le respect d'une cohérence globale */
g_code_block_lock_src(dest);
g_code_block_lock_dest(block);
add_item_to_flat_array(&dest->from, &new_src, sizeof(block_link_t));
add_item_to_flat_array(&block->to, &new_dst, sizeof(block_link_t));
g_code_block_unlock_dest(block);
g_code_block_unlock_src(dest);
}
/******************************************************************************
* *
* Paramètres : block = bloc de code dont les informations sont à traiter. *
* *
* Description : Supprime tous les liens établis avec d'autres blocs de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_code_block_delete_all_links(GCodeBlock *block)
{
block_link_t *link_src; /* Lien à supprimer #2 */
GCodeBlock *other; /* Bloc de l'autre bout */
size_t count; /* Quantié de liens présents */
size_t i; /* Boucle de parcours */
block_link_t *link_dst; /* Lien à supprimer #1 */
/* Coté sources */
g_code_block_lock_src(block);
while (count_flat_array_items(block->from) > 0)
{
link_src = get_flat_array_item(block->from, 0, sizeof(block_link_t));
other = link_src->linked;
g_code_block_lock_dest(other);
count = count_flat_array_items(other->to);
for (i = 0; i < count; i++)
{
link_dst = get_flat_array_item(other->to, i, sizeof(block_link_t));
if (link_dst->linked == block && link_dst->type == link_src->type)
{
unref_block_link(link_dst);
rem_item_from_flat_array(&other->to, i, sizeof(block_link_t));
break;
}
}
assert(i < count);
g_code_block_unlock_dest(other);
unref_block_link(link_src);
rem_item_from_flat_array(&block->from, 0, sizeof(block_link_t));
}
g_code_block_unlock_src(block);
/* Coté destinations */
g_code_block_lock_dest(block);
while (count_flat_array_items(block->to) > 0)
{
link_dst = get_flat_array_item(block->to, 0, sizeof(block_link_t));
other = link_dst->linked;
g_code_block_lock_src(other);
count = count_flat_array_items(other->from);
for (i = 0; i < count; i++)
{
link_src = get_flat_array_item(other->from, i, sizeof(block_link_t));
if (link_src->linked == block && link_src->type == link_dst->type)
{
unref_block_link(link_src);
rem_item_from_flat_array(&other->from, i, sizeof(block_link_t));
break;
}
}
assert(i < count);
g_code_block_unlock_src(other);
unref_block_link(link_dst);
rem_item_from_flat_array(&block->to, 0, sizeof(block_link_t));
}
g_code_block_unlock_dest(block);
}
/******************************************************************************
* *
* Paramètres : block = bloc dont les informations sont à consulter. *
* *
* Description : Fournit la quantité de blocs de code pointant vers un autre. *
* *
* Retour : Nombre de ces origines. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_code_block_count_sources(const GCodeBlock *block)
{
size_t result; /* Nombre de liens à renvoyer */
result = count_flat_array_items(block->from);
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc dont les informations sont à consulter. *
* index = indice de l'élément à retrouver. *
* *
* Description : Fournit les détails d'une origine d'un bloc de code donné. *
* *
* Retour : Lien déterminé vers un bloc de code d'origine. *
* *
* Remarques : - *
* *
******************************************************************************/
const block_link_t *g_code_block_get_source(GCodeBlock *block, size_t index)
{
block_link_t *result; /* Détails présents à renvoyer */
result = get_flat_array_item(block->from, index, sizeof(block_link_t));
ref_block_link(result);
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc dont les informations sont à consulter. *
* *
* Description : Donne le nombre de blocs de code suivants dans le flot. *
* *
* Retour : Nombre de ces destinations. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_code_block_count_destinations(const GCodeBlock *block)
{
size_t result; /* Nombre de liens à renvoyer */
result = count_flat_array_items(block->to);
return result;
}
/******************************************************************************
* *
* Paramètres : block = bloc dont les informations sont à consulter. *
* index = indice de l'élément à retrouver. *
* *
* Description : Fournit les détails d'une destination de bloc de code. *
* *
* Retour : Lien déterminé vers un bloc de code de destination. *
* *
* Remarques : - *
* *
******************************************************************************/
const block_link_t *g_code_block_get_destination(GCodeBlock *block, size_t index)
{
block_link_t *result; /* Détails présents à renvoyer */
result = get_flat_array_item(block->to, index, sizeof(block_link_t));
ref_block_link(result);
return result;
}
/* ---------------------------------------------------------------------------------- */
/* REGROUPEMENT EN LISTE DE BLOCS */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour une liste de blocs de code. */
G_DEFINE_TYPE(GBlockList, g_block_list, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : class = classe à initialiser. *
* *
* Description : Initialise la classe des listes de blocs de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_block_list_class_init(GBlockListClass *class)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)g_block_list_dispose;
object->finalize = (GObjectFinalizeFunc)g_block_list_finalize;
}
/******************************************************************************
* *
* Paramètres : block = instance à initialiser. *
* *
* Description : Initialise une liste de blocs de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_block_list_init(GBlockList *list)
{
list->blocks = NULL;
list->count = 0;
}
/******************************************************************************
* *
* Paramètres : block = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_block_list_dispose(GBlockList *list)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < list->count; i++)
if (list->blocks[i] != NULL)
{
g_code_block_delete_all_links(list->blocks[i]);
g_clear_object(&list->blocks[i]);
}
G_OBJECT_CLASS(g_block_list_parent_class)->dispose(G_OBJECT(list));
}
/******************************************************************************
* *
* Paramètres : block = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_block_list_finalize(GBlockList *list)
{
if (list->blocks != NULL)
free(list->blocks);
G_OBJECT_CLASS(g_block_list_parent_class)->finalize(G_OBJECT(list));
}
/******************************************************************************
* *
* Paramètres : count = quantité finale de blocs présentie. *
* *
* Description : Crée une liste de blocs de code. *
* *
* Retour : Adresse de la structure mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
GBlockList *g_block_list_new(size_t count)
{
GBlockList *result; /* Structure à retourner */
result = g_object_new(G_TYPE_BLOCK_LIST, NULL);
result->blocks = (GCodeBlock **)calloc(count, sizeof(GCodeBlock *));
result->count = count;
return result;
}
/******************************************************************************
* *
* Paramètres : list = liste de blocs de code à consulter. *
* *
* Description : Compte le nombre de blocs de code représentés. *
* *
* Retour : Quantité de blocs de code rassemblés. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_block_list_count_blocks(const GBlockList *list)
{
size_t result; /* Quantité à retourner */
result = list->count;
return result;
}
/******************************************************************************
* *
* Paramètres : list = liste de blocs de code à compléter. *
* block = bloc de code à intégrer. *
* index = indice de la position d'insertion du bloc. *
* *
* Description : Ajoute un bloc de code à une liste définie. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_block_list_add_block(GBlockList *list, GCodeBlock *block, size_t index)
{
assert(index < list->count);
assert(list->blocks[index] == NULL);
list->blocks[index] = block;
g_code_block_set_index(block, index);
}
/******************************************************************************
* *
* Paramètres : list = ensemble des blocs de code à traiter. *
* *
* Description : Etablit les liens entre les blocs de code et leurs voisins. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_block_list_resolve_links(const GBlockList *list)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < list->count; i++)
g_code_block_resolve_links(list->blocks[i], list);
}
/******************************************************************************
* *
* Paramètres : list = liste de blocs de code à consulter. *
* index = indice de la position du bloc recherché. *
* *
* Description : Fournit le bloc de code correspondant à un indice de liste. *
* *
* Retour : Bloc de code trouvé, ou NULL en cas d'erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBlock *g_block_list_get_block(const GBlockList *list, size_t index)
{
GCodeBlock *result; /* Bloc de code à retourner */
assert(index < list->count);
if (index < list->count)
result = list->blocks[index];
else
result = NULL;
/**
* La liste peut être dimensionnée sans avoir été remplie...
* Donc on fait attention avec le compteur de références.
*/
if (result != NULL)
g_object_ref(G_OBJECT(result));
return result;
}
/******************************************************************************
* *
* Paramètres : list = liste de blocs de code à consulter. *
* addr = localisation à comparer. *
* *
* Description : Recherche un bloc de code débutant à une adresse donnée. *
* *
* Retour : Bloc de code trouvé ou NULL si aucun. *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBlock *g_block_list_find_by_starting_instr(const GBlockList *list, const vmpa2t *addr)
{
GCodeBlock *result; /* Trouvaille à retourner */
size_t i; /* Boucle de parcours */
GCodeBlock *block; /* Bloc basique analysé */
result = NULL;
for (i = 0; i < list->count && result == NULL; i++)
{
block = list->blocks[i];
/**
* La liste peut être dimensionnée sans avoir été remplie...
* Donc on fait attention.
*/
assert(block != NULL);
if (block == NULL)
continue;
if (g_code_block_is_starting_with(block, addr))
{
result = block;
g_object_ref(G_OBJECT(result));
}
}
return result;
}