path: root/src/arch/x86/operand.c

/* OpenIDA - Outil d'analyse de fichiers binaires
 * operand.c - gestion des operandes de l'architecture x86
 *
 * Copyright (C) 2008 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  OpenIDA is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  OpenIDA is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "operand.h"


#include <malloc.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>


#include "../operand.h"
#include "../operand-int.h"
#include "../../common/extstr.h"



/* ---------------------- COQUILLE VIDE POUR LES OPERANDES X86 ---------------------- */


/* Définition d'un opérande de x86 (instance) */
struct _GX86Operand
{
    GArchOperand parent;                    /* Instance parente            */

};


/* Définition d'un opérande de x86 (classe) */
struct _GX86OperandClass
{
    GArchOperandClass parent;               /* Classe parente              */

};


/* Initialise la classe des opérandes x86 de base. */
static void g_x86_operand_class_init(GX86OperandClass *);

/* Initialise une instance d'opérande de base pour x86. */
static void g_x86_operand_init(GX86Operand *);



/* ------------------------ OPERANDES VISANT UN REGISTRE X86 ------------------------ */


/* Définition d'un opérande visant un registre x86 (instance) */
struct _GX86RegisterOperand
{
    GX86Operand parent;                     /* Instance parente            */

    GX86Register *reg;                      /* Registre représenté         */

};


/* Définition d'un opérande visant un registre x86 (classe) */
struct _GX86RegisterOperandClass
{
    GX86OperandClass parent;                /* Classe parente              */

};


/* Initialise la classe des opérandes de registre x86. */
static void g_x86_register_operand_class_init(GX86RegisterOperandClass *);

/* Initialise une instance d'opérande de registre x86. */
static void g_x86_register_operand_init(GX86RegisterOperand *);

/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_register_operand_add_to_gtk_buffer(const GX86RegisterOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);



/* ----------------------- OPERANDES COMPLEXES DE TYPE MOD/RM ----------------------- */


/* Définition d'un opérande x86 de type ModRM (instance) */
struct _GX86ModRMOperand
{
    GX86Operand parent;                     /* Instance parente            */

    uint8_t scale;                          /* Puissance de deux           */
    GX86Register *index;                    /* Registre servant d'indice   */
    GX86Register *base;                     /* Registre de base            */
    GImmOperand *displacement;              /* Décallage supplémentaire    */

};


/* Définition d'un opérande x86 de type ModRM (classe) */
struct _GX86ModRMOperandClass
{
    GX86OperandClass parent;                /* Classe parente              */

};


/* Initialise la classe des opérandes x86 de type ModRM. */
static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *);

/* Initialise une instance d'opérande x86 de type ModRM. */
static void g_x86_mod_rm_operand_init(GX86ModRMOperand *);

/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_mod_rm_operand_add_to_gtk_buffer(const GX86ModRMOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);



/* ------------------------- OPERANDES D'ADRESSES RELATIVES ------------------------- */


/* Définition d'un opérande x86 d'adresse relative (instance) */
struct _GX86RelativeOperand
{
    GX86Operand parent;                     /* Instance parente            */

    GImmOperand *immediate;                 /* Adresse visée reconstituée  */

};

/* Définition d'un opérande x86 d'adresse relative (classe) */
struct _GX86RelativeOperandClass
{
    GX86OperandClass parent;                /* Classe parente              */

};


/* Initialise la classe des opérandes x86 d'adresse relative. */
static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *);

/* Initialise une instance d'opérande x86 d'adresse relative. */
static void g_x86_relative_operand_init(GX86RelativeOperand *);

/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_relative_operand_add_to_gtk_buffer(const GX86RelativeOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);



/* ------------------------ OPERANDES D'EMPLACEMENTS MEMOIRE ------------------------ */


/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */
struct _GX86MOffsOperand
{
    GX86Operand parent;                     /* Instance parente            */

    GImmOperand *offset;                    /* Adresse mémoire visée       */

};

/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */
struct _GX86MOffsOperandClass
{
    GX86OperandClass parent;                /* Classe parente              */

};


/* Initialise la classe des opérandes d'emplacement mémoire x86. */
static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *);

