path: root/src/arch/instruction.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * instruction.c - gestion générique des instructions
 *
 * Copyright (C) 2008-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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "instruction.h"


#include <assert.h>
#include <stdarg.h>
#include <string.h>


#include "instruction-int.h"
#include "../glibext/linegen-int.h"



/* Accès aux décrochages */
static const char *_hook_names[IPH_COUNT] = {

    [IPH_FETCH] = "IPH_FETCH",
    [IPH_LINK] = "IPH_LINK",
    [IPH_POST] = "IPH_POST"

};


/* Initialise la classe générique des instructions. */
static void g_arch_instruction_class_init(GArchInstructionClass *);

/* Initialise une instance d'opérande d'architecture. */
static void g_arch_instruction_init(GArchInstruction *);

/* Procède à l'initialisation de l'interface de génération. */
static void g_arch_instruction_generator_interface_init(GLineGeneratorInterface *);

/* Supprime toutes les références externes. */
static void g_arch_instruction_dispose(GArchInstruction *);

/* Procède à la libération totale de la mémoire. */
static void g_arch_instruction_finalize(GArchInstruction *);



/* ------------------------ OFFRE DE CAPACITES DE GENERATION ------------------------ */


/* Indique le nombre de ligne prêtes à être générées. */
static size_t g_arch_instruction_count_lines(const GArchInstruction *);

/* Retrouve l'emplacement correspondant à une position donnée. */
static void g_arch_instruction_compute_addr(const GArchInstruction *, gint, vmpa2t *, size_t, size_t);

/* Détermine si le conteneur s'inscrit dans une plage donnée. */
static int g_arch_instruction_contains_addr(const GArchInstruction *, const vmpa2t *, size_t, size_t);

/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_arch_instruction_get_flags2(const GArchInstruction *, size_t, size_t);

/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
static void _g_arch_instruction_print(GArchInstruction *, GBufferLine *, size_t, size_t, const GBinContent *);

/* Imprime dans une ligne de rendu le contenu représenté. */
static void g_arch_instruction_print(GArchInstruction *, GBufferLine *, size_t, size_t, const GBinContent *);



