path: root/src/analysis/block.c

/* 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 <http://www.gnu.org/licenses/>.
 */


#include "block.h"


#include <assert.h>
#include <malloc.h>


#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

    if (block->view != NULL)
        g_object_unref(G_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_object_unref(G_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;

}