Relocated the undefined instructions.

4 files changed, 610 insertions, 0 deletions

diff --git a/src/arch/instructions/Makefile.am b/src/arch/instructions/Makefile.am
new file mode 100644
index 0000000..c060c7e
--- /dev/null
+++ b/src/arch/instructions/Makefile.am
@@ -0,0 +1,23 @@
+
+noinst_LTLIBRARIES = libarchinstructions.la
+
+libarchinstructions_la_SOURCES =		\
+	undefined-int.h						\
+	undefined.h undefined.c
+
+libarchinstructions_la_LIBADD =	
+
+libarchinstructions_la_LDFLAGS = 
+
+
+devdir = $(includedir)/chrysalide/$(subdir:src/%=%)
+
+dev_HEADERS = $(libarchinstructions_la_SOURCES:%c=)
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+
+SUBDIRS = 
diff --git a/src/arch/instructions/undefined-int.h b/src/arch/instructions/undefined-int.h
new file mode 100644
index 0000000..8a648cf
--- /dev/null
+++ b/src/arch/instructions/undefined-int.h
@@ -0,0 +1,94 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * undefined-int.h - prototypes pour la définition générique interne des instructions au comportement non défini
+ *
+ * Copyright (C) 2019 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_INSTRUCTIONS_UNDEFINED_INT_H
+#define _ARCH_INSTRUCTIONS_UNDEFINED_INT_H
+
+
+#include "undefined.h"
+#include "../instruction-int.h"
+#include "../../glibext/objhole.h"
+
+
+
+/* Informations glissées dans la structure GObject de GArchInstruction */
+typedef union _undef_obj_extra
+{
+    struct
+    {
+        InstrExpectedBehavior behavior;     /* Conséquences réelles        */
+
+    };
+
+    gint lock;                              /* Gestion d'accès aux fanions */
+
+} undef_obj_extra;
+
+/* Définition générique d'une instruction au comportement non défini (instance) */
+struct _GUndefInstruction
+{
+    GArchInstruction parent;                /* A laisser en premier        */
+
+#if __SIZEOF_INT__ == __SIZEOF_LONG__
+
+    /**
+     * L'inclusion des informations suivantes dépend de l'architecture.
+     *
+     * Si la structure GObject possède un trou, on remplit de préférence
+     * ce dernier.
+     */
+
+    undef_obj_extra extra;                  /* Externalisation embarquée   */
+
+#endif
+
+};
+
+/**
+ * Accès aux informations éventuellement déportées.
+ */
+
+#if __SIZEOF_INT__ == __SIZEOF_LONG__
+
+#   define INIT_UNDEF_INSTR_EXTRA(ins) ins->extra.lock = 0
+
+#   define GET_UNDEF_INSTR_EXTRA(ins) &ins->extra
+
+#else
+
+#   define INIT_UNDEF_INSTR_EXTRA(ins) INIT_GOBJECT_EXTRA(G_OBJECT(ins))
+
+#   define GET_UNDEF_INSTR_EXTRA(ins) GET_GOBJECT_EXTRA(G_OBJECT(ins), undef_obj_extra)
+
+#endif
+
+/* Définition générique d'une instruction au comportement non défini (classe) */
+struct _GUndefInstructionClass
+{
+    GArchInstructionClass parent;           /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _ARCH_INSTRUCTIONS_UNDEFINED_INT_H */
diff --git a/src/arch/instructions/undefined.c b/src/arch/instructions/undefined.c
new file mode 100644
index 0000000..da2f73e
--- /dev/null
+++ b/src/arch/instructions/undefined.c
@@ -0,0 +1,421 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * undefined.c - instructions au comportement non défini
+ *
+ * Copyright (C) 2016-2019 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 "undefined.h"
+
+
+#include <assert.h>
+
+
+#include <i18n.h>
+
+
+#include "undefined-int.h"
+
+
+
+/* Initialise la classe des instructions non définies. */
+static void g_undef_instruction_class_init(GUndefInstructionClass *);
+
+/* Initialise une instance d'instruction non définie. */
+static void g_undef_instruction_init(GUndefInstruction *);
+
+/* Supprime toutes les références externes. */
+static void g_undef_instruction_dispose(GUndefInstruction *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_undef_instruction_finalize(GUndefInstruction *);
+
+/* Indique l'encodage d'une instruction de façon détaillée. */
+static const char *g_undef_instruction_get_encoding(const GUndefInstruction *);
+
+/* Fournit le nom humain de l'instruction manipulée. */
+static const char *g_undef_instruction_get_keyword(const GUndefInstruction *);
+
+
+
+/* -------------------- CONSERVATION SUR DISQUE DES INSTRUCTIONS -------------------- */
+
+
+/* Charge une instruction depuis une mémoire tampon. */
+static bool g_undef_instruction_unserialize(GUndefInstruction *, GAsmStorage *, GBinFormat *, packed_buffer *);
+
+/* Sauvegarde une instruction dans une mémoire tampon. */
+static bool g_undef_instruction_serialize(GUndefInstruction *, GAsmStorage *, packed_buffer *);
+
+
+
+/* ------------------------ OFFRE DE CAPACITES DE GENERATION ------------------------ */
+
+
+/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */
+static void g_undef_instruction_print(GUndefInstruction *, GBufferLine *, size_t, size_t, const GBinContent *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           INSTRUCTION INCONNUE / DONNEES                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une instruction au comportement non défini. */
+G_DEFINE_TYPE(GUndefInstruction, g_undef_instruction, G_TYPE_ARCH_INSTRUCTION);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des instructions non définies.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_undef_instruction_class_init(GUndefInstructionClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GArchInstructionClass *instr;           /* Encore une autre vision...  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_undef_instruction_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_undef_instruction_finalize;
+
+    instr = G_ARCH_INSTRUCTION_CLASS(klass);
+
+    instr->get_encoding = (get_instruction_encoding_fc)g_undef_instruction_get_encoding;
+    instr->get_keyword = (get_instruction_keyword_fc)g_undef_instruction_get_keyword;
+
+    instr->unserialize = (unserialize_instruction_fc)g_undef_instruction_unserialize;
+    instr->serialize = (serialize_instruction_fc)g_undef_instruction_serialize;
+
+    instr->print = (print_instruction_fc)g_undef_instruction_print;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance d'instruction non définie.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_undef_instruction_init(GUndefInstruction *instr)
+{
+    INIT_ARCH_INSTR_EXTRA(instr);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_undef_instruction_dispose(GUndefInstruction *instr)
+{
+    G_OBJECT_CLASS(g_undef_instruction_parent_class)->dispose(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_undef_instruction_finalize(GUndefInstruction *instr)
+{
+    G_OBJECT_CLASS(g_undef_instruction_parent_class)->finalize(G_OBJECT(instr));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : behavior = état réel du CPU après une passe de l'instruction.*
+*                                                                             *
+*  Description : Crée une instruction au comportement nominalement indéfini.  *
+*                                                                             *
+*  Retour      : Instruction mise en place.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *g_undef_instruction_new(InstrExpectedBehavior behavior)
+{
+    GArchInstruction *result;               /* Instruction à retourner     */
+    undef_obj_extra *extra;                 /* Données insérées à modifier */
+
+    result = g_object_new(G_TYPE_UNDEF_INSTRUCTION, NULL);
+
+    extra = GET_UNDEF_INSTR_EXTRA(result);
+
+    extra->behavior = behavior;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction quelconque à consulter.                  *
+*                                                                             *
+*  Description : Indique l'encodage d'une instruction de façon détaillée.     *
+*                                                                             *
+*  Retour      : Description humaine de l'encodage utilisé.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_undef_instruction_get_encoding(const GUndefInstruction *instr)
+{
+    const char *result;                     /* Description à retourner     */
+
+    result = _("Undefined");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr = instruction d'assemblage à consulter.                *
+*                                                                             *
+*  Description : Fournit le nom humain de l'instruction manipulée.            *
+*                                                                             *
+*  Retour      : Mot clef de bas niveau.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *g_undef_instruction_get_keyword(const GUndefInstruction *instr)
+{
+    const char *result;                     /* Désignation à retourner     */
+    undef_obj_extra *extra;                 /* Données insérées à consulter*/
+
+    extra = GET_UNDEF_INSTR_EXTRA(instr);
+
+    switch (extra->behavior)
+    {
+        case IEB_NOP:
+            result = "nop";
+            break;
+
+        case IEB_UNDEFINED:
+            result = "undefined";
+            break;
+
+        case IEB_UNPREDICTABLE:
+            result = "unpredictable";
+            break;
+
+        default:
+            assert(false);
+            result = NULL;
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                      CONSERVATION SUR DISQUE DES INSTRUCTIONS                      */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                format  = format binaire chargé associé à l'architecture.    *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Charge une instruction depuis une mémoire tampon.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_undef_instruction_unserialize(GUndefInstruction *instr, GAsmStorage *storage, GBinFormat *format, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchInstructionClass *parent;          /* Classe parente à consulter  */
+    undef_obj_extra *extra;                 /* Données insérées à modifier */
+
+    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
+
+    result = parent->unserialize(G_ARCH_INSTRUCTION(instr), storage, format, pbuf);
+
+    if (result)
+    {
+        extra = GET_UNDEF_INSTR_EXTRA(instr);
+
+        result = extract_packed_buffer(pbuf, &extra->behavior, sizeof(InstrExpectedBehavior), true);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction d'assemblage à consulter.              *
+*                storage = mécanisme de sauvegarde à manipuler.               *
+*                pbuf    = zone tampon à remplir.                             *
+*                                                                             *
+*  Description : Sauvegarde une instruction dans une mémoire tampon.          *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_undef_instruction_serialize(GUndefInstruction *instr, GAsmStorage *storage, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+    GArchInstructionClass *parent;          /* Classe parente à consulter  */
+    undef_obj_extra *extra;                 /* Données insérées à consulter*/
+
+    parent = G_ARCH_INSTRUCTION_CLASS(g_undef_instruction_parent_class);
+
+    result = parent->serialize(G_ARCH_INSTRUCTION(instr), storage, pbuf);
+
+    if (result)
+    {
+        extra = GET_UNDEF_INSTR_EXTRA(instr);
+
+        result = extend_packed_buffer(pbuf, &extra->behavior, sizeof(InstrExpectedBehavior), true);
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          OFFRE DE CAPACITES DE GENERATION                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr   = instruction d'assemblage à représenter.            *
+*                line    = ligne de rendu à compléter.                        *
+*                index   = indice de cette même ligne dans le tampon global.  *
+*                repeat  = indice d'utilisations successives du générateur.   *
+*                content = éventuel contenu binaire brut à imprimer.          *
+*                                                                             *
+*  Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_undef_instruction_print(GUndefInstruction *instr, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content)
+{
+    GArchInstruction *base;                 /* Version de base             */
+    const char *key;                        /* Mot clef principal          */
+    size_t klen;                            /* Taille de ce mot clef       */
+
+    base = G_ARCH_INSTRUCTION(instr);
+
+    g_buffer_line_fill_vmpa(line, get_mrange_addr(&base->range), MDS_32_BITS_UNSIGNED, MDS_32_BITS_UNSIGNED);
+
+    g_buffer_line_fill_content(line, content, &base->range, VMPA_NO_PHYSICAL);
+
+    /* Instruction proprement dite */
+
+    key = g_arch_instruction_get_keyword(base);
+    klen = strlen(key);
+
+    g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, key, klen, RTT_ERROR, NULL);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : instr  = instruction à consulter.                            *
+*                                                                             *
+*  Description : Indique le type de conséquences réél de l'instruction.       *
+*                                                                             *
+*  Retour      : Etat réel du CPU après l'exécution de l'instruction.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+InstrExpectedBehavior g_undef_instruction_get_behavior(const GUndefInstruction *instr)
+{
+    InstrExpectedBehavior result;           /* Comportement à retourner    */
+    undef_obj_extra *extra;                 /* Données insérées à consulter*/
+
+    extra = GET_UNDEF_INSTR_EXTRA(instr);
+
+    result = extra->behavior;
+
+    return result;
+
+}
diff --git a/src/arch/instructions/undefined.h b/src/arch/instructions/undefined.h
new file mode 100644
index 0000000..5aa9bec
--- /dev/null
+++ b/src/arch/instructions/undefined.h
@@ -0,0 +1,72 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * undefined.h - prototypes pour les instructions au comportement non défini
+ *
+ * Copyright (C) 2016-2019 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_INSTRUCTIONS_UNDEFINED_H
+#define _ARCH_INSTRUCTIONS_UNDEFINED_H
+
+
+#include <glib-object.h>
+
+
+#include "../instruction.h"
+#include "../vmpa.h"
+
+
+
+#define G_TYPE_UNDEF_INSTRUCTION            g_undef_instruction_get_type()
+#define G_UNDEF_INSTRUCTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_UNDEF_INSTRUCTION, GUndefInstruction))
+#define G_IS_UNDEF_INSTRUCTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_UNDEF_INSTRUCTION))
+#define G_UNDEF_INSTRUCTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_UNDEF_INSTRUCTION, GUndefInstructionClass))
+#define G_IS_UNDEF_INSTRUCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_UNDEF_INSTRUCTION))
+#define G_UNDEF_INSTRUCTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_UNDEF_INSTRUCTION, GUndefInstructionClass))
+
+
+/* Définition générique d'une instruction au comportement non défini (instance) */
+typedef struct _GUndefInstruction GUndefInstruction;
+
+/* Définition générique d'une instruction au comportement non défini (classe) */
+typedef struct _GUndefInstructionClass GUndefInstructionClass;
+
+
+/* Etat précis de l'instruction */
+typedef enum _InstrExpectedBehavior
+{
+    IEB_NOP,
+    IEB_UNDEFINED,
+    IEB_UNPREDICTABLE,
+
+} InstrExpectedBehavior;
+
+
+/* Indique le type défini pour une instruction au comportement non défini. */
+GType g_undef_instruction_get_type(void);
+
+/* Crée une instruction au comportement nominalement indéfini. */
+GArchInstruction *g_undef_instruction_new(InstrExpectedBehavior);
+
+/* Indique le type de conséquences réél de l'instruction. */
+InstrExpectedBehavior g_undef_instruction_get_behavior(const GUndefInstruction *);
+
+
+
+#endif  /* _ARCH_INSTRUCTIONS_UNDEFINED_H */