/* Indique le type défini pour une instruction d'architecture. */
G_DEFINE_TYPE_WITH_CODE(GArchInstruction, g_arch_instruction, G_TYPE_OBJECT,
                        G_IMPLEMENT_INTERFACE(G_TYPE_LINE_GENERATOR, g_arch_instruction_generator_interface_init));


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe générique des instructions.             *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_class_init(GArchInstructionClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GArchInstructionClass *instr;           /* Encore une autre vision...  */

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_arch_instruction_dispose;
    object->finalize = (GObjectFinalizeFunc)g_arch_instruction_finalize;

    instr = G_ARCH_INSTRUCTION_CLASS(klass);

    instr->print = (print_instruction_fc)_g_arch_instruction_print;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance à initialiser.                              *
*                                                                             *
*  Description : Initialise une instance d'instruction d'architecture.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_init(GArchInstruction *instr)
{
    instr->operands = NULL;

    instr->from = NULL;
    instr->to = NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : iface = interface GLib à initialiser.                        *
*                                                                             *
*  Description : Procède à l'initialisation de l'interface de génération.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_generator_interface_init(GLineGeneratorInterface *iface)
{
    iface->count = (linegen_count_lines_fc)g_arch_instruction_count_lines;
    iface->compute = (linegen_compute_fc)g_arch_instruction_compute_addr;
    iface->contains = (linegen_contains_fc)g_arch_instruction_contains_addr;
    iface->get_flags = (linegen_get_flags_fc)g_arch_instruction_get_flags2;
    iface->print = (linegen_print_fc)g_arch_instruction_print;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_dispose(GArchInstruction *instr)
{
    size_t count;                           /* Nombre d'opérandes en place */
    size_t i;                               /* Boucle de parcours          */
    GArchOperand *op;                       /* Opérande à manipuler        */

    g_arch_instruction_lock_operands(instr);

    count = _g_arch_instruction_count_operands(instr);

    for (i = 0; i < count; i++)
    {
        op = _g_arch_instruction_get_operand(instr, 0);

        rem_item_from_flat_array(&instr->operands, 0, sizeof(GArchOperand *));

        /**
         * Une fois pour l'obtention, une autre pour la libération !
         */
        g_object_unref(G_OBJECT(op));
        g_object_unref(G_OBJECT(op));

    }

    g_arch_instruction_unlock_operands(instr);

    G_OBJECT_CLASS(g_arch_instruction_parent_class)->dispose(G_OBJECT(instr));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_finalize(GArchInstruction *instr)
{
    G_OBJECT_CLASS(g_arch_instruction_parent_class)->finalize(G_OBJECT(instr));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction quelconque à consulter.                  *
*                                                                             *
*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
*                                                                             *
*  Retour      : Description humaine de l'encodage utilisé.                   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char *g_arch_instruction_get_encoding(const GArchInstruction *instr)
{
    return G_ARCH_INSTRUCTION_GET_CLASS(instr)->get_encoding(instr);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction quelconque à modifier.                   *
*                flag  = drapeau d'information complémentaire à planter.      *
*                                                                             *
*  Description : Ajoute une information complémentaire à une instruction.     *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_arch_instruction_set_flag(GArchInstruction *instr, ArchInstrFlag flag)
{
    instr->flags |= flag;

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction quelconque à modifier.                   *
*                                                                             *
*  Description : Fournit les informations complémentaires d'une instruction.  *
*                                                                             *
*  Retour      : Eventuels drapeaux d'information complémentaire à plantés.   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

ArchInstrFlag g_arch_instruction_get_flags(const GArchInstruction *instr)
{
    return instr->flags;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction quelconque à modifier.                   *
*                type  = type de procédure à mémoriser.                       *
*                hook  = fonction à appeler sur commande.                     *
*                                                                             *
*  Description : Définit un traitement complémentare au désassemblage.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_set_hooks(GArchInstruction *instr, const instr_hook_fc hooks[IPH_COUNT])
{
    InstrProcessHook i;                     /* Boucle de parcours          */

    for (i = 0; i < IPH_COUNT; i++)
        g_object_set_data(G_OBJECT(instr), _hook_names[i], hooks[i]);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instruction quelconque à traiter.                  *
*                type    = type de procédure à utiliser.                      *
*                proc    = représentation de l'architecture utilisée.         *
*                context = contexte associé à la phase de désassemblage.      *
*                format  = accès aux données du binaire d'origine.            *
*                                                                             *
*  Description : Complète un désassemblage accompli pour une instruction.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_call_hook(GArchInstruction *instr, InstrProcessHook type, GArchProcessor *proc, GProcContext *context, GExeFormat *format)
{
    instr_hook_fc hook;

    assert(type < IPH_COUNT);

    hook = g_object_get_data(G_OBJECT(instr), _hook_names[type]);

    if (hook != NULL)
    {
        /**
         * Comme ce genre d'appel n'est effectué normalement qu'une seule fois
         * par instruction, on libère la mémoire au moment de cet unique appel.
         */
        g_object_set_data(G_OBJECT(instr), _hook_names[type], NULL);

        hook(instr, proc, context, format);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instruction quelconque à modifier.                 *
*                address = adresse virtuelle et/ou position physique.         *
*                length  = taille de l'instruction.                           *
*                                                                             *
*  Description : Définit la localisation d'une instruction.                   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_set_range(GArchInstruction *instr, const mrange_t *range)
{
    copy_mrange(&instr->range, range);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instruction quelconque à consulter.                *
*                                                                             *
*  Description : Fournit la place mémoire d'une instruction.                  *
*                                                                             *
*  Retour      : Zone mémoire couverte par l'instruction.                     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const mrange_t *g_arch_instruction_get_range(const GArchInstruction *instr)
{
    return &instr->range;

}



/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instruction quelconque à consulter.                *
*                offset  = position physique dans le code binaire/NULL. [OUT] *
*                length  = taille de l'instruction ou NULL. [OUT]             *
*                address = adresse virtuelle ou position physique/NULL. [OUT] *
*                                                                             *
*  Description : Fournit la localisation d'une instruction.                   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_get_location(const GArchInstruction *instr, off_t *offset, off_t *length, vmpa_t *address)
{
    //if (offset != NULL) *offset = instr->offset;
    //if (length != NULL) *length = instr->length;

    //if (address != NULL) *address = instr->address;

}



/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = instruction à consulter.                            *
*                rregs  = liste des rgistres lus. [OUT]                       *
*                rcount = nombre de registres lus. [OUT]                      *
*                wregs  = liste des rgistres écrits. [OUT]                    *
*                wcount = nombre de registres écrits. [OUT]                   *
*                                                                             *
*  Description : Liste les registres lus et écrits par l'instruction.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : Les compteurs de références sont à décrémenter après usage ! *
*                                                                             *
******************************************************************************/

void g_arch_instruction_get_rw_registers(const GArchInstruction *instr, GArchRegister ***rregs, size_t *rcount, GArchRegister ***wregs, size_t *wcount)
{
#if 0

    size_t i;                               /* Boucle de parcours          */

    *rregs = NULL;
    *rcount = 0;
    *wregs = NULL;
    *wcount = 0;

    instr->get_rw_regs(instr, rregs, rcount, wregs, wcount);

    for (i = 0; i < *rcount; i++)
        g_object_ref(G_OBJECT((*rregs)[i]));

    for (i = 0; i < *wcount; i++)
        g_object_ref(G_OBJECT((*wregs)[i]));

#endif

}



/* ---------------------------------------------------------------------------------- */
/*                             MANIPULATION DES OPERANDES                             */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction à mettre à jour.                         *
*                                                                             *
*  Description : Verrouille les accès à la liste des opérandes.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_lock_operands(GArchInstruction *instr)
{
    lock_flat_array(&instr->operands);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction à mettre à jour.                         *
*                                                                             *
*  Description : Déverrouille les accès à la liste des opérandes.             *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_unlock_operands(GArchInstruction *instr)
{
    unlock_flat_array(&instr->operands);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instance à mettre à jour.                          *
*                operand = instruction à venir associer.                      *
*                                                                             *
*  Description : Attache un opérande supplémentaire à une instruction.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_attach_extra_operand(GArchInstruction *instr, GArchOperand *operand)
{
    g_arch_instruction_lock_operands(instr);

    add_item_to_flat_array(&instr->operands, &operand, sizeof(GArchOperand *));

    g_arch_instruction_unlock_operands(instr);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance à consulter.                                *
*                                                                             *
*  Description : Indique la quantité d'opérandes présents dans l'instruction. *
*                                                                             *
*  Retour      : Nombre d'opérandes attachés.                                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

size_t _g_arch_instruction_count_operands(const GArchInstruction *instr)
{
    size_t result;                          /* Décompte à retourner        */

    result = count_flat_array_items(instr->operands);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance à consulter.                                *
*                index = indice de l'opérande concerné.                       *
*                                                                             *
*  Description : Fournit un opérande donné d'une instruction.                 *
*                                                                             *
*  Retour      : Opérande trouvée.                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *_g_arch_instruction_get_operand(const GArchInstruction *instr, size_t index)
{
    GArchOperand *result;                   /* Opérande à retourner        */
    GArchOperand **ptr;                     /* Adresse dans le tableau     */

    ptr = get_flat_array_item(instr->operands, index, sizeof(GArchOperand *));

    result = *ptr;

    g_object_ref(G_OBJECT(result));

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance à mettre à jour.                            *
*                old   = ancien opérande à remplacer.                         *
*                new   = nouvel opérande à intégrer.                          *
*                                                                             *
*  Description : Remplace un opérande d'une instruction par un autre.         *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_arch_instruction_replace_operand(GArchInstruction *instr, GArchOperand *old, GArchOperand *new)
{
    bool result;                            /* Bilan à retourner           */

    g_arch_instruction_lock_operands(instr);

    result = _g_arch_instruction_replace_operand(instr, old, new);

    g_arch_instruction_unlock_operands(instr);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instance à mettre à jour.                            *
*                old   = ancienne opérande à détacher.                        *
*                new   = nouvelle opérande à attacher.                        *
*                                                                             *
*  Description : Remplace un opérande d'une instruction par un autre.         *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool _g_arch_instruction_replace_operand(GArchInstruction *instr, GArchOperand *old, GArchOperand *new)
{
    bool result;                            /* Bilan à retourner           */
    size_t count;                           /* Nombre d'opérandes en place */
    size_t i;                               /* Boucle de parcours          */
    GArchOperand *op;                       /* Opérande à manipuler        */

    result = false;

    count = _g_arch_instruction_count_operands(instr);

    for (i = 0; i < count; i++)
    {
        op = _g_arch_instruction_get_operand(instr, i);

        if (op == old)
        {
            result = true;
            break;
        }

        g_object_unref(G_OBJECT(op));

    }

    if (result)
    {
        rpl_item_in_flat_array(instr->operands, i, &new, sizeof(GArchOperand *));

        g_object_unref(G_OBJECT(old));

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = instance à mettre à jour.                           *
*                target = instruction à venir dissocier.                      *
*                                                                             *
*  Description : Détache un opérande liée d'une instruction.                  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void _g_arch_instruction_detach_operand(GArchInstruction *instr, GArchOperand *target)
{
    size_t count;                           /* Nombre d'opérandes en place */
    size_t i;                               /* Boucle de parcours          */
    GArchOperand *op;                       /* Opérande à manipuler        */

    count = _g_arch_instruction_count_operands(instr);

    for (i = 0; i < count; i++)
    {
        op = _g_arch_instruction_get_operand(instr, i);

        if (op == target)
            break;

        g_object_unref(G_OBJECT(op));

    }

    rem_item_from_flat_array(&instr->operands, i, sizeof(GArchOperand *));

    g_object_unref(G_OBJECT(target));

}



/* ---------------------------------------------------------------------------------- */
/*                     DEFINITION DES LIAISONS ENTRE INSTRUCTIONS                     */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction à 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_arch_instruction_lock_unlock_links(GArchInstruction *instr, bool src, bool lock)
{
    flat_array_t **array;                   /* Choix du tableau ciblé      */

    array = (src ? &instr->from : &instr->to);

    if (lock)
        lock_flat_array(array);
    else
        unlock_flat_array(array);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                dest  = ligne visée par la liaison (côté destination).       *
*                                                                             *
*  Description : Détermine si un lien est déjà établi entre deux instructions.*
*                                                                             *
*  Retour      : Bilan de l'état actuel des liaisons.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_arch_instruction_has_link_to(GArchInstruction *instr, const GArchInstruction *dest)
{
    bool result;                            /* Bilan à retourner           */
    size_t count;                           /* Nombre de liens à parcourir */
    size_t i;                               /* Boucle de parcours          */
    instr_link_t *dlink;                    /* Définition de destination   */

    result = false;

    g_arch_instruction_lock_dest(instr);

    count = g_arch_instruction_count_destinations(instr);

    for (i = 0; i < count && !result; i++)
    {
        dlink = g_arch_instruction_get_destination(instr, i);

        result = (dlink->linked == dest);

    }

    g_arch_instruction_unlock_dest(instr);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                dest  = ligne visée par la liaison (côté destination).       *
*                type  = type de lien à construire.                           *
*                                                                             *
*  Description : Etablit un lien entre deux instructions.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_arch_instruction_link_with(GArchInstruction *instr, GArchInstruction *dest, InstructionLinkType type)
{
    instr_link_t new_src;                   /* Nouveau lien à définir #1   */
    instr_link_t new_dst;                   /* Nouveau lien à définir #2   */

    /* Côté destination */

    new_src.linked = instr;
    new_src.type = type;

    /* Côté point de départ */

    new_dst.linked = dest;
    new_dst.type = type;

    /* Ajout dans le respect d'une cohérence globale */

    g_arch_instruction_lock_src(dest);
    g_arch_instruction_lock_dest(instr);

    add_item_to_flat_array(&dest->from, &new_src, sizeof(instr_link_t));

    add_item_to_flat_array(&instr->to, &new_dst, sizeof(instr_link_t));

    g_arch_instruction_unlock_dest(instr);
    g_arch_instruction_unlock_src(dest);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                dest  = ligne visée par la liaison (côté destination).       *
*                old   = ancien type de lien construit.                       *
*                new   = nouveau type de lien à construire.                   *
*                                                                             *
*  Description : Change la nature d'un lien entre deux instructions.          *
*                                                                             *
*  Retour      : true pour une mise à jour réussie, false sinon.              *
*                                                                             *
*  Remarques   : Le verrou doit être posé sur les destinations de 'instr'.    *
*                                                                             *
******************************************************************************/

bool g_arch_instruction_change_link(GArchInstruction *instr, GArchInstruction *dest, InstructionLinkType old, InstructionLinkType new)
{
    bool result;                            /* Bilan à retourner           */
    size_t count;                           /* Raccourci pour la lecture   */
    size_t i;                               /* Boucle de parcours          */
    instr_link_t *slink;                    /* Définition de source        */
    instr_link_t *dlink;                    /* Définition de destination   */

    result = false;

    g_arch_instruction_lock_src(dest);

    /* Côté destination */

    count = g_arch_instruction_count_sources(dest);

    for (i = 0; i < count; i++)
    {
        slink = g_arch_instruction_get_source(dest, i);

        if (slink->linked == instr && slink->type == old)
            break;

    }

    if (i == count)
        goto gaicl_exit;

    /* Côté point de départ */

    count = g_arch_instruction_count_destinations(instr);

    for (i = 0; i < count; i++)
    {
        dlink = g_arch_instruction_get_destination(instr, i);

        if (dlink->linked == dest && dlink->type == old)
            break;

    }

    if (i == count)
        goto gaicl_exit;

    /* Si les deux extrémités sont raccord... */

    slink->type = new;

    dlink->type = new;

    result = true;

 gaicl_exit:

    g_arch_instruction_unlock_src(dest);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                                                                             *
*  Description : Fournit la quantité d'instructions pointant vers une autre.  *
*                                                                             *
*  Retour      : Nombre de ces origines.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

size_t g_arch_instruction_count_sources(const GArchInstruction *instr)
{
    size_t result;                          /* Nombre de liens à renvoyer  */

    result = count_flat_array_items(instr->from);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                index = indice de l'élément à retrouver.                     *
*                                                                             *
*  Description : Fournit les détails d'une origine d'une instruction donnée.  *
*                                                                             *
*  Retour      : Lien déterminé vers une instruction d'origine.               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

instr_link_t *g_arch_instruction_get_source(GArchInstruction *instr, size_t index)
{
    instr_link_t *result;                   /* Détails présents à renvoyer */

    result = get_flat_array_item(instr->from, index, sizeof(instr_link_t));

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                                                                             *
*  Description : Donne le nombre d'instructions non naturellement suivantes.  *
*                                                                             *
*  Retour      : Nombre de ces destinations.                                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

size_t g_arch_instruction_count_destinations(const GArchInstruction *instr)
{
    size_t result;                          /* Nombre de liens à renvoyer  */

    result = count_flat_array_items(instr->to);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                index = indice de l'élément à retrouver.                     *
*                                                                             *
*  Description : Fournit les détails d'une destination d'une instruction.     *
*                                                                             *
*  Retour      : Lien déterminé vers une instruction de destination.          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

instr_link_t *g_arch_instruction_get_destination(GArchInstruction *instr, size_t index)
{
    instr_link_t *result;                   /* Détails présents à renvoyer */

    result = get_flat_array_item(instr->to, index, sizeof(instr_link_t));

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont les informations sont à consulter.  *
*                type  = type de lien recherché.                              *
*                                                                             *
*  Description : Fournit la destination d'une instruction et d'un type donné. *
*                                                                             *
*  Retour      : Instruction de destination trouvée ou NULL.                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchInstruction *g_arch_instruction_get_given_destination(GArchInstruction *instr, InstructionLinkType type)
{
    GArchInstruction *result;               /* Résultat à remonter         */
    size_t count;                           /* Nombre de liens à parcourir */
    size_t i;                               /* Boucle de parcours          */
    instr_link_t *dest;                     /* Destination à étudier       */

    result = NULL;

    g_arch_instruction_lock_dest(instr);

    count = g_arch_instruction_count_destinations(instr);

    for (i = 0; i < count && result == NULL; i++)
    {
        dest = g_arch_instruction_get_destination(instr, i);

        if (dest->type == type)
        {
            result = dest->linked;
            g_object_ref(G_OBJECT(result));
        }

    }

    g_arch_instruction_unlock_dest(instr);

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                       CONVERSIONS DU FORMAT DES INSTRUCTIONS                       */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = instruction d'assemblage à consulter.               *
*                syntax = type de représentation demandée.                    *
*                                                                             *
*  Description : Fournit le nom humain de l'instruction manipulée.            *
*                                                                             *
*  Retour      : Mot clef de bas niveau.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char *g_arch_instruction_get_keyword(GArchInstruction *instr, AsmSyntax syntax)
{
    const char *result;                     /* Désignation à retourner     */

    result = G_ARCH_INSTRUCTION_GET_CLASS(instr)->get_keyword(instr, syntax);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction d'assemblage à consulter.                *
*                                                                             *
*  Description : Construit un petit résumé concis de l'instruction.           *
*                                                                             *
*  Retour      : Chaîne de caractères à libérer après usage ou NULL.          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *g_arch_instruction_build_tooltip(const GArchInstruction *instr)
{
    char *result;                           /* Description à retourner     */
    GArchInstructionClass *class;           /* Classe des instructions     */

    class = G_ARCH_INSTRUCTION_GET_CLASS(instr);

    if (class->build_tooltip != NULL)
        result = class->build_tooltip(instr);

    else
        result = NULL;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction d'assemblage à consulter.                *
*                                                                             *
*  Description : Fournit une description pour l'instruction manipulée.        *
*                                                                             *
*  Retour      : Chaîne de caractères avec balises éventuelles.               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/
  
const char *g_arch_instruction_get_description(const GArchInstruction *instr)
{
    const char *result;                     /* Description à retourner     */

    result = G_ARCH_INSTRUCTION_GET_CLASS(instr)->get_desc(instr);

    return result;
  
}



/* ---------------------------------------------------------------------------------- */
/*                          OFFRE DE CAPACITES DE GENERATION                          */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = générateur à consulter.                              *
*                                                                             *
*  Description : Indique le nombre de ligne prêtes à être générées.           *
*                                                                             *
*  Retour      : Nombre de lignes devant apparaître au final.                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static size_t g_arch_instruction_count_lines(const GArchInstruction *instr)
{
    return 1;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = générateur à consulter.                             *
*                x      = position géographique sur la ligne concernée.       *
*                addr   = position en mémoire à analyser.                     *
*                index  = indice de cette même ligne dans le tampon global.   *
*                repeat = indice d'utilisations successives du générateur.    *
*                                                                             *
*  Description : Retrouve l'emplacement correspondant à une position donnée.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_compute_addr(const GArchInstruction *instr, gint x, vmpa2t *addr, size_t index, size_t repeat)
{
    copy_vmpa(addr, get_mrange_addr(&instr->range));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = générateur à consulter.                             *
*                addr   = position en mémoire à analyser.                     *
*                index  = indice de cette même ligne dans le tampon global.   *
*                repeat = indice d'utilisations successives du générateur.    *
*                                                                             *
*  Description : Détermine si le conteneur s'inscrit dans une plage donnée.   *
*                                                                             *
*  Retour      : Bilan de la détermination, utilisable en comparaisons.       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static int g_arch_instruction_contains_addr(const GArchInstruction *instr, const vmpa2t *addr, size_t index, size_t repeat)
{
    int result;                             /* Conclusion à retourner      */

    result = cmp_mrange_with_vmpa(&instr->range, addr);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr  = générateur à consulter.                             *
*                index  = indice de cette même ligne dans le tampon global.   *
*                repeat = indice d'utilisations successives du générateur.    *
*                                                                             *
*  Description : Renseigne sur les propriétés liées à un générateur.          *
*                                                                             *
*  Retour      : Propriétés particulières associées.                          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static BufferLineFlags g_arch_instruction_get_flags2(const GArchInstruction *instr, size_t index, size_t repeat)
{
    return BLF_HAS_CODE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = instruction d'assemblage à représenter.            *
*                buffer  = espace où placer ledit contenu.                    *
*                msize   = taille idéale des positions et adresses;           *
*                content = contenu binaire global à venir lire.               *
*                syntax  = type de représentation demandée.                   *
*                content = éventuel contenu binaire brut à imprimer.          *
*                                                                             *
*  Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void _g_arch_instruction_print(GArchInstruction *instr, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content)
{
    const char *key;                        /* Mot clef principal          */
    size_t klen;                            /* Taille de ce mot clef       */
    size_t count;                           /* Nombre d'opérandes en place */
    size_t i;                               /* Boucle de parcours          */
    GArchOperand *op;                       /* Opérande à manipuler        */

    g_buffer_line_fill_vmpa(line, get_mrange_addr(&instr->range), MDS_32_BITS_UNSIGNED, MDS_32_BITS_UNSIGNED);

    g_buffer_line_fill_content(line, content, &instr->range, VMPA_NO_PHYSICAL);

    /* Instruction proprement dite */

    key = g_arch_instruction_get_keyword(instr, 0/*, syntax*/);
    klen = strlen(key);

    g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, key, klen, RTT_INSTRUCTION, G_OBJECT(instr));

    /* Liste des opérandes */

    g_arch_instruction_lock_operands(instr);

    count = _g_arch_instruction_count_operands(instr);

    if (count > 0)
    {
        op = _g_arch_instruction_get_operand(instr, 0);
        g_arch_operand_print(op, line, 0/*syntax*/);
        g_object_unref(G_OBJECT(op));

        for (i = 1; i < count; i++)
        {
            g_buffer_line_append_text(line, BLC_ASSEMBLY, ",", 1, RTT_PUNCT, NULL);
            g_buffer_line_append_text(line, BLC_ASSEMBLY, " ", 1, RTT_RAW, NULL);

            op = _g_arch_instruction_get_operand(instr, i);

            g_arch_operand_print(op, line, 0/*syntax*/);

            g_object_unref(G_OBJECT(op));

        }

    }

    g_arch_instruction_unlock_operands(instr);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr   = générateur à utiliser pour l'impression.           *
*                line    = ligne de rendu à compléter.                        *
*                index   = indice de cette même ligne dans le tampon global.  *
*                repeat  = indice d'utilisations successives du générateur.   *
*                content = éventuel contenu binaire brut à imprimer.          *
*                                                                             *
*  Description : Imprime dans une ligne de rendu le contenu représenté.       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_arch_instruction_print(GArchInstruction *instr, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content)
{
    G_ARCH_INSTRUCTION_GET_CLASS(instr)->print(instr, line, index, repeat, content);

}