Added support for a few extra ARMv7 instructions.

8 files changed, 1031 insertions, 2 deletions

diff --git a/plugins/arm/v7/operands/Makefile.am b/plugins/arm/v7/operands/Makefile.am
index 7ba6d0a..41a809e 100644
--- a/plugins/arm/v7/operands/Makefile.am
+++ b/plugins/arm/v7/operands/Makefile.am
@@ -4,13 +4,15 @@ noinst_LTLIBRARIES = libarmv7operands.la
 libarmv7operands_la_SOURCES = 			\
 	coproc.h coproc.c					\
 	estate.h estate.c					\
+	it.h it.c							\
 	limitation.h limitation.c			\
 	maccess.h maccess.c					\
 	offset.h offset.c					\
 	register.h register.c				\
 	reglist.h reglist.c					\
 	rotation.h rotation.c				\
-	shift.h shift.c
+	shift.h shift.c						\
+	specreg.h specreg.c
 
 libarmv7operands_la_LIBADD =
 
diff --git a/plugins/arm/v7/operands/estate.c b/plugins/arm/v7/operands/estate.c
index 472ac2b..8460375 100644
--- a/plugins/arm/v7/operands/estate.c
+++ b/plugins/arm/v7/operands/estate.c
@@ -1,6 +1,6 @@
 
 /* Chrysalide - Outil d'analyse de fichiers binaires
- * endian.c - décalages de valeurs
+ * estate.c - décalages de valeurs
  *
  * Copyright (C) 2016-2017 Cyrille Bagard
  *
diff --git a/plugins/arm/v7/operands/it.c b/plugins/arm/v7/operands/it.c
new file mode 100644
index 0000000..f8232d1
--- /dev/null
+++ b/plugins/arm/v7/operands/it.c
@@ -0,0 +1,402 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * it.c - manipulation des informations de l'instruction TI
+ *
+ * Copyright (C) 2018 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 "it.h"
+
+
+#include <assert.h>
+
+
+#include <arch/operand-int.h>
+#include <common/sort.h>
+
+
+
+/* Définition d'un opérande organisant l'application d'une instruction IT (instance) */
+struct _GArmV7ITCondOperand
+{
+    GArchOperand parent;                    /* Instance parente            */
+
+    ArmCondCode firstcond;                  /* Condition première          */
+    uint8_t mask;                           /* Masque de l'interprétation  */
+
+};
+
+
+/* Définition d'un opérande organisant l'application d'une instruction IT (classe) */
+struct _GArmV7ITCondOperandClass
+{
+    GArchOperandClass parent;               /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des conditions d'application d'IT. */
+static void g_armv7_itcond_operand_class_init(GArmV7ITCondOperandClass *);
+
+/* Initialise une instance de conditions d'application d'IT. */
+static void g_armv7_itcond_operand_init(GArmV7ITCondOperand *);
+
+/* Supprime toutes les références externes. */
+static void g_armv7_itcond_operand_dispose(GArmV7ITCondOperand *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_armv7_itcond_operand_finalize(GArmV7ITCondOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_itcond_operand_compare(const GArmV7ITCondOperand *, const GArmV7ITCondOperand *);
+
+/* Traduit un opérande en version humainement lisible. */
+static void g_armv7_itcond_operand_print(const GArmV7ITCondOperand *, GBufferLine *, AsmSyntax);
+
+
+
+/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
+
+
+/* Charge un opérande depuis une mémoire tampon. */
+static bool g_armv7_itcond_operand_unserialize(GArmV7ITCondOperand *, GAsmStorage *, GBinFormat *, packed_buffer *);
+
+/* Sauvegarde un opérande dans une mémoire tampon. */
+static bool g_armv7_itcond_operand_serialize(const GArmV7ITCondOperand *, GAsmStorage *, packed_buffer *);
+
+
+
+/* Indique le type défini par la GLib pour l'application d'une instruction IT. */
+G_DEFINE_TYPE(GArmV7ITCondOperand, g_armv7_itcond_operand, G_TYPE_ARCH_OPERAND);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des conditions d'application d'IT.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_itcond_operand_class_init(GArmV7ITCondOperandClass *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_armv7_itcond_operand_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_armv7_itcond_operand_finalize;
+
+    operand->compare = (operand_compare_fc)g_armv7_itcond_operand_compare;
+    operand->print = (operand_print_fc)g_armv7_itcond_operand_print;
+
+    operand->unserialize = (unserialize_operand_fc)g_armv7_itcond_operand_unserialize;
+    operand->serialize = (serialize_operand_fc)g_armv7_itcond_operand_serialize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de conditions d'application d'IT.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_itcond_operand_init(GArmV7ITCondOperand *operand)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_itcond_operand_dispose(GArmV7ITCondOperand *operand)
+{
+    G_OBJECT_CLASS(g_armv7_itcond_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_armv7_itcond_operand_finalize(GArmV7ITCondOperand *operand)
+{
+    G_OBJECT_CLASS(g_armv7_itcond_operand_parent_class)->finalize(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_itcond_operand_compare(const GArmV7ITCondOperand *a, const GArmV7ITCondOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_boolean(a->firstcond, b->firstcond);
+
+    if (result == 0)
+        result = sort_unsigned_long(a->mask, b->mask);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_itcond_operand_print(const GArmV7ITCondOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    const char *kw;                         /* Mot clef à imprimer         */
+
+    switch (operand->firstcond)
+    {
+        case ACC_EQ: kw = "EQ"; break;
+        case ACC_NE: kw = "NE"; break;
+        case ACC_HS: kw = "HS"; break;
+        case ACC_LO: kw = "LO"; break;
+        case ACC_MI: kw = "MI"; break;
+        case ACC_PL: kw = "PL"; break;
+        case ACC_VS: kw = "VS"; break;
+        case ACC_VC: kw = "VC"; break;
+        case ACC_HI: kw = "HI"; break;
+        case ACC_LS: kw = "LS"; break;
+        case ACC_GE: kw = "GE"; break;
+        case ACC_LT: kw = "LT"; break;
+        case ACC_GT: kw = "GT"; break;
+        case ACC_LE: kw = "LE"; break;
+        case ACC_AL: kw = NULL; break;
+        case ACC_NV: kw = "NV"; break;
+
+        default:    /* Pour GCC... */
+            assert(false);
+            kw = NULL;
+            break;
+
+    }
+
+    if (kw != NULL)
+        g_buffer_line_append_text(line, BLC_ASSEMBLY, kw, 2, RTT_KEY_WORD, NULL);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : firstcond = valeur brute de la condition d'exécution.        *
+*                mask      = masque d'interprétation pour l'instruction.      *
+*                                                                             *
+*  Description : Crée un opérande lié à une instruction IT.                   *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_itcond_operand_new(uint8_t firstcond, uint8_t mask)
+{
+    GArmV7ITCondOperand *result;            /* Structure à retourner       */
+
+    if (firstcond > ACC_NV)
+        return NULL;
+
+    result = g_object_new(G_TYPE_ARMV7_ITCOND_OPERAND, NULL);
+
+    result->firstcond = firstcond;
+    result->mask = mask;
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à consulter.                              *
+*                                                                             *
+*  Description : Fournit la condition associée à l'opérande.                  *
+*                                                                             *
+*  Retour      : Condition classique pour ARMv7.                              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+ArmCondCode g_armv7_itcond_operand_get_firstcond(const GArmV7ITCondOperand *operand)
+{
+    ArmCondCode result;                     /* Condition à renvoyer        */
+
+    result = operand->firstcond;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à consulter.                              *
+*                                                                             *
+*  Description : Fournit le masque d'interprétation de la condition.          *
+*                                                                             *
+*  Retour      : Masque de bits.                                              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+uint8_t g_armv7_itcond_operand_get_mask(const GArmV7ITCondOperand *operand)
+{
+    uint8_t result;                         /* Valeur à retourner          */
+
+    result = operand->mask;
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_itcond_operand_unserialize(GArmV7ITCondOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+
+    parent = G_ARCH_OPERAND_CLASS(g_armv7_itcond_operand_parent_class);
+
+    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &operand->firstcond, sizeof(ArmCondCode), true);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &operand->mask, sizeof(uint8_t), 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_armv7_itcond_operand_serialize(const GArmV7ITCondOperand *operand, GAsmStorage *storage, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+
+    parent = G_ARCH_OPERAND_CLASS(g_armv7_itcond_operand_parent_class);
+
+    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+
+    if (result)
+        result = extend_packed_buffer(pbuf, &operand->firstcond, sizeof(ArmCondCode), true);
+
+    if (result)
+        result = extend_packed_buffer(pbuf, &operand->mask, sizeof(uint8_t), false);
+
+    return result;
+
+}
diff --git a/plugins/arm/v7/operands/it.h b/plugins/arm/v7/operands/it.h
new file mode 100644
index 0000000..9e1706b
--- /dev/null
+++ b/plugins/arm/v7/operands/it.h
@@ -0,0 +1,67 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * it.h - prototypes pour la manipulation des informations de l'instruction TI
+ *
+ * Copyright (C) 2018 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 _PLUGINS_ARM_V7_OPERANDS_IT_H
+#define _PLUGINS_ARM_V7_OPERANDS_IT_H
+
+
+#include <glib-object.h>
+
+
+#include <arch/operand.h>
+
+
+#include "../../cond.h"
+
+
+
+#define G_TYPE_ARMV7_ITCOND_OPERAND            g_armv7_itcond_operand_get_type()
+#define G_ARMV7_ITCOND_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_ARMV7_ITCOND_OPERAND, GArmV7ITCondOperand))
+#define G_IS_ARMV7_ITCOND_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_ARMV7_ITCOND_OPERAND))
+#define G_ARMV7_ITCOND_OPERAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARMV7_ITCOND_OPERAND, GArmV7ITCondOperandClass))
+#define G_IS_ARMV7_ITCOND_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARMV7_ITCOND_OPERAND))
+#define G_ARMV7_ITCOND_OPERAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARMV7_ITCOND_OPERAND, GArmV7ITCondOperandClass))
+
+
+/* Définition d'un opérande organisant l'application d'une instruction IT (instance) */
+typedef struct _GArmV7ITCondOperand GArmV7ITCondOperand;
+
+/* Définition d'un opérande organisant l'application d'une instruction IT (classe) */
+typedef struct _GArmV7ITCondOperandClass GArmV7ITCondOperandClass;
+
+
+/* Indique le type défini par la GLib pour l'application d'une instruction IT. */
+GType g_armv7_itcond_operand_get_type(void);
+
+/* Crée un opérande lié à une instruction IT. */
+GArchOperand *g_armv7_itcond_operand_new(uint8_t, uint8_t);
+
+/* Fournit la condition associée à l'opérande. */
+ArmCondCode g_armv7_itcond_operand_get_firstcond(const GArmV7ITCondOperand *);
+
+/* Fournit le masque d'interprétation de la condition. */
+uint8_t g_armv7_itcond_operand_get_mask(const GArmV7ITCondOperand *);
+
+
+
+#endif  /* _PLUGINS_ARM_V7_OPERANDS_IT_H */
diff --git a/plugins/arm/v7/operands/register.c b/plugins/arm/v7/operands/register.c
index 33a14f6..412d0f9 100644
--- a/plugins/arm/v7/operands/register.c
+++ b/plugins/arm/v7/operands/register.c
@@ -36,6 +36,8 @@ struct _GArmV7RegisterOperand
 {
     GRegisterOperand parent;                /* Instance parente            */
 
+    bool write_back;                        /* Mise à jour du registre ?   */
+
 };
 
 
@@ -59,6 +61,9 @@ static void g_armv7_register_operand_dispose(GArmV7RegisterOperand *);
 /* Procède à la libération totale de la mémoire. */
 static void g_armv7_register_operand_finalize(GArmV7RegisterOperand *);
 
+/* Traduit un opérande en version humainement lisible. */
+static void g_armv7_register_operand_print(const GArmV7RegisterOperand *, GBufferLine *, AsmSyntax);
+
 
 
 /* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
@@ -100,6 +105,8 @@ static void g_armv7_register_operand_class_init(GArmV7RegisterOperandClass *klas
 
     operand = G_ARCH_OPERAND_CLASS(klass);
 
+    operand->print = (operand_print_fc)g_armv7_register_operand_print;
+
     operand->unserialize = (unserialize_operand_fc)g_armv7_register_operand_unserialize;
     operand->serialize = (serialize_operand_fc)g_armv7_register_operand_serialize;
 
@@ -120,6 +127,7 @@ static void g_armv7_register_operand_class_init(GArmV7RegisterOperandClass *klas
 
 static void g_armv7_register_operand_init(GArmV7RegisterOperand *operand)
 {
+    operand->write_back = false;
 
 }
 
@@ -164,6 +172,34 @@ static void g_armv7_register_operand_finalize(GArmV7RegisterOperand *operand)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_register_operand_print(const GArmV7RegisterOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    GArchOperandClass *parent;              /* Classe parente              */
+
+    parent = G_ARCH_OPERAND_CLASS(g_armv7_register_operand_parent_class);
+
+    parent->print(G_ARCH_OPERAND(operand), line, syntax);
+
+    if (operand->write_back)
+        g_buffer_line_append_text(line, BLC_ASSEMBLY, "!", 1, RTT_PUNCT, NULL);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : reg = registre déjà en place.                                *
 *                                                                             *
 *  Description : Crée un opérande visant un registre ARMv7.                   *
@@ -210,6 +246,48 @@ const GArmV7Register *g_armv7_register_operand_get(const GArmV7RegisterOperand *
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande représentant un registre.                 *
+*                wback   = indique si le registre est mis à jour après coup.  *
+*                                                                             *
+*  Description : Détermine si le registre est mis à jour après l'opération.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_armv7_register_operand_write_back(GArmV7RegisterOperand *operand, bool wback)
+{
+    operand->write_back = wback;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande représentant un registre.                 *
+*                                                                             *
+*  Description : Indique si le registre est mis à jour après coup.            *
+*                                                                             *
+*  Retour      : Evolution du registre.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_armv7_register_operand_is_written_back(const GArmV7RegisterOperand *operand)
+{
+    bool result;                            /* Statut à retourner          */
+
+    result = operand->write_back;
+
+    return result;
+
+}
+
 
 /* ---------------------------------------------------------------------------------- */
 /*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
@@ -237,6 +315,7 @@ static bool g_armv7_register_operand_unserialize(GArmV7RegisterOperand *operand,
     GArchOperandClass *parent;              /* Classe parente à consulter  */
     uint8_t index;                          /* Identifiant de registre     */
     GArmV7Register *reg;                    /* Registre à intégrer         */
+    uint8_t wback;                          /* Mise à jour après coup ?    */
 
     parent = G_ARCH_OPERAND_CLASS(g_armv7_register_operand_parent_class);
 
@@ -257,6 +336,15 @@ static bool g_armv7_register_operand_unserialize(GArmV7RegisterOperand *operand,
 
     }
 
+    if (result)
+    {
+        result = extract_packed_buffer(pbuf, &wback, sizeof(uint8_t), false);
+
+        if (result)
+            operand->write_back = (wback == 1 ? true : false);
+
+    }
+
     return result;
 
 }
@@ -281,6 +369,7 @@ static bool g_armv7_register_operand_serialize(const GArmV7RegisterOperand *oper
     bool result;                            /* Bilan à retourner           */
     GArchOperandClass *parent;              /* Classe parente à consulter  */
     uint8_t index;                          /* Identifiant de registre     */
+    uint8_t wback;                          /* Mise à jour après coup ?    */
 
     parent = G_ARCH_OPERAND_CLASS(g_armv7_register_operand_parent_class);
 
@@ -292,6 +381,12 @@ static bool g_armv7_register_operand_serialize(const GArmV7RegisterOperand *oper
         result = extend_packed_buffer(pbuf, &index, sizeof(uint8_t), false);
     }
 
+    if (result)
+    {
+        wback = (operand->write_back ? 1 : 0);
+        result = extend_packed_buffer(pbuf, &wback, sizeof(uint8_t), false);
+    }
+
     return result;
 
 }
diff --git a/plugins/arm/v7/operands/register.h b/plugins/arm/v7/operands/register.h
index 61f5d6e..2bd13c6 100644
--- a/plugins/arm/v7/operands/register.h
+++ b/plugins/arm/v7/operands/register.h
@@ -60,6 +60,12 @@ GArchOperand *g_armv7_register_operand_new(GArmV7Register *);
 /* Fournit le registre ARMv7 associé à l'opérande. */
 const GArmV7Register *g_armv7_register_operand_get(const GArmV7RegisterOperand *);
 
+/* Détermine si le registre est mis à jour après l'opération. */
+void g_armv7_register_operand_write_back(GArmV7RegisterOperand *, bool);
+
+/* Indique si le registre est mis à jour après coup. */
+bool g_armv7_register_operand_is_written_back(const GArmV7RegisterOperand *);
+
 
 
 #endif  /* _PLUGINS_ARM_V7_OPERANDS_REGISTER_H */
diff --git a/plugins/arm/v7/operands/specreg.c b/plugins/arm/v7/operands/specreg.c
new file mode 100644
index 0000000..233e6fd
--- /dev/null
+++ b/plugins/arm/v7/operands/specreg.c
@@ -0,0 +1,378 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * specreg.c - registres spéciaux
+ *
+ * Copyright (C) 2018 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 "specreg.h"
+
+
+#include <arch/operand-int.h>
+#include <common/sort.h>
+
+
+
+/* Définition d'un opérande de registre spécial (instance) */
+struct _GArmV7SpecRegOperand
+{
+    GArchOperand parent;                    /* Instance parente            */
+
+    SpecRegType reg;                        /* Identifiant de registre     */
+
+};
+
+
+/* Définition d'un opérande de registre spécial (classe) */
+struct _GArmV7SpecRegOperandClass
+{
+    GArchOperandClass parent;               /* Classe parente              */
+
+};
+
+
+/* Initialise la classe des opérandes de registre spécial. */
+static void g_armv7_specreg_operand_class_init(GArmV7SpecRegOperandClass *);
+
+/* Initialise une instance d'opérande de registre spécial. */
+static void g_armv7_specreg_operand_init(GArmV7SpecRegOperand *);
+
+/* Supprime toutes les références externes. */
+static void g_armv7_specreg_operand_dispose(GArmV7SpecRegOperand *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_armv7_specreg_operand_finalize(GArmV7SpecRegOperand *);
+
+/* Compare un opérande avec un autre. */
+static int g_armv7_specreg_operand_compare(const GArmV7SpecRegOperand *, const GArmV7SpecRegOperand *);
+
+/* Traduit un opérande en version humainement lisible. */
+static void g_armv7_specreg_operand_print(const GArmV7SpecRegOperand *, GBufferLine *, AsmSyntax);
+
+
+
+/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
+
+
+/* Charge un opérande depuis une mémoire tampon. */
+static bool g_armv7_specreg_operand_unserialize(GArmV7SpecRegOperand *, GAsmStorage *, GBinFormat *, packed_buffer *);
+
+/* Sauvegarde un opérande dans une mémoire tampon. */
+static bool g_armv7_specreg_operand_serialize(const GArmV7SpecRegOperand *, GAsmStorage *, packed_buffer *);
+
+
+
+/* Indique le type défini par la GLib pour un opérande de registre spécial ARMv7. */
+G_DEFINE_TYPE(GArmV7SpecRegOperand, g_armv7_specreg_operand, G_TYPE_ARCH_OPERAND);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des opérandes de registre spécial.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_specreg_operand_class_init(GArmV7SpecRegOperandClass *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_armv7_specreg_operand_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_armv7_specreg_operand_finalize;
+
+    operand->compare = (operand_compare_fc)g_armv7_specreg_operand_compare;
+    operand->print = (operand_print_fc)g_armv7_specreg_operand_print;
+
+    operand->unserialize = (unserialize_operand_fc)g_armv7_specreg_operand_unserialize;
+    operand->serialize = (serialize_operand_fc)g_armv7_specreg_operand_serialize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance d'opérande de registre spécial.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_specreg_operand_init(GArmV7SpecRegOperand *operand)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_specreg_operand_dispose(GArmV7SpecRegOperand *operand)
+{
+    G_OBJECT_CLASS(g_armv7_specreg_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_armv7_specreg_operand_finalize(GArmV7SpecRegOperand *operand)
+{
+    G_OBJECT_CLASS(g_armv7_specreg_operand_parent_class)->finalize(G_OBJECT(operand));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_specreg_operand_compare(const GArmV7SpecRegOperand *a, const GArmV7SpecRegOperand *b)
+{
+    int result;                             /* Bilan à faire remonter      */
+
+    result = sort_unsigned_long(a->reg, b->reg);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à traiter.                                *
+*                line    = ligne tampon où imprimer l'opérande donné.         *
+*                syntax  = type de représentation demandée.                   *
+*                                                                             *
+*  Description : Traduit un opérande en version humainement lisible.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_armv7_specreg_operand_print(const GArmV7SpecRegOperand *operand, GBufferLine *line, AsmSyntax syntax)
+{
+    switch (operand->reg)
+    {
+        case SRT_APSR:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "APSR", 4, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_CPSR:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "CPSR", 4, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_SPSR:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "SPSR", 4, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_APSR_NZCVQ:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "APSR_nzcvq", 10, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_APSR_G:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "APSR_g", 6, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_APSR_NZCVQG:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "APSR_nzcvqg", 11, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_FPSID:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "FPSID", 5, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_FPSCR:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "FPSCR", 5, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_MVFR1:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "MVFR1", 5, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_MVFR0:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "MVFR0", 5, RTT_REGISTER, NULL);
+            break;
+
+        case SRT_FPEXC:
+            g_buffer_line_append_text(line, BLC_ASSEMBLY, "FPEXC", 5, RTT_REGISTER, NULL);
+            break;
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : big = indication sur le boutisme à représenter.              *
+*                                                                             *
+*  Description : Crée une représentation d'opérande de registre spécial.      *
+*                                                                             *
+*  Retour      : Opérande mis en place.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchOperand *g_armv7_specreg_operand_new(SpecRegType reg)
+{
+    GArmV7SpecRegOperand *result;            /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_ARMV7_SPECREG_OPERAND, NULL);
+
+    result->reg = reg;
+
+    return G_ARCH_OPERAND(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = opérande à consulter.                              *
+*                                                                             *
+*  Description : Indique le type de registre spécial représenté.              *
+*                                                                             *
+*  Retour      : Identifiant de registre spécial.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+SpecRegType g_armv7_specreg_operand_get_register(const GArmV7SpecRegOperand *operand)
+{
+    SpecRegType result;                     /* Désignation à retourner     */
+
+    result = operand->reg;
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       TRANSPOSITIONS VIA CACHE DES OPERANDES                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  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_armv7_specreg_operand_unserialize(GArmV7SpecRegOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+
+    parent = G_ARCH_OPERAND_CLASS(g_armv7_specreg_operand_parent_class);
+
+    result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+
+    if (result)
+        result = extract_packed_buffer(pbuf, &operand->reg, sizeof(SpecRegType), true);
+
+    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_armv7_specreg_operand_serialize(const GArmV7SpecRegOperand *operand, GAsmStorage *storage, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchOperandClass *parent;              /* Classe parente à consulter  */
+
+    parent = G_ARCH_OPERAND_CLASS(g_armv7_specreg_operand_parent_class);
+
+    result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+
+    if (result)
+        result = extend_packed_buffer(pbuf, &operand->reg, sizeof(SpecRegType), true);
+ 
+    return result;
+
+}
diff --git a/plugins/arm/v7/operands/specreg.h b/plugins/arm/v7/operands/specreg.h
new file mode 100644
index 0000000..2d1d744
--- /dev/null
+++ b/plugins/arm/v7/operands/specreg.h
@@ -0,0 +1,79 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * specreg.h - prototypes pour les registres spéciaux
+ *
+ * Copyright (C) 2018 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 _PLUGINS_ARM_V7_OPERANDS_SPECREG_H
+#define _PLUGINS_ARM_V7_OPERANDS_SPECREG_H
+
+
+#include <glib-object.h>
+
+
+#include <arch/operand.h>
+
+
+
+#define G_TYPE_ARMV7_SPECREG_OPERAND            g_armv7_specreg_operand_get_type()
+#define G_ARMV7_SPECREG_OPERAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_ARMV7_SPECREG_OPERAND, GArmV7SpecRegOperand))
+#define G_IS_ARMV7_SPECREG_OPERAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_ARMV7_SPECREG_OPERAND))
+#define G_ARMV7_SPECREG_OPERAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARMV7_SPECREG_OPERAND, GArmV7SpecRegOperandClass))
+#define G_IS_ARMV7_SPECREG_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARMV7_SPECREG_OPERAND))
+#define G_ARMV7_SPECREG_OPERAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARMV7_SPECREG_OPERAND, GArmV7SpecRegOperandClass))
+
+
+/* Définition d'un opérande de registre spécial (instance) */
+typedef struct _GArmV7SpecRegOperand GArmV7SpecRegOperand;
+
+/* Définition d'un opérande de registre spécial (classe) */
+typedef struct _GArmV7SpecRegOperandClass GArmV7SpecRegOperandClass;
+
+
+/* Désignation des registres spéciaux */
+typedef enum _SpecRegType
+{
+    SRT_APSR,
+    SRT_CPSR,
+    SRT_SPSR,
+    SRT_APSR_NZCVQ,
+    SRT_APSR_G,
+    SRT_APSR_NZCVQG,
+    SRT_FPSID,
+    SRT_FPSCR,
+    SRT_MVFR1,
+    SRT_MVFR0,
+    SRT_FPEXC
+
+} SpecRegType;
+
+
+/* Indique le type défini par la GLib pour un opérande de registre spécial ARMv7. */
+GType g_armv7_specreg_operand_get_type(void);
+
+/* Crée une représentation d'opérande de registre spécial. */
+GArchOperand *g_armv7_specreg_operand_new(SpecRegType );
+
+/* Indique le type de registre spécial représenté. */
+SpecRegType g_armv7_specreg_operand_get_register(const GArmV7SpecRegOperand *);
+
+
+
+#endif  /* _PLUGINS_ARM_V7_OPERANDS_SPECREG_H */