Created a new interface for renamed operands.

6 files changed, 780 insertions, 26 deletions

diff --git a/src/arch/operands/Makefile.am b/src/arch/operands/Makefile.am
index 3d464e3..4e52f58 100644
--- a/src/arch/operands/Makefile.am
+++ b/src/arch/operands/Makefile.am
@@ -5,6 +5,8 @@ libarchoperands_la_SOURCES =			\
 	immediate.h immediate.c				\
 	register-int.h						\
 	register.h register.c				\
+	rename-int.h						\
+	rename.h rename.c					\
 	targetable-int.h					\
 	targetable.h targetable.c
 
diff --git a/src/arch/operands/immediate.c b/src/arch/operands/immediate.c
index 0ecb5f7..58e40aa 100644
--- a/src/arch/operands/immediate.c
+++ b/src/arch/operands/immediate.c
@@ -37,14 +37,19 @@
 #include <i18n.h>
 
 
+#include "rename-int.h"
 #include "targetable-int.h"
 #include "../operand-int.h"
 #include "../../common/asm.h"
 #include "../../common/extstr.h"
+#include "../../core/logs.h"
 #include "../../format/format.h"
 
 
 
+/* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
+
+
 /* Définition d'un opérande de valeur numérique (instance) */
 struct _GImmOperand
 {
@@ -81,15 +86,18 @@ struct _GImmOperandClass
 };
 
 
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise la classe des opérandes de valeur immédiate. */
 static void g_imm_operand_class_init(GImmOperandClass *);
 
-/* Initialise la classe des lignes de descriptions initiales. */
+/* Initialise un opérande de valeur immédiate. */
 static void g_imm_operand_init(GImmOperand *);
 
 /* Procède à l'initialisation de l'interface de ciblage. */
 static void g_imm_operand_targetable_interface_init(GTargetableOperandInterface *);
 
+/* Procède à l'initialisation de l'interface de renommage. */
+static void g_imm_operand_renameable_interface_init(GRenameableOperandInterface *);
+
 /* Supprime toutes les références externes. */
 static void g_imm_operand_dispose(GImmOperand *);
 
@@ -111,38 +119,88 @@ static void g_imm_operand_print(const GImmOperand *, GBufferLine *);
 /* Construit un petit résumé concis de l'opérande. */
 static char *g_imm_operand_build_tooltip(const GImmOperand *, const GLoadedBinary *);
 
-
-
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
-
-
 /* Charge un opérande depuis une mémoire tampon. */
 static bool g_imm_operand_unserialize(GImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer *);
 
 /* Sauvegarde un opérande dans une mémoire tampon. */
 static bool g_imm_operand_serialize(const GImmOperand *, GAsmStorage *, packed_buffer *);
 
+/* Obtient l'adresse de la cible visée par un opérande. */
+static bool g_imm_operand_get_addr(const GImmOperand *, const vmpa2t *, GBinFormat *, GArchProcessor *, vmpa2t *);
 
+/* Construit un opérande de représentation alternative. */
+static GRenamedOperand *g_imm_operand_build(const GImmOperand *, const char *);
 
-/* ----------------------- INTERFACE DE CIBLAGE POUR OPERANDE ----------------------- */
 
 
-/* Obtient l'adresse de la cible visée par un opérande. */
-static bool g_imm_operand_get_addr(const GImmOperand *, const vmpa2t *, GBinFormat *, GArchProcessor *, vmpa2t *);
+/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
+
+
+/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
+struct _GKnownImmOperand
+{
+    GImmOperand parent;                     /* Instance parente            */
+
+    char *alt_text;                         /* Alternative humaine         */
+
+};
+
+/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
+struct _GKnownImmOperandClass
+{
+    GImmOperandClass parent;                /* Classe parente              */
+
+};
+
 