/* Initialise une instance d'opérande d'emplacement mémoire x86. */
static void g_x86_moffs_operand_init(GX86MOffsOperand *);

/* Ajoute à un texte GTK le contenu d'un opérande. */
static void g_x86_moffs_operand_add_to_gtk_buffer(const GX86MOffsOperand *, const GExeFormat *, AsmSyntax, GtkTextBuffer *, GtkTextIter *);



/* ---------------------------------------------------------------------------------- */
/*                        COQUILLE VIDE POUR LES OPERANDES X86                        */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande de x86. */
G_DEFINE_TYPE(GX86Operand, g_x86_operand, G_TYPE_ARCH_OPERAND);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des opérandes x86 de base.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_operand_class_init(GX86OperandClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande de base pour x86.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_operand_init(GX86Operand *operand)
{

}



/* ---------------------------------------------------------------------------------- */
/*                          OPERANDES VISANT UN REGISTRE X86                          */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande de registre x86. */
G_DEFINE_TYPE(GX86RegisterOperand, g_x86_register_operand, G_TYPE_X86_OPERAND);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des opérandes de registre x86.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_register_operand_class_init(GX86RegisterOperandClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande de registre x86.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_register_operand_init(GX86RegisterOperand *operand)
{
    GContentExporter *parent;               /* Instance parente            */

    parent = G_CONTENT_EXPORTER(operand);

    parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_register_operand_add_to_gtk_buffer;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : data = flux de données à analyser.                           *
*                pos  = position courante dans ce flux. [OUT]                 *
*                len  = taille totale des données à analyser.                 *
*                size = taille de l'opérande, et donc du registre.            *
*                base = indice du premier registre.                           *
*                                                                             *
*  Description : Crée un opérande visant un registre x86.                     *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bin_t base)
{
    GX86RegisterOperand *result;            /* Structure à retourner       */
    GX86Register *reg;                      /* Registre lu                 */

    reg = g_x86_register_new(size, data[*pos] - base);

    if (reg != NULL)
    {
        (*pos)++;

        result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);

        result->reg = reg;

    }
    else result = NULL;

    return G_ARCH_OPERAND(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : data  = flux de données à analyser.                          *
*                pos   = position courante dans ce flux. [OUT]                *
*                len   = taille totale des données à analyser.                *
*                size  = taille de l'opérande, et donc du registre.           *
*                first = indique la partie du ModR/M à traiter.               *
*                                                                             *
*  Description : Crée un opérande visant un registre x86.                     *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bool first)
{
    GX86RegisterOperand *result;            /* Structure à retourner       */
    bin_t index;                            /* Registre lu                 */
    GX86Register *reg;                      /* Registre créé               */

    if (first) index = data[*pos] & 0x07;
    else index = (data[*pos] & 0x38) >> 3;

    reg = g_x86_register_new(size, index);

    if (reg != NULL)
    {
        (*pos)++;

        result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);

        result->reg = reg;

    }
    else result = NULL;

    return G_ARCH_OPERAND(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : index = indice du registre visé.                             *
*                size  = taille de l'opérande, et donc du registre.           *
*                                                                             *
*  Description : Crée un opérande visant un registre x86 donné.               *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_register_operand_new_from_index(bin_t index, AsmOperandSize size)
{
    GX86RegisterOperand *result;            /* Structure à retourner       */
    GX86Register *reg;                      /* Registre lu                 */

    reg = g_x86_register_new(size, index);

    if (reg != NULL)
    {
        result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);

        result->reg = reg;

    }
    else result = NULL;

    return G_ARCH_OPERAND(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à transcrire.                             *
*                format = format du binaire manipulé.                         *
*                syntax = type de représentation demandée.                    *
*                buffer = zone de texte à venir compléter.                    *
*                iter   = point d'insertion du nouveau texte.                 *
*                                                                             *
*  Description : Ajoute à un texte GTK le contenu d'un opérande.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_register_operand_add_to_gtk_buffer(const GX86RegisterOperand *operand, const GExeFormat *format, AsmSyntax syntax, GtkTextBuffer *buffer, GtkTextIter *iter)
{
    g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->reg), format, syntax, buffer, iter);

}



/* ---------------------------------------------------------------------------------- */
/*                         OPERANDES COMPLEXES DE TYPE MOD/RM                         */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande x86 de type ModRM. */
G_DEFINE_TYPE(GX86ModRMOperand, g_x86_mod_rm_operand, G_TYPE_ARCH_OPERAND);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des opérandes x86 de type ModRM.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande x86 de type ModRM.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand)
{
    GContentExporter *parent;               /* Instance parente            */

    parent = G_CONTENT_EXPORTER(operand);

    parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_mod_rm_operand_add_to_gtk_buffer;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : data = flux de données à analyser.                           *
*                pos  = position courante dans ce flux. [OUT]                 *
*                len  = taille totale des données à analyser.                 *
*                size = taille de l'opérande, et donc du registre.            *
*                                                                             *
*  Description : Crée un opérande x86 de type ModRM.                          *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
{
    GX86ModRMOperand *result;               /* Structure à retourner       */
    uint8_t mod;                            /* Modificateur présent        */
    GX86Register *reg;                      /* Registre lu                 */

    mod = (data[*pos] & 0xc0);

    if (mod == 0xc0)
        return g_x86_register_operand_new_from_mod_rm(data, pos, len, size, true);

    reg = g_x86_register_new(size, data[*pos] & 0x07);
    if (reg == NULL) return NULL;

    (*pos)++;

    /* Vieille astuce de l'emplacement mémoire fixe ? */
    if (g_x86_register_is_base_pointer(reg) && mod == 0x00)
    {
        /* FIXME *///free_x86_register(reg);
        return g_imm_operand_new_from_data(MDS_32_BITS/* FIXME */, data, pos, len, SRE_LITTLE);
    }

    result = g_object_new(G_TYPE_X86_MOD_RM_OPERAND, NULL);

    /* A la recherche d'un SIB */
    if (g_x86_register_is_stack_pointer(reg))
    {
        /* FIXME *///free_x86_register(reg);

        result->base = g_x86_register_new(size, data[*pos] & 0x07);
        if (result->base == NULL) goto gxmron_error;

        result->index = g_x86_register_new(size, (data[*pos] & 0x38) >> 3);
        if (result->index == NULL) goto gxmron_error;

        result->scale = ((data[*pos] & 0xc0) >> 6);

        if (g_x86_register_is_stack_pointer(result->index))
        {
            /* FIXME *///free_x86_register(result->index);
            result->index = result->base;
            result->base = NULL;
        }

        (*pos)++;

    }

    else result->index = reg;

    /* Décallage supplémentaire ? */
    switch (mod)
    {
        case 0x00:
            if (result->base != NULL && g_x86_register_is_base_pointer(result->base))
            {
                /* FIXME *///free_x86_register(result->base);
                result->base = NULL;

                result->displacement = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE);
                if (result->displacement == NULL) goto gxmron_error;

            }
            break;

        case 0x40:
            result->displacement = g_imm_operand_new_from_data(MDS_8_BITS_SIGNED, data, pos, len, SRE_LITTLE);
            if (result->displacement == NULL) goto gxmron_error;
            break;

        case 0x80:
            result->displacement = g_imm_operand_new_from_data(MDS_32_BITS_SIGNED/* FIXME ! 16/32 */, data, pos, len, SRE_LITTLE);
            if (result->displacement == NULL) goto gxmron_error;
            break;

    }

    return G_ARCH_OPERAND(result);

 gxmron_error:

    /* FIXME free(result);*/
    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à transcrire.                             *
*                format = format du binaire manipulé.                         *
*                syntax = type de représentation demandée.                    *
*                buffer = zone de texte à venir compléter.                    *
*                iter   = point d'insertion du nouveau texte.                 *
*                                                                             *
*  Description : Ajoute à un texte GTK le contenu d'un opérande.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_mod_rm_operand_add_to_gtk_buffer(const GX86ModRMOperand *operand, const GExeFormat *format, AsmSyntax syntax, GtkTextBuffer *buffer, GtkTextIter *iter)
{
    char tmp[2];                            /* Echelle en puissance de 2   */

    switch (syntax)
    {
        case ASX_INTEL:

            g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                   "[", 1, RTT_HOOK);

            if (operand->scale > 0)
            {
                snprintf(tmp, 2, "%d", (int)pow(2, operand->scale)); 

                g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                       tmp, 1, RTT_IMMEDIATE);

                g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                       "*", 1, RTT_SIGNS);

            }

            g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->index),
                                                      format, syntax, buffer, iter);

            if (operand->base != NULL)
                g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->base),
                                                          format, syntax, buffer, iter);

            if (operand->displacement != NULL)
            {
                if (g_imm_operand_is_negative(operand->displacement))
                    g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                           "-", 1, RTT_SIGNS);
                else
                    g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                           "+", 1, RTT_SIGNS);

                g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->displacement),
                                                          format, syntax, buffer, iter);

            }

            g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                   "]", 1, RTT_HOOK);

            break;

        case ASX_ATT:

            /* TODO */
            g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                                   "[ModRM]", 7, RTT_HOOK);

            break;

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à consulter.                              *
*                scale   = facteur sous forme de puissance de deux. [OUT      *
*                index   = register principal de l'opérande. [OUT]            *
*                                                                             *
*  Description : Fournit l'indice et l'échelle d'un opérande x86 ModRM.       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *scale, const GX86Register **index)
{
    *scale = operand->scale;
    *index = operand->index;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à consulter.                              *
*                                                                             *
*  Description : Fournit le registre de base d'un opérande x86 ModRM.         *
*                                                                             *
*  Retour      : Registre de base de l'opérande.                              *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const GX86Register *g_x86_mod_rm_operand_get_base(const GX86ModRMOperand *operand)
{
    return operand->base;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à consulter.                              *
*                                                                             *
*  Description : Fournit le décallage supplémentaire d'un opérande x86 ModRM. *
*                                                                             *
*  Retour      : Décallage numérique pour l'opérande.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const GImmOperand *g_x86_mod_rm_operand_get_displacement(const GX86ModRMOperand *operand)
{
    return operand->displacement;

}



/* ---------------------------------------------------------------------------------- */
/*                           OPERANDES D'ADRESSES RELATIVES                           */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande x86 d'adresse relative. */
G_DEFINE_TYPE(GX86RelativeOperand, g_x86_relative_operand, G_TYPE_X86_OPERAND);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des opérandes x86 d'adresse relative.   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande x86 d'adresse relative.   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_relative_operand_init(GX86RelativeOperand *operand)
{
    GContentExporter *parent;               /* Instance parente            */

    parent = G_CONTENT_EXPORTER(operand);

    parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_relative_operand_add_to_gtk_buffer;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : data = flux de données à analyser.                           *
*                pos  = position courante dans ce flux. [OUT]                 *
*                len  = taille totale des données à analyser.                 *
*                size = taille de l'opérande, et donc du registre.            *
*                base = indice du premier registre.                           *
*                                                                             *
*  Description : Crée un opérande X86 d'adresse relative.                     *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, vmpa_t base)
{
    GX86RelativeOperand *result;            /* Structure à retourner       */
    off_t init_pos;                         /* Position avant lecture      */
    uint8_t val8;                           /* Valeur sur 8 bits           */
    uint16_t val16;                         /* Valeur sur 16 bits          */
    uint32_t val32;                         /* Valeur sur 32 bits          */
    uint32_t address32;                     /* Adresse finale visée        */

    init_pos = *pos;

    switch (size)
    {
        case AOS_8_BITS_UNSIGNED:
            read_u8(&val8, data, pos, len, SRE_LITTLE);
            address32 = val8;
            break;
        case AOS_16_BITS_UNSIGNED:
            read_u16(&val16, data, pos, len, SRE_LITTLE);
            address32 = val16;
            break;
        case AOS_32_BITS_UNSIGNED:
            read_u32(&val32, data, pos, len, SRE_LITTLE);
            address32 = val32;
            break;
        default:
            return NULL;
            break;
    }

    address32 += base + (*pos - init_pos);

    result = g_object_new(G_TYPE_X86_RELATIVE_OPERAND, NULL);
    result->immediate = g_imm_operand_new_from_value(AOS_32_BITS/*FIXME*/, address32);

    return G_ARCH_OPERAND(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à transcrire.                             *
*                format = format du binaire manipulé.                         *
*                syntax = type de représentation demandée.                    *
*                buffer = zone de texte à venir compléter.                    *
*                iter   = point d'insertion du nouveau texte.                 *
*                                                                             *
*  Description : Ajoute à un texte GTK le contenu d'un opérande.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_relative_operand_add_to_gtk_buffer(const GX86RelativeOperand *operand, const GExeFormat *format, AsmSyntax syntax, GtkTextBuffer *buffer, GtkTextIter *iter)
{
    g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->immediate),
                                              format, syntax, buffer, iter);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à traiter.                                *
*                                                                             *
*  Description : Fournit l'adresse relative représentée par une opérande X86. *
*                                                                             *
*  Retour      : Valeur portée par l'opérande.                                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *operand)
{
    return operand->immediate;

}



/* ---------------------------------------------------------------------------------- */
/*                          OPERANDES D'EMPLACEMENTS MEMOIRE                          */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini par la GLib pour un opérande d'emplacement mémoire x86. */
G_DEFINE_TYPE(GX86MOffsOperand, g_x86_moffs_operand, G_TYPE_X86_OPERAND);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des opérandes d'emplacement mémoire x86.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance d'opérande d'emplacement mémoire x86.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_moffs_operand_init(GX86MOffsOperand *operand)
{
    GContentExporter *parent;               /* Instance parente            */

    parent = G_CONTENT_EXPORTER(operand);

    parent->add_arch_to_gtk_buffer = (add_arch_to_gtk_buffer_fc)g_x86_moffs_operand_add_to_gtk_buffer;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : data = flux de données à analyser.                           *
*                pos  = position courante dans ce flux. [OUT]                 *
*                len  = taille totale des données à analyser.                 *
*                size = taille de l'opérande, et donc du registre.            *
*                                                                             *
*  Description : Crée un opérande d'emplacement mémoire x86.                  *
*                                                                             *
*  Retour      : Opérande mis en place.                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
{
    GX86MOffsOperand *result;               /* Structure à retourner       */
    GImmOperand *offset;                    /* Emplacement lu              */

    result = NULL;

    offset = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE);

    if (offset != NULL)
    {
        result = g_object_new(G_TYPE_X86_MOFFS_OPERAND, NULL);
        result->offset = offset;
    }

    return G_ARCH_OPERAND(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : operand = opérande à transcrire.                             *
*                format = format du binaire manipulé.                         *
*                syntax = type de représentation demandée.                    *
*                buffer = zone de texte à venir compléter.                    *
*                iter   = point d'insertion du nouveau texte.                 *
*                                                                             *
*  Description : Ajoute à un texte GTK le contenu d'un opérande.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_x86_moffs_operand_add_to_gtk_buffer(const GX86MOffsOperand *operand, const GExeFormat *format, AsmSyntax syntax, GtkTextBuffer *buffer, GtkTextIter *iter)
{
    g_content_exporter_insert_with_gtk_tag(G_CONTENT_EXPORTER(operand), buffer, iter,
                                           "ds:", 3, RTT_SEGMENT);

    g_content_exporter_add_arch_to_gtk_buffer(G_CONTENT_EXPORTER(operand->offset),
                                              format, syntax, buffer, iter);

}



/* ---------------------------------------------------------------------------------- */
/*                           AIDE A LA CREATION D'OPERANDES                           */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont la définition est à compléter. [OUT]*
*                data  = flux de données à analyser.                          *
*                pos   = position courante dans ce flux. [OUT]                *
*                len   = taille totale des données à analyser.                *
*                type  = type de l'opérande.                                  *
*                ...   = éventuelle(s) information(s) complémentaire(s).      *
*                                                                             *
*  Description : Procède à la lecture d'un opérande donné.                    *
*                                                                             *
*  Retour      : Bilan de l'opération : true en cas de succès, false sinon.   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool x86_read_one_operand(GArchInstruction *instr, const bin_t *data, off_t *pos, off_t len, X86OperandType type, ...)
{
    va_list ap;                             /* Liste des compléments       */
    AsmOperandSize oprsize;                 /* Taille des opérandes        */
    vmpa_t offset;                          /* Adresse courante            */
    bin_t base;                             /* Indice du premier registre  */
    GArchOperand *op;                       /* Opérande unique décodé      */

    va_start(ap, type);

    /* Lecture du premier opérande */

    switch (type)
    {
        case X86_OTP_IMM8:
            op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, len, SRE_LITTLE);
            break;

        case X86_OTP_IMM1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, pos, len, SRE_LITTLE);
            break;

        case X86_OTP_REL8:
            offset = va_arg(ap, vmpa_t);
            op = g_x86_relative_operand_new(data, pos, len, AOS_8_BITS, offset + 1);
            break;

        case X86_OTP_REL1632:
            oprsize = va_arg(ap, AsmOperandSize);
            offset = va_arg(ap, vmpa_t);
            op = g_x86_relative_operand_new(data, pos, len, oprsize, offset + 1);
            break;

        case X86_OTP_R8:
            op = g_x86_register_operand_new_from_mod_rm(data, pos, len, AOS_8_BITS, true);
            break;

        case X86_OTP_R1632:
            oprsize = va_arg(ap, AsmOperandSize);
            op = g_x86_register_operand_new_from_mod_rm(data, pos, len, oprsize, true);
            break;

        case X86_OTP_OP_R8:
            base = (bin_t)va_arg(ap, int);
            op = g_x86_register_operand_new_from_opcode(data, pos, len, AOS_8_BITS, base);
            break;

        case X86_OTP_OP_R1632:
            oprsize = va_arg(ap, AsmOperandSize);
            base = (bin_t)va_arg(ap, int);
            op = g_x86_register_operand_new_from_opcode(data, pos, len, oprsize, base);
            break;

        case X86_OTP_RM8:
            op = g_x86_mod_rm_operand_new(data, pos, len, AOS_8_BITS);
            break;

        case X86_OTP_RM1632:
            oprsize = va_arg(ap, AsmOperandSize);
            op = g_x86_mod_rm_operand_new(data, pos, len, oprsize);
            break;

        case X86_OTP_CL:
            op = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
            break;

        case X86_OTP_AL:
            op = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
            break;

        case X86_OTP_E_AX:
            oprsize = va_arg(ap, AsmOperandSize);
            op = g_x86_register_operand_new_from_index(0x00, oprsize);
            break;

    }

    va_end(ap);

    if (op == NULL) return false;

    g_arch_instruction_attach_one_operand(instr, op);

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : instr = instruction dont la définition est à compléter. [OUT]*
*                data  = flux de données à analyser.                          *
*                pos   = position courante dans ce flux. [OUT]                *
*                len   = taille totale des données à analyser.                *
*                type1 = type du premier opérande.                            *
*                type2 = type du second opérande.                             *
*                ...   = éventuelle(s) information(s) complémentaire(s).      *
*                                                                             *
*  Description : Procède à la lecture de deux opérandes donnés.               *
*                                                                             *
*  Retour      : Bilan de l'opération : true en cas de succès, false sinon.   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool x86_read_two_operands(GArchInstruction *instr, const bin_t *data, off_t *pos, off_t len, X86OperandType type1, X86OperandType type2, ...)
{
    va_list ap;                             /* Liste des compléments       */
    AsmOperandSize oprsize;                 /* Taille des opérandes        */
    bool op1_first;                         /* Position de l'opérande  #1  */
    bool op2_first;                         /* Position de l'opérande  #2  */
    off_t op1_pos;                          /* Position après lecture #1   */
    bin_t base;                             /* Indice du premier registre  */
    GArchOperand *op1;                      /* Premier opérande décodé     */
    off_t op2_pos;                          /* Position après lecture #2   */
    GArchOperand *op2;                      /* Second opérande décodé      */

    va_start(ap, type2);

    oprsize = AOS_UNDEFINED;

    if (type1 & X86_OTP_RM_TYPE)
    {
        op1_first = true;
        op2_first = false;
    }
    else if (type2 & X86_OTP_RM_TYPE)
    {
        op1_first = false;
        op2_first = true;
    }
    else
    {
        op1_first = true;
        op2_first = false;
    }

    /* Lecture du premier opérande */

    op1_pos = *pos;

    switch (type1)
    {
        case X86_OTP_IMM8:
            op1 = g_imm_operand_new_from_data(MDS_8_BITS, data, &op1_pos, len, SRE_LITTLE);
            break;

        case X86_OTP_IMM1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op1 = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op1_pos, len, SRE_LITTLE);
            break;

        case X86_OTP_MOFFS8:
            op1 = g_x86_moffs_operand_new(data, &op1_pos, len, AOS_8_BITS);
            break;

        case X86_OTP_MOFFS1632:
            oprsize = va_arg(ap, AsmOperandSize);
            op1 = g_x86_moffs_operand_new(data, &op1_pos, len, oprsize);
            break;

        case X86_OTP_R8:
            op1 = g_x86_register_operand_new_from_mod_rm(data, &op1_pos, len, AOS_8_BITS, op1_first);
            break;

        case X86_OTP_R1632:
            oprsize = va_arg(ap, AsmOperandSize);
            op1 = g_x86_register_operand_new_from_mod_rm(data, &op1_pos, len, oprsize, op1_first);
            break;

        case X86_OTP_OP_R8:
            base = (bin_t)va_arg(ap, int);
            op1 = g_x86_register_operand_new_from_opcode(data, &op1_pos, len, AOS_8_BITS, base);
            break;

        case X86_OTP_OP_R1632:
            oprsize = va_arg(ap, AsmOperandSize);
            base = (bin_t)va_arg(ap, int);
            op1 = g_x86_register_operand_new_from_opcode(data, &op1_pos, len, oprsize, base);
            break;

        case X86_OTP_RM8:
            op1 = g_x86_mod_rm_operand_new(data, &op1_pos, len, AOS_8_BITS);
            break;

        case X86_OTP_RM1632:
            oprsize = va_arg(ap, AsmOperandSize);
            op1 = g_x86_mod_rm_operand_new(data, &op1_pos, len, oprsize);
            break;

        case X86_OTP_CL:
            op1 = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
            break;

        case X86_OTP_AL:
            op1 = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
            break;

        case X86_OTP_E_AX:
            oprsize = va_arg(ap, AsmOperandSize);
            op1 = g_x86_register_operand_new_from_index(0x00, oprsize);
            break;

    }

    if (op1 == NULL)
    {
        va_end(ap);
        return false;
    }

    /* Lecture du second opérande */

    if ((type1 & X86_OTP_REG_TYPE || type1 & X86_OTP_RM_TYPE) && (type2 & X86_OTP_IMM_TYPE))
        op2_pos = op1_pos;
    else op2_pos = *pos;

    switch (type2)
    {
        case X86_OTP_IMM8:
            op2 = g_imm_operand_new_from_data(MDS_8_BITS, data, &op2_pos, len, SRE_LITTLE);
            break;

        case X86_OTP_IMM1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op2 = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op2_pos, len, SRE_LITTLE);
            break;

        case X86_OTP_MOFFS8:
            op2 = g_x86_moffs_operand_new(data, &op2_pos, len, AOS_8_BITS);
            break;

        case X86_OTP_MOFFS1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op2 = g_x86_moffs_operand_new(data, &op2_pos, len, oprsize);
            break;

        case X86_OTP_R8:
            op2 = g_x86_register_operand_new_from_mod_rm(data, &op2_pos, len, AOS_8_BITS, op2_first);
            break;

        case X86_OTP_R1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op2 = g_x86_register_operand_new_from_mod_rm(data, &op2_pos, len, oprsize, op2_first);
            break;

        case X86_OTP_RM8:
            op2 = g_x86_mod_rm_operand_new(data, &op2_pos, len, AOS_8_BITS);
            break;

        case X86_OTP_RM1632:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op2 = g_x86_mod_rm_operand_new(data, &op2_pos, len, oprsize);
            break;

        case X86_OTP_CL:
            op2 = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
            break;

        case X86_OTP_AL:
            op2 = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
            break;

        case X86_OTP_E_AX:
            if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
            op2 = g_x86_register_operand_new_from_index(0x00, oprsize);
            break;

    }

    if (op2 == NULL)
    {
        free(op1);
        va_end(ap);
        return false;
    }

    va_end(ap);

    /* Assemblage final */

    *pos = MAX(op1_pos, op2_pos);

    g_arch_instruction_attach_two_operands(instr, op1, op2);

    return true;

}