+/* Initialise la classe des remplacements d'opérandes. */
+static void g_known_imm_operand_class_init(GKnownImmOperandClass *);
+
+/* Initialise un remplacement d'opérande de valeur immédiate. */
+static void g_known_imm_operand_init(GKnownImmOperand *);
+
+/* Procède à l'initialisation de l'interface de renommage. */
+static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *);
+
+/* Supprime toutes les références externes. */
+static void g_known_imm_operand_dispose(GKnownImmOperand *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_known_imm_operand_finalize(GKnownImmOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_known_imm_operand_compare(const GKnownImmOperand *, const GKnownImmOperand *);
+
+/* Traduit un opérande en version humainement lisible. */
+static void g_known_imm_operand_print(const GKnownImmOperand *, GBufferLine *);
+
+/* Charge un opérande depuis une mémoire tampon. */
+static bool g_known_imm_operand_unserialize(GKnownImmOperand *, GAsmStorage *, GBinFormat *, packed_buffer *);
+
+/* Sauvegarde un opérande dans une mémoire tampon. */
+static bool g_known_imm_operand_serialize(const GKnownImmOperand *, GAsmStorage *, packed_buffer *);
+
+/* Fournit un texte comme représentation alternative d'opérande. */
+static const char *g_known_imm_operand_get_text(const GKnownImmOperand *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           OPERANDE POUR VALEUR IMMEDIATE                           */
+/* ---------------------------------------------------------------------------------- */
 
 
 /* Indique le type défini pour un opérande de valeur numérique. */
 G_DEFINE_TYPE_WITH_CODE(GImmOperand, g_imm_operand, G_TYPE_ARCH_OPERAND,
-                        G_IMPLEMENT_INTERFACE(G_TYPE_TARGETABLE_OPERAND, g_imm_operand_targetable_interface_init));
-
+                        G_IMPLEMENT_INTERFACE(G_TYPE_TARGETABLE_OPERAND, g_imm_operand_targetable_interface_init)
+                        G_IMPLEMENT_INTERFACE(G_TYPE_RENAMEABLE_OPERAND, g_imm_operand_renameable_interface_init));
 
 
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*  Description : Initialise la classe des opérandes de valeur immédiate.      *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -175,7 +233,7 @@ static void g_imm_operand_class_init(GImmOperandClass *klass)
 *                                                                             *
 *  Paramètres  : operand = instance à initialiser.                            *
 *                                                                             *
-*  Description : Initialise la classe des lignes de descriptions initiales.   *
+*  Description : Initialise un opérande de valeur immédiate.                  *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -214,6 +272,25 @@ static void g_imm_operand_targetable_interface_init(GTargetableOperandInterface
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de renommage.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_imm_operand_renameable_interface_init(GRenameableOperandInterface *iface)
+{
+    iface->build = (build_renameable_fc)g_imm_operand_build;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : operand = instance d'objet GLib à traiter.                   *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
@@ -1403,12 +1480,6 @@ bool g_imm_operand_to_off_t(const GImmOperand *operand, off_t *value, bool *nega
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = opérande d'assemblage à constituer.                *
@@ -1496,12 +1567,6 @@ static bool g_imm_operand_serialize(const GImmOperand *operand, GAsmStorage *sto
 }
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                         INTERFACE DE CIBLAGE POUR OPERANDE                         */
-/* ---------------------------------------------------------------------------------- */
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = operande à consulter.                              *
@@ -1531,3 +1596,349 @@ static bool g_imm_operand_get_addr(const GImmOperand *operand, const vmpa2t *src
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = operande à consulter.                              *
+*                text    = texte alternatif de représentation.                *
+*                                                                             *
+*  Description : Construit un opérande de représentation alternative.         *
+*                                                                             *
+*  Retour      : Nouvel opérande, en version renommée.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GRenamedOperand *g_imm_operand_build(const GImmOperand *operand, const char *text)
+{
+    GRenamedOperand *result;                /* Instance à retourner        */
+
+    result = G_RENAMED_OPERAND(g_known_imm_operand_new(operand, text));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         REMPLACEMENT DE VALEURS IMMEDIATES                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
+G_DEFINE_TYPE_WITH_CODE(GKnownImmOperand, g_known_imm_operand, G_TYPE_IMM_OPERAND,
+                        G_IMPLEMENT_INTERFACE(G_TYPE_RENAMED_OPERAND, g_known_imm_operand_renamed_interface_init));
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des remplacements d'opérandes.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_class_init(GKnownImmOperandClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchOperandClass *operand;             /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+    operand = G_ARCH_OPERAND_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_known_imm_operand_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_known_imm_operand_finalize;
+
+    operand->compare = (operand_compare_fc)g_known_imm_operand_compare;
+    operand->print = (operand_print_fc)g_known_imm_operand_print;
+
+    operand->unserialize = (unserialize_operand_fc)g_known_imm_operand_unserialize;
+    operand->serialize = (serialize_operand_fc)g_known_imm_operand_serialize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise un remplacement d'opérande de valeur immédiate.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_init(GKnownImmOperand *operand)
+{
+    operand->alt_text = NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de renommage.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_renamed_interface_init(GRenamedOperandInterface *iface)
+{
+    iface->get_text = (get_renamed_text_fc)g_known_imm_operand_get_text;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_dispose(GKnownImmOperand *operand)
+{
+    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->dispose(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_finalize(GKnownImmOperand *operand)
+{
+    G_OBJECT_CLASS(g_known_imm_operand_parent_class)->finalize(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : old = opérande à venir copier avant son remplacement.        *
+*                alt = texte alternatif à présenter pour l'impression.        *
+*                                                                             *
+*  Description : Crée un opérande remplaçant visuellement une valeur.         *
+*                                                                             *
+*  Retour      : Instruction mise en place.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_known_imm_operand_new(const GImmOperand *old, const char *alt)
+{
+    GKnownImmOperand *result;               /* Remplacement à retourner    */
+
+    result = g_object_new(G_TYPE_KNOWN_IMM_OPERAND, NULL);
+
+    result->parent.raw = old->raw;
+
+    result->parent.size = old->size;
+    result->parent.def_display = old->def_display;
+    result->parent.display = old->display;
+    result->parent.misc = old->misc;
+
+    result->alt_text = strdup(alt);
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = premier opérande à consulter.                            *
+*                b = second opérande à consulter.                             *
+*                                                                             *
+*  Description : Compare un opérande avec un autre.                           *
+*                                                                             *
+*  Retour      : Bilan de la comparaison.                                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int g_known_imm_operand_compare(const GKnownImmOperand *a, const GKnownImmOperand *b)
+{
+    int result;                             /* Bilan à retourner           */
+    GArchOperandClass *class;               /* Classe parente à consulter  */
+
+    class = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+
+    result = class->compare(G_ARCH_OPERAND(a), G_ARCH_OPERAND(b));
+
+    if (result == 0)
+        result = strcmp(a->alt_text, b->alt_text);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_known_imm_operand_print(const GKnownImmOperand *operand, GBufferLine *line)
+{
+    size_t len;                             /* Taille de l'élément inséré  */
+
+    len = strlen(operand->alt_text);
+
+    g_buffer_line_append_text(line, BLC_MAIN, operand->alt_text, len, RTT_IMMEDIATE, G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande d'assemblage à constituer.                *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                format  = format binaire chargé associé à l'architecture.    *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Charge un opérande depuis une mémoire tampon.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_known_imm_operand_unserialize(GKnownImmOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+    unsigned short len;                     /* Taille du contenu alternatif*/
+
+    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+
+    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &len, sizeof(unsigned short), true);
+
+    if (result)
+        result = (len > 0);
+
+    if (result)
+    {
+        operand->alt_text = malloc(len);
+
+        result = extract_packed_buffer(pbuf, operand->alt_text, len, false);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande d'assemblage à consulter.                 *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Sauvegarde un opérande dans une mémoire tampon.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_known_imm_operand_serialize(const GKnownImmOperand *operand, GAsmStorage *storage, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+    size_t len;                             /* Taille du contenu alternatif*/
+
+    parent = G_ARCH_OPERAND_CLASS(g_known_imm_operand_parent_class);
+
+    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+
+    if (result)
+    {
+        len = strlen(operand->alt_text) + 1;
+        assert(len > 1);
+
+        if (len > (2 << (sizeof(unsigned short) * 8 - 1)))
+        {
+            log_variadic_message(LMT_ERROR, "Alternative text too long: '%s' (%zu bytes)",
+                                 operand->alt_text, len);
+            result = false;
+        }
+
+        else
+            result = extend_packed_buffer(pbuf, (unsigned short []) { len }, sizeof(unsigned short), true);
+
+        if (result)
+            result = extend_packed_buffer(pbuf, operand->alt_text, len, false);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = operande à consulter.                              *
+*                                                                             *
+*  Description : Fournit un texte comme représentation alternative d'opérande.*
+*                                                                             *
+*  Retour      : Chaîne de caractère de représentation alternative.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_known_imm_operand_get_text(const GKnownImmOperand *operand)
+{
+    const char *result;                     /* Texte à retourner           */
+
+    result = operand->alt_text;
+
+    return result;
+
+}
diff --git a/src/arch/operands/immediate.h b/src/arch/operands/immediate.h
index 4d9a77e..28fe7ba 100644
--- a/src/arch/operands/immediate.h
+++ b/src/arch/operands/immediate.h
@@ -36,6 +36,9 @@
 
 
 
+/* ------------------------- OPERANDE POUR VALEUR IMMEDIATE ------------------------- */
+
+
 /* Grande ligne d'un format d'affichage */
 typedef enum _ImmOperandDisplay
 {
@@ -154,4 +157,30 @@ bool g_imm_operand_to_off_t(const GImmOperand *, off_t *, bool *) __attribute__
 
 
 
+/* ----------------------- REMPLACEMENT DE VALEURS IMMEDIATES ----------------------- */
+
+
+#define G_TYPE_KNOWN_IMM_OPERAND            g_known_imm_operand_get_type()
+#define G_KNOWN_IMM_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperand))
+#define G_IS_KNOWN_IMM_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_KNOWN_IMM_OPERAND))
+#define G_KNOWN_IMM_OPERAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
+#define G_IS_KNOWN_IMM_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_KNOWN_IMM_OPERAND))
+#define G_KNOWN_IMM_OPERAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_KNOWN_IMM_OPERAND, GKnownImmOperandClass))
+
+
+/* Définition d'un remplacement d'opérande de valeur numérique (instance) */
+typedef struct _GKnownImmOperand GKnownImmOperand;
+
+/* Définition d'un remplacement d'opérande de valeur numérique (classe) */
+typedef struct _GKnownImmOperandClass GKnownImmOperandClass;
+
+
+/* Indique le type défini pour un remplacemet d'opérande de valeur numérique. */
+GType g_known_imm_operand_get_type(void);
+
+/* Crée un opérande remplaçant visuellement une valeur. */
+GArchOperand *g_known_imm_operand_new(const GImmOperand *, const char *);
+
+
+
 #endif  /* _ARCH_OPERANDS_IMMEDIATE_H */
diff --git a/src/arch/operands/rename-int.h b/src/arch/operands/rename-int.h
new file mode 100644
index 0000000..28653b9
--- /dev/null
+++ b/src/arch/operands/rename-int.h
@@ -0,0 +1,76 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * rename-int.h - définitions internes propres aux opérandes ciblant une portion de désassemblage
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERANDS_RENAME_INT_H
+#define _ARCH_OPERANDS_RENAME_INT_H
+
+
+#include "rename.h"
+
+
+
+/* ------------------------ INTERFACE POUR OPERANDE RENOMMEE ------------------------ */
+
+
+/* Obtient l'adresse de la cible visée par un opérande. */
+typedef const char * (* get_renamed_text_fc) (const GRenamedOperand *);
+
+
+/* Opérande renommé avec un texte alternatif (interface) */
+struct _GRenamedOperandIface
+{
+    GTypeInterface base_iface;              /* A laisser en premier        */
+
+    get_renamed_text_fc get_text;           /* Récupération d'alternative  */
+
+};
+
+
+/* Redéfinition */
+typedef GRenamedOperandIface GRenamedOperandInterface;
+
+
+
+/* ----------------------- INTERFACE POUR OPERANDE RENOMMABLE ----------------------- */
+
+
+/* Obtient l'adresse de la cible visée par un opérande. */
+typedef GRenamedOperand * (* build_renameable_fc) (const GRenameableOperand *, const char *);
+
+
+/* Opérande offrant une capacité de renommage (interface) */
+struct _GRenameableOperandIface
+{
+    GTypeInterface base_iface;              /* A laisser en premier        */
+
+    build_renameable_fc build;              /* Obtention de la cible       */
+
+};
+
+
+/* Redéfinition */
+typedef GRenameableOperandIface GRenameableOperandInterface;
+
+
+
+#endif  /* _ARCH_OPERANDS_RENAME_INT_H */
diff --git a/src/arch/operands/rename.c b/src/arch/operands/rename.c
new file mode 100644
index 0000000..e865b63
--- /dev/null
+++ b/src/arch/operands/rename.c
@@ -0,0 +1,152 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * rename.c - opérandes pouvant être renommées
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "rename.h"
+
+
+#include "rename-int.h"
+
+
+
+/* ------------------------ INTERFACE POUR OPERANDE RENOMMEE ------------------------ */
+
+
+/* Procède à l'initialisation de l'interface de renommage. */
+static void g_renamed_operand_default_init(GRenamedOperandInterface *);
+
+
+
+/* ----------------------- INTERFACE POUR OPERANDE RENOMMABLE ----------------------- */
+
+
+/* Procède à l'initialisation de l'interface de renommage. */
+static void g_renameable_operand_default_init(GRenameableOperandInterface *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          INTERFACE POUR OPERANDE RENOMMEE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Détermine le type d'une interface pour un opérande renommé. */
+G_DEFINE_INTERFACE(GRenamedOperand, g_renamed_operand, G_TYPE_OBJECT)
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de renommage.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_renamed_operand_default_init(GRenamedOperandInterface *iface)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = operande à consulter.                              *
+*                                                                             *
+*  Description : Fournit un texte comme représentation alternative d'opérande.*
+*                                                                             *
+*  Retour      : Chaîne de caractère de représentation alternative.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_renamed_operand_get_text(const GRenamedOperand *operand)
+{
+    const char *result;                     /* Texte à retourner           */
+    GRenamedOperandIface *iface;            /* Interface utilisée          */
+
+    iface = G_RENAMED_OPERAND_GET_IFACE(operand);
+
+    result = iface->get_text(operand);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         INTERFACE POUR OPERANDE RENOMMABLE                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Détermine le type d'une interface pour le renommage d'un opérande. */
+G_DEFINE_INTERFACE(GRenameableOperand, g_renameable_operand, G_TYPE_OBJECT)
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : iface = interface GLib à initialiser.                        *
+*                                                                             *
+*  Description : Procède à l'initialisation de l'interface de renommage.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_renameable_operand_default_init(GRenameableOperandInterface *iface)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = operande à consulter.                              *
+*                text    = texte alternatif de représentation.                *
+*                                                                             *
+*  Description : Construit un opérande de représentation alternative.         *
+*                                                                             *
+*  Retour      : Nouvel opérande, en version renommée.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GRenamedOperand *g_renameable_operand_build(const GRenameableOperand *operand, const char *text)
+{
+    GRenamedOperand *result;                /* Instance à retourner        */
+    GRenameableOperandIface *iface;         /* Interface utilisée          */
+
+    iface = G_RENAMEABLE_OPERAND_GET_IFACE(operand);
+
+    result = iface->build(operand, text);
+
+    return result;
+
+}
diff --git a/src/arch/operands/rename.h b/src/arch/operands/rename.h
new file mode 100644
index 0000000..a6b99d7
--- /dev/null
+++ b/src/arch/operands/rename.h
@@ -0,0 +1,84 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * rename.h - prototypes pour les opérandes pouvant être renommées
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERANDS_RENAME_H
+#define _ARCH_OPERANDS_RENAME_H
+
+
+#include <glib-object.h>
+
+
+
+/* ------------------------ INTERFACE POUR OPERANDE RENOMMEE ------------------------ */
+
+
+#define G_TYPE_RENAMED_OPERAND             (g_renamed_operand_get_type())
+#define G_RENAMED_OPERAND(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RENAMED_OPERAND, GRenamedOperand))
+#define G_RENAMED_OPERAND_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST((vtable), G_TYPE_RENAMED_OPERAND, GRenamedOperandIface))
+#define G_IS_RENAMED_OPERAND(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RENAMED_OPERAND))
+#define G_IS_RENAMED_OPERAND_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE((vtable), G_TYPE_RENAMED_OPERAND))
+#define G_RENAMED_OPERAND_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE((inst), G_TYPE_RENAMED_OPERAND, GRenamedOperandIface))
+
+
+/* Opérande renommé avec un texte alternatif (coquille vide) */
+typedef struct _GRenamedOperand GRenamedOperand;
+
+/* Opérande renommé avec un texte alternatif (interface) */
+typedef struct _GRenamedOperandIface GRenamedOperandIface;
+
+
+/* Détermine le type d'une interface pour un opérande renommé. */
+GType g_renamed_operand_get_type(void) G_GNUC_CONST;
+
+/* Fournit un texte comme représentation alternative d'opérande. */
+const char *g_renamed_operand_get_text(const GRenamedOperand *);
+
+
+
+/* ----------------------- INTERFACE POUR OPERANDE RENOMMABLE ----------------------- */
+
+
+#define G_TYPE_RENAMEABLE_OPERAND             (g_renameable_operand_get_type())
+#define G_RENAMEABLE_OPERAND(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RENAMEABLE_OPERAND, GRenameableOperand))
+#define G_RENAMEABLE_OPERAND_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST((vtable), G_TYPE_RENAMEABLE_OPERAND, GRenameableOperandIface))
+#define G_IS_RENAMEABLE_OPERAND(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RENAMEABLE_OPERAND))
+#define G_IS_RENAMEABLE_OPERAND_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE((vtable), G_TYPE_RENAMEABLE_OPERAND))
+#define G_RENAMEABLE_OPERAND_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE((inst), G_TYPE_RENAMEABLE_OPERAND, GRenameableOperandIface))
+
+
+/* Opérande offrant une capacité de renommage (coquille vide) */
+typedef struct _GRenameableOperand GRenameableOperand;
+
+/* Opérande offrant une capacité de renommage (interface) */
+typedef struct _GRenameableOperandIface GRenameableOperandIface;
+
+
+/* Détermine le type d'une interface pour le renommage d'un opérande. */
+GType g_renameable_operand_get_type(void) G_GNUC_CONST;
+
+/* Construit un opérande de représentation alternative. */
+GRenamedOperand *g_renameable_operand_build(const GRenameableOperand *, const char *);
+
+
+
+#endif  /* _ARCH_OPERANDS_RENAME_